Three protocols shape how AI agents interact with commerce, and the cleanest way to understand them is by the layer each centers on. MCP (Model Context Protocol), from Anthropic, is the connection layer: how an agent reaches a tool or data source at all. UCP (Universal Commerce Protocol), co-developed by Google and Shopify and launched in January 2026, is the discovery-and-catalog layer: how your products are described so an agent can find and compare them. ACP (Agentic Commerce Protocol), co-developed by OpenAI and Stripe in late 2025, centers on the transaction layer: how an agent completes a purchase, and it powers checkout inside ChatGPT. The honest nuance: UCP and ACP are full-journey protocols from competing camps, not tidy non-overlapping layers, and both build on MCP. But most stores still need to be legible to all three. This is what each one centers on, who is behind it, and what to implement first.
The protocol naming is a mess and it makes people think these three are alternatives to choose between. The truth is more layered. MCP is genuinely a different layer: it is the generic connection substrate the commerce protocols ride on. UCP and ACP, though, are not neat floors above it; they are competing full-journey commerce standards from rival camps, Google and Shopify behind UCP, OpenAI and Stripe behind ACP, that happen to be interoperable and both lean on MCP underneath. So the useful mental model is a layered stack for understanding what each one centers on, with the caveat that the top two overlap more than a tidy diagram suggests.
An agent that wants to buy something on behalf of a user has to do three distinct things regardless of which camp's protocol it speaks. It has to connect to your systems, understand and compare your catalog, and execute a transaction. MCP centers on the first, UCP on the second, ACP on the third. Getting that center-of-gravity right is what makes the implementation order obvious, even though UCP and ACP each reach across more of the journey than their center implies.
MCP: the connection layer
The Model Context Protocol, introduced by Anthropic and now widely adopted, is the lowest layer, the one that defines how an AI model connects to external tools and data at all. It is not commerce-specific. MCP is the standard for exposing any capability to an agent: a database, an API, a file system, or a store's backend. When an agent needs to reach your systems, MCP is the protocol that defines how that connection is structured, what the agent can request, and how your system responds.
For commerce, MCP matters because it is the substrate. If you expose your catalog or your transaction capability to agents, you are likely doing it over an MCP-style connection. But MCP itself does not know anything about products or purchases. It is generic plumbing. Thinking of MCP as a commerce protocol is the first category error; it is the layer commerce protocols ride on. The broader role of MCP in the emerging inference economy is about far more than shopping, which is exactly why it sits underneath the commerce-specific layers rather than alongside them.
UCP: the catalog layer
The Universal Commerce Protocol, co-developed by Google and Shopify and launched at NRF in January 2026 with a coalition including Etsy, Target, Walmart, and Wayfair, centers on discovery and catalog. It defines how your products are described so an agent can find them, compare them against alternatives, and decide whether they fit the user's request, and it reaches forward into checkout and post-purchase too. The catalog work is where most stores get the biggest early gain, because it is the layer that looks like it overlaps with existing product schema and mostly does not.
UCP is concerned with making your catalog machine-legible at the level an agent needs: not just a name and price, but the structured attributes that let an agent reason about fit. Can this product ship to the user's country, is it in stock, what are its specifications in comparable units, what variants exist. An agent comparing five products across three stores needs all of them described in a way it can line up. A store with rich human-facing product pages but thin machine-facing structure is invisible at this layer, the same way a JavaScript-rendered page is invisible to a non-rendering crawler. UCP is already wired into Google AI Mode in Search and the Gemini apps, so this legibility is what decides whether you surface when a shopper asks those surfaces to find a product. The full UCP implementation guide covers the field-level requirements, and the gap between "has product pages" and "is UCP-compliant" is where most catalogs fail.
ACP: the transaction layer
The Agentic Commerce Protocol, co-developed by OpenAI and Stripe and released in late 2025, centers on the purchase itself. It is the standard behind Instant Checkout in ChatGPT. ACP defines how an agent completes a transaction: what your checkout must accept, what it must return, how payment and confirmation flow when the buyer is an agent acting for a human rather than a human clicking buttons. It composes with the other layers rather than replacing them; an agent can discover via one camp and transact via another.
This is the newest and most consequential layer, because it is where the money moves. An agent that can find your product but cannot transact with it sends the user elsewhere to buy, which means you did the catalog work and lost the sale at the last step. ACP compliance is what turns "the agent recommended you" into "the agent bought from you." The transaction schema and BuyAction structure underpin how an agent initiates a purchase, and this layer is moving fast as the major platforms publish their specs.
Why you need all three
The practical reason to care about all three is that the agent ecosystem is split across camps, and you do not control which one a given shopper's agent speaks. A shopper in Google AI Mode reaches you through UCP; a shopper in ChatGPT reaches you through ACP. Being legible to only one camp means being invisible to the other's users. And within either path the same logic holds: an agent that cannot understand and compare your catalog cannot confidently choose you, and an agent that can choose you but cannot complete the transaction routes the purchase away. Discovery legibility and transaction readiness are both required; the camps just package them differently.
The contrarian point most ecommerce teams miss: being recommended is not the same as being bought from, and the gap between them is transaction readiness. A lot of early agentic-commerce effort goes into being discoverable and comparable and stops there. That gets you into the agent's consideration set and then loses the transaction to whichever competitor was ready to complete the checkout the agent wanted to drive. Discoverability without transactability is a sale you hand to someone else.
What to implement first
The dependency order and the value order point the same way, with one twist. MCP is foundational but often handled by your platform or a connector rather than built from scratch, so for most stores the real work starts at UCP. Get your catalog machine-legible first, because an agent that cannot understand you cannot do anything else with you, and because UCP compliance also improves your standing in the discovery and comparison stage that feeds everything downstream.
Then transaction readiness, because that is where the catalog work converts to revenue, and prioritize the camp your buyers actually use: ACP if your demand is coming through ChatGPT, UCP checkout if it is coming through Google AI Mode, and both if you are large enough to be reached from either. Building transaction support before your catalog is legible is the common mistake, because the ability to transact sits idle if agents cannot first choose you. Catalog first, transaction second, connection layer handled by your infrastructure underneath. The stores that win the agentic commerce wave treat this as a sequence to complete, while staying legible to whichever camp the shopper's agent belongs to.
Sources
- Model Context Protocol, official specification: the connection-layer standard and its scope. modelcontextprotocol.io
- Universal Commerce Protocol (Google and Shopify): the discovery-and-catalog standard launched at NRF 2026. developers.googleblog.com
- Agentic Commerce Protocol (OpenAI and Stripe): the spec for agent-initiated purchases, behind ChatGPT Instant Checkout. agenticcommerce.dev
- Schema.org, Offer and product structures: the underlying vocabulary catalog description builds on. schema.org/Offer
- Website AI Score, UCP implementation guide: the field-level catalog requirements. View article
- Website AI Score, agentic transaction schema: the BuyAction structure for the transaction layer. View article
