The Agentic Commerce Protocol Stack: ACP vs AP2 vs UCP vs MCP vs x402 vs MPP
Depth · Core
If you have tried to follow agentic commerce, you have hit a wall of acronyms: ACP, AP2, UCP, MCP, A2A, x402, and now MPP. 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.
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. Each layer is a distinct step in a single agentic purchase, and most protocols sit mainly in one.
Discovery
Discovery is how an agent finds what you sell and learns what it can do. Before anything is bought, the agent has to locate a merchant’s products and the tools or endpoints it can call, the machine-readable equivalent of finding the right shop and reading the shelves. This is the job of MCP.
Commerce and checkout
Commerce, or checkout, is how an agent browses, builds a cart, and completes the purchase with a merchant: selecting items, applying the cart, and running the checkout conversation. It is the heart of the transaction, and the layer where the two rival standards, ACP and UCP, compete.
Payment authorization
Payment authorization is how the agent proves a real person approved this specific purchase, and where the question of who is liable is settled. Removing the human from the checkout creates a new trust problem: a merchant or bank needs cryptographic confidence that the buyer actually consented, not just that software decided to spend. AP2 is the standard for this layer.
Settlement
Settlement is how the money actually moves once a purchase is authorized. It spans the familiar card rails and machine-native options for software paying software, including stablecoin settlement. x402 and MPP are the machine-native standards here, alongside the card networks.
Most of the protocols below sit mainly in one of these layers. They overlap at the edges, which is the source of most of the confusion.
The protocols
ACP: Agentic Commerce Protocol
Launched by OpenAI and Stripe, ACP is an open standard (Apache 2.0) for agent-to-merchant checkout. Its README describes OpenAI and Stripe as founding maintainers, while MAINTAINERS.md lists OpenAI, Stripe, and Meta as lead maintainers. A merchant implements it once, and any ACP-compatible agent can then browse, build a cart, and complete a purchase. It powered ChatGPT’s original in-conversation buying. ACP describes itself as compatible with both REST and MCP.
Layer: commerce semantics (checkout). As of mid-2026: in beta. Etsy was live from launch and Walmart announced support, but the widely cited “million Shopify merchants” never materialized, and trade reporting indicates OpenAI scaled back native in-chat checkout in early 2026. See ACP explained.
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
Launched by Google in January 2026 with backers including Shopify, Etsy, Target, Wayfair, and Walmart, UCP standardizes the broader shopping journey, from discovery through checkout to post-purchase, rather than checkout alone. It is the main rival to ACP at the commerce-semantics layer, and Google pairs it with AP2 as the payments half of its stack.
Layer: commerce semantics. Backed by: Google and major retailers.
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.
MPP: Machine Payments Protocol
Launched in March 2026 and co-authored by Stripe and Tempo, MPP is a second machine-native standard in the same lane as x402. An agent requests a resource from a service, API, or MCP endpoint, the service returns a payment request, the agent authorizes it, and the resource is delivered. It is built for microtransactions, recurring payments, and paying per API call, and it can settle in stablecoins as well as cards and buy-now-pay-later via Shared Payment Tokens. Stripe supports both MPP and x402.
Layer: settlement. See MPP explained.
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 | Google + retailers | The broader discover-to-post-purchase 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 |
| MPP | Settlement | Stripe, Tempo | Machine-native agent payments for APIs and services |
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 of these 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.