// protocol_stack
UCP, ACP, AP2, x402 and MCP get written up as a standards war. They are not. They sit at different layers and answer different questions, and a merchant serious about agentic traffic will end up implementing several of them. This is the map, plus the part nobody writes down: what you actually have to build, and where it breaks in regulated commerce.
UCP tells an agent what a merchant can do and drives the order through a checkout state machine. ACP gets a merchant's catalogue in front of buyers inside ChatGPT — and since March 2026 it hands checkout back to the retailer. AP2 answers a different question entirely: proving who authorized a purchase, with signed mandates a merchant can produce in a dispute. x402 settles machine-to-machine payments too small for card rails. MCP and A2A are transport — how the agent reaches any of it. The overlap between them is far smaller than the coverage suggests.
“What can this merchant do, and which of it can my agent use?”
Merchants publish a capability profile at /.well-known/ucp. Agents pass their own profile URL with each request and the merchant computes the intersection. Namespaces use reverse-domain naming, so a vendor owns com.example.* by owning the domain — no central registry, no approval queue.
“How does a cart become an order without a browser?”
UCP models checkout as a state machine: incomplete when required data is missing, requires_escalation when a human has to intervene (the merchant hands back a continue_url), ready_for_complete when the agent can finalise programmatically. Escalation uses the Embedded Checkout Protocol — bidirectional JSON-RPC 2.0 between agent and merchant.
“Who actually authorized this purchase, and can the merchant prove it?”
A Mandate is a W3C Verifiable Credential — tamper-evident, portable, cryptographically signed. A user gives a high-level instruction as a signed Intent Mandate; when the agent finds something matching, the merchant generates a Cart Mandate that the user signs with a hardware-backed key. That signature chain is what a merchant presents in a dispute.
“How does value actually move, especially for machine-to-machine?”
Revives HTTP 402 Payment Required: an agent hits a paid endpoint, gets a 402 with payment details, settles in stablecoin, and retries with a receipt header. Built for per-call API and data payments too small to run through card rails, not for retail baskets.
“How does the agent reach any of this in the first place?”
Neither is a commerce protocol, and conflating them with the four above is the most common mistake in this space. MCP connects a model to tools and data; A2A lets agents delegate to each other. A UCP integration is very often exposed to an agent as an MCP server — they compose, they do not compete.
OpenAI launched Instant Checkout in September 2025 and retired it in March 2026. The stated reason was flexibility — the initial version “did not offer the level of flexibility that we aspire to provide.” The adoption numbers tell it more plainly: roughly 30 Shopify merchants had completed onboarding, and fewer than 200,000 Walmart products were reachable through it.
The engineering lesson is worth stating directly, because it applies to whichever protocol you are evaluating next: the checkout API was never the hard part. Onboarding was. Every merchant integration ran into the same three questions — who owns the customer relationship, who holds the order data, and who eats the chargeback when an agent bought the wrong thing. A protocol can specify the request and response. It cannot specify the answer to any of those, and that is why a technically complete integration still stalled at thirty merchants.
ACP did not die with Instant Checkout — it pivoted. The current model is discovery-first: merchants publish structured catalogue data, ChatGPT surfaces it, and the buyer completes the purchase in the retailer's own environment. If you scoped an ACP project around a checkout integration, the work has changed shape entirely, and mostly shrunk.
A document at /.well-known/ucp declaring supported capabilities, extensions and payment handlers. Extensions use reverse-domain names you own, so no registry gates you.
Correct price, real-time availability, resolvable identifiers. This is where most projects stall — agents are unforgiving about stale stock data in a way a human browsing a page is not.
The state machine, including the escalation path: when a human must intervene, you return a continue_url rather than failing the session.
Whether you accept AP2 mandates as proof of intent, how you verify the signature chain, and what you present when an agent-placed order is disputed.
Every protocol here assumes that once intent is proven, the buyer may transact. That assumption does not survive contact with regulated or contract-governed purchasing. A pharmaceutical order needs licence verification and DSCSA traceability before it is legal, not merely authorized. A B2B order needs contract pricing rather than list price, formulary and approved-vendor rules, and an approval threshold above which no agent may commit spend no matter what the user signed.
AP2 is a reasonable substrate for this, because a mandate can carry constraints and is verifiable after the fact. But the policy engine that evaluates those constraints against your contracts, licences and thresholds is yours to build — the protocol gives you the envelope, not the rules. That is the same shape as the authorization problem covered in AI agent authentication, applied to money instead of API scope.
They answer different questions, which is why a merchant can end up implementing all three. UCP (Google and Shopify) covers discovery and the checkout lifecycle: what a merchant supports, and how a cart becomes an order. ACP (OpenAI and Stripe) covers merchant presence inside an AI surface — since March 2026 it is discovery-first, handing the actual checkout back to the retailer. AP2 (Google, now under the FIDO Alliance) covers authorization: cryptographic proof of who approved a purchase and on what terms. Treating them as rival standards is a category error — the only genuine overlap is checkout, where UCP and ACP have now diverged in approach rather than competing head-on.
No, and they operate at different layers. MCP is a transport for connecting a model to tools and data; UCP is a domain protocol describing what a merchant can do and how an order progresses. In practice a UCP integration is frequently surfaced to an agent as an MCP server, so an agent discovers the merchant through MCP and then speaks UCP semantics over it. If you already run an MCP server, that is the natural place to expose UCP capabilities rather than a parallel integration.
OpenAI launched Instant Checkout in September 2025 and retired it in March 2026, stating that the initial version "did not offer the level of flexibility that we aspire to provide" and that merchants would use their own checkout experiences while OpenAI focused on product discovery. The adoption numbers explain the retreat better than the statement does: roughly 30 Shopify merchants had completed onboarding and fewer than 200,000 Walmart products were live. The hard part was never the checkout API — it was merchant onboarding and the question of who owns the customer relationship, the order data and the liability. ACP itself did not die; it pivoted to a discovery-first model where retailers keep checkout, loyalty and customer data.
At minimum: a capability profile at /.well-known/ucp declaring what you support; a product feed clean enough that an agent can match a query to a SKU with correct price and availability; checkout endpoints that implement the session state machine including a continue_url path for escalation to a human; and a decision about payment authorization — whether you accept AP2 mandates as proof of intent, and what you do in a dispute when the buyer was an agent. The feed is where most projects actually stall. Agents are unforgiving about stale price and stock data in a way that a human browsing a product page is not.
Mostly not. x402 is built for machine-to-machine payments too small or too frequent to route through card rails — per-call API access, data, compute. Retail baskets settle on the existing card networks, which is why Visa, Mastercard, Stripe and American Express are in the UCP coalition and why AP2 was donated to the FIDO Alliance rather than built on a chain. x402 matters if you sell access to something an agent consumes directly, and it is worth watching regardless because it is the only one of these protocols where agents pay agents without a human in the loop at all.
Not out of the box. Every one of them assumes the buyer may transact once intent is proven, which is the wrong model for regulated and contract-governed buying. Pharmaceutical distribution needs licence verification and DSCSA traceability; B2B needs contract pricing rather than list price, formulary and approved-vendor rules, and approval thresholds above which no agent should be able to commit spend regardless of what the user authorized. AP2 mandates are a reasonable substrate for that — a mandate can carry constraints — but the policy layer that evaluates those constraints against your contracts and licences is something you build, not something the protocol gives you.
Follow the traffic. If your buyers are in Google Search AI Mode and Gemini, UCP is where the volume is and the discovery layer is the part to get right first. If they are in ChatGPT, ACP now means feed quality and product discovery rather than a checkout integration, which is considerably less work than it was a year ago. AP2 becomes urgent the moment you accept an order that no human clicked a button to place — before that it is a design consideration rather than a dependency. In every case the product feed is the prerequisite, so that is the work that pays off no matter which surface wins.
Primary sources for every claim above, last checked August 21, 2026. Specs at this stage move monthly — check the date before relying on any of it.
Capability discovery, profile negotiation, checkout state machine, Embedded Checkout Protocol.
AP2 v0.2, donation dated 28 April 2026, human-not-present payments, Verifiable Intent with Mastercard.
Mandates as W3C Verifiable Credentials; Intent and Cart mandate flow.
ACP, co-developed with OpenAI.
March 2026 retirement of Instant Checkout and the pivot to discovery.
HTTP 402 settlement flow for machine-to-machine payments.