The Agentic Commerce Protocol Stack: ACP vs AP2 vs UCP vs MCP vs x402
If you have tried to follow agentic commerce, you have hit a wall of acronyms: ACP, AP2, UCP, MCP, A2A, x402. They are not competing versions of the same thing. They solve different parts of one problem: how an AI agent can discover a product, agree on a cart, prove a real person authorized the purchase, and move the money, all without a human clicking a checkout button.
This page is a neutral map. It explains what each protocol does, who is behind it, and how they stack together.
Editor’s note: Figures and adoption claims below reflect reporting as of June 2026 and should be verified against primary sources before publication.
The mental model: four layers, not one standard
The cleanest way to make sense of the acronyms is to separate them by the job they do:
- Discovery and capability — how an agent finds products and learns what an endpoint can do.
- Commerce semantics — how an agent browses, builds a cart, and runs a checkout with a merchant.
- Payment authorization — how the agent proves a real user approved a specific purchase, and who is liable.
- Settlement — how value actually moves, including machine-to-machine and stablecoin rails.
Most of the protocols below sit mainly in one layer. They overlap at the edges, which is the source of most of the confusion.
The protocols
ACP — Agentic Commerce Protocol
Maintained by OpenAI and Stripe, ACP is an open standard (Apache 2.0) for agent-to-merchant checkout. A merchant implements it once, and any ACP-compatible agent can then browse, build a cart, and complete a purchase. It is the protocol behind ChatGPT’s in-conversation buying. ACP also exposes an integration hook for MCP, so agents can discover a merchant’s checkout capability as a tool.
Layer: commerce semantics (checkout). As of mid-2026: in beta but live, with early merchants including Etsy, a large set of Shopify merchants, and Walmart.
AP2 — Agent Payments Protocol
Announced by Google in September 2025 with 60+ launch partners (including Mastercard, PayPal, American Express, Coinbase, and Salesforce), AP2 is a vendor-neutral standard for payment authorization. It represents each purchase as three cryptographically signed mandates: an Intent Mandate (what the user wanted), a Cart Mandate (what the agent assembled), and a Payment Mandate (what gets charged). The point is trust: proving to a merchant or network that a real user consented to a specific amount.
Layer: payment authorization and trust. Backed by: Google plus major networks and PSPs.
UCP — Universal Commerce Protocol
UCP aims to standardize the commerce semantics layer — how agents discover, cart, and check out across merchants — with an emphasis on being neutral across platforms. It overlaps with ACP on checkout, and the two are often discussed together as the “commerce” half of the stack, with AP2 as the “payments” half.
Layer: commerce semantics. Note: confirm current sponsors and status before publication.
MCP — Model Context Protocol
From Anthropic, MCP is not a commerce protocol at all. It is the broader standard for how agents discover and call tools and data sources. In commerce, it acts as the discovery layer: an ACP-aware merchant can advertise its checkout as an MCP tool, so agents find it the same way they find any other capability.
Layer: discovery and capability.
A2A — Agent-to-Agent
A2A standardizes how independent agents talk to each other and delegate tasks. In a commerce flow, it matters when a buyer’s agent negotiates or coordinates with a merchant’s agent rather than calling a fixed endpoint.
Layer: agent coordination.
x402 — machine-native payments
x402 revives the long-dormant HTTP 402 Payment Required status to let software pay for resources programmatically, typically with stablecoins, in amounts and at frequencies that card rails handle poorly. It is the settlement option for machine-to-machine and micro-transaction use cases rather than consumer retail checkout.
Layer: settlement.
Side-by-side
| Protocol | Primary layer | Backed by | Best thought of as |
|---|---|---|---|
| ACP | Commerce semantics (checkout) | OpenAI, Stripe | The agent-to-merchant checkout standard |
| AP2 | Payment authorization | Google + networks/PSPs | The proof that a user authorized the purchase |
| UCP | Commerce semantics | Multi-party (verify) | A neutral discover-cart-checkout layer |
| MCP | Discovery / capability | Anthropic | How agents find the checkout in the first place |
| A2A | Agent coordination | Multi-party | How buyer and merchant agents talk |
| x402 | Settlement | Coinbase ecosystem | Machine-native, stablecoin micropayments |
How they fit together
In practice these are complementary, not rivals. A realistic flow: an agent discovers a merchant’s checkout via MCP, runs the checkout via ACP or UCP, attaches an AP2 mandate to prove the user authorized it, and settles over card rails or, for machine-to-machine cases, x402. The reason there is no single winner is that no one standard spans discovery, semantics, authorization, and settlement at once.
What it means for you
Merchants: you do not have to bet on one acronym. The pattern emerging is checkout (ACP/UCP) plus authorization (AP2). Implementing ACP gets you into ChatGPT’s buying surface today; supporting AP2 mandates prepares you for the liability and trust questions that follow.
Builders: treat the stack as layered. Use MCP for discovery, a commerce protocol for the cart, AP2 for signed authorization, and pick a settlement rail per use case.
Decision-makers: the strategic question is not “which protocol wins” but “which layer is your moat.” Networks are fighting over authorization; model providers are fighting over the checkout surface; the merchant’s job is to be present and verifiable across both.
FAQ
Is ACP or AP2 going to win? They address different layers, so the likely outcome is coexistence: ACP/UCP for checkout, AP2 for authorization. Watch for convergence at the edges rather than a single victor.
Do I need all six protocols? No. Most real deployments touch two or three: a discovery layer, a checkout layer, and an authorization layer. Settlement depends on your use case.
Where does MCP fit if it is not a commerce protocol? It is the discovery plumbing. Agents use MCP to find capabilities, including a merchant’s checkout, before any commerce protocol runs.