Comparison

UCP vs MCP vs A2A vs ACP.

They are not four competitors for one job. Each answers a different question, which is why "which protocol wins" is the wrong question and "which of my buyers is blocked" is the right one.

See Which You Need First

The four

One question each.

The fastest way to tell them apart is the question each one exists to answer. Once you know which question is blocking revenue, the choice makes itself.

UCP: “Can an agent buy this product from this merchant?”; What you expose

A discovery manifest, checkout sessions, payment handlers, order management

Who consumes it

Shopping assistants that complete a purchase for a consumer

Right choice when

You sell to consumers and want assistants to complete the order rather than hand the shopper back to your site.
ACP: “Can this assistant hand me an order and a scoped payment token?”; What you expose

Order payloads, delegated payment tokens, merchant remains seller of record

Who consumes it

ChatGPT Instant Checkout

Right choice when

Your buyers are in ChatGPT and you want the purchase to complete inside the conversation.
MCP: “What tools can this model call, and what do they return?”; What you expose

Tool definitions with typed inputs and outputs, served by your systems

Who consumes it

Any MCP-capable assistant or internal agent

Right choice when

You want models to query catalogue, pricing, or account data — including your own internal agents and B2B buyers.
A2A: “Which agent am I talking to, and what is it allowed to negotiate?”; What you expose

Agent cards, capability negotiation, multi-step workflows across organizations

Who consumes it

A buyer's procurement agent talking to a supplier's commerce agent

Right choice when

You sell B2B and the counterparty is an organization's agent, not a person.

In practice

What each one looks like on the wire.

A UCP manifest declares commerce capability. An MCP tool declares a callable function. The difference in shape is the difference in purpose.

.well-known/ucp json

{
  "version": "1.0.0",
  "discovery": {
    "endpoint": "/api/ucp/discover",
    "supported_agents": [
      "google-gemini",
      "openai-gpt"
    ]
  },
  "checkout": {
    "mode": "agent_delegated",
    "providers": ["stripe", "adyen"]
  }
}

mcp-tools.json json

{
  "name": "search_catalog",
  "description": "Search products with
    account pricing applied.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" },
      "accountId": { "type": "string" },
      "maxPrice": { "type": "number" }
    },
    "required": ["query"]
  }
}

Sequencing

Which one first.

Ordered by who your buyer is, not by which protocol is newest. The last row is the one most agencies will not show you.

DTC brand, consumers ask assistants what to buy: UCP first, ACP next; Discovery and checkout for consumer assistants. ACP adds the ChatGPT surface specifically.
Enterprise retail on SFCC, mixed B2C and B2B: UCP, then MCP; UCP opens the consumer channel; MCP exposes catalogue and account pricing to business buyers' models.
B2B distributor, buyers run procurement systems: A2A and MCP; UCP later; Your counterparties are agents with purchasing policy, not shoppers. Consumer checkout is not the bottleneck.
Marketplace or aggregator: MCP first; Your value is query and comparison across sellers before any single checkout matters.
You only want to be cited, not transacted with: None of them; That is GEO and structured data work. Protocols cost money and change nothing about whether a model names you.

Questions

Asked most often.

What is the difference between UCP, MCP, and A2A?

UCP is a commerce protocol: it defines how an AI agent discovers products, creates a checkout session, pays, and tracks an order at a specific merchant. MCP is a tool protocol: it defines how a model calls typed functions your systems expose, commerce or otherwise. A2A is an inter-agent protocol: it defines how two organizations' agents identify each other, negotiate capabilities, and run multi-step workflows. UCP answers 'can an agent buy this', MCP answers 'what can a model ask my systems', A2A answers 'which agent am I dealing with and what may it do'.

Do I need all four protocols?

Almost nobody does. Consumer retail usually starts with UCP and adds ACP for the ChatGPT surface. B2B usually starts with MCP and A2A and may never need consumer checkout. Implementing all four at once is the most common way to spend a year and open no channel — sequence them against where your buyers actually are.

Does implementing UCP replace my storefront?

No. UCP sits alongside the storefront and uses the same catalogue, pricing, tax, and payment provider. You remain the merchant of record. It adds a second way to reach checkout, it does not migrate the first one.

Which protocol should a Salesforce Commerce Cloud brand implement first?

UCP, via OCAPI or SCAPI, because it opens the consumer channel with the catalogue and checkout you already run. MCP is the natural second step if you have B2B accounts with negotiated pricing. Our SFCC cartridge implements the UCP path and is MIT-licensed, so you can read exactly what it touches before deciding.

Is any of this settled? Should I wait for a winner?

The protocols are not competing for the same job, so there is no single winner to wait for — a shopping assistant completing a consumer order and a procurement agent negotiating a contract price are different problems. What does change is which assistants support what, so the cost of waiting is not a wasted implementation, it is the quarters where competitors are the only ones a model can transact with.

Protocol Implementation UCP on SFCC, in detail