Agentic commerce protocols:
ACP vs AP2 vs UCP vs WebMCP, explained and compared
ACP, AP2, UCP, WebMCP, PAP, Web Bot Auth, OSD: what each agentic commerce protocol actually does, how they fit together, and why almost none of them reach past checkout.
ACP, AP2, UCP, WebMCP, PAP, Web Bot Auth, OSD: what each agentic commerce protocol actually does, how they fit together, and why almost none of them reach past checkout.
In the last few weeks we've written about WebMCP and Zendesk's Open Service Directory, and both times we ran into the same thing: every piece of agentic commerce now seems to come with its own protocol. We promised a map. Here it is.
The short version: there isn't one protocol for agentic commerce. There's a stack of them, each doing one job. Read them by job instead of by name and they get a lot easier to follow, and the gap after checkout gets a lot easier to see.
The Agentic Protocols map
| Job | What it answers | Protocols |
|---|---|---|
| Discovery | What can I buy, and where? | UCP, ACP, MCP |
| Cart and checkout | How does the agent buy it? | UCP, ACP, WebMCP |
| Payment | Did the customer really approve this payment? | AP2, card network tokens |
| Identity and permission | Who is the agent, and who is it acting for? | Web Bot Auth, PAP, PACT, passkeys |
| Finding support | Where is this brand's real support, and how do I talk to it? | OSD, PAP, PACT, A2A Agent Cards |
| After checkout | Where is it, and can I change it? | Read-only order status, mostly |
The rest of this post walks through each row.
The part most people are missing: there are now two different ways for an agent to find a business. Zendesk's Open Service Directory is a shared directory. Sierra's PAP, Decagon's PACT and Google's A2A have each business publish a file on its own domain instead. They're not rivals so much as two halves: the directory says where a brand's real support is, and the file says how to talk to it. How those two halves come together will decide how a shopper's agent reaches you when something goes wrong.
Discovery and checkout: UCP and ACP
Two protocols cover most of the shopping itself.
- The Universal Commerce Protocol (UCP). Co-developed by Google, Shopify and others, UCP describes itself as "an open standard designed to let AI agents, apps, businesses, and payment providers interact seamlessly." It covers catalog search, carts, checkout, identity linking over OAuth 2.0 and order management, over REST or JSON-RPC, and it supports MCP, A2A and AP2. It powers checkout in Google's Universal Cart and much of what Shopify shipped this fall.
- The Agentic Commerce Protocol (ACP). Developed by Stripe and OpenAI, ACP is "an open standard for programmatic commerce flows between buyers, AI agents, and businesses." Businesses expose checkout through a REST API or MCP, and payment credentials pass to the agent without exposing the underlying card. It's open source under Apache 2.0.
ACP is also a useful reminder of how early all of this is. OpenAI launched in-ChatGPT checkout on it last year, and this spring, as McKinsey puts it, "implementation complications" reportedly "led OpenAI to scale back its instant checkout ambitions for the time being." The protocol remains. The checkout moved into retailers' own apps inside ChatGPT.
A note on names: "ACP" also refers to the Agent Communication Protocol, an unrelated project for agents talking to each other. In commerce, ACP almost always means Stripe and OpenAI's.
And MCP itself? It's the general-purpose plumbing. It lets an agent call tools, and plenty of commerce runs over it, including Shopify's Shop MCP. But as Veliu's protocol comparison points out, MCP doesn't define what a product, a payment or an order is. UCP and ACP do.
Checkout in the browser: WebMCP
WebMCP is the odd one out. UCP and ACP connect an agent to a platform's APIs from anywhere. WebMCP lets the page the shopper already has open register tools, like add_to_cart and complete_checkout, for an agent in that same browser. It's a W3C community group draft, live on every Shopify storefront and Stripe Checkout, and on BigCommerce stores through Cloudflare.
Payment: AP2 and the card networks
Checking out isn't the same as paying, and that's the job of Google's Agent Payments Protocol (AP2). It extends A2A and UCP, and records consent as signed mandates: a Checkout Mandate for "the reference to the specific items and purchase details," and a Payment Mandate that "authorizes a payment against a specific payment instrument." Its standardization is continuing in the FIDO Alliance.
The card networks are doing their part too. Shopify says agent purchases with Shop Pay use network tokens from Mastercard, Visa and Discover, so the card itself is never shared with the agent.
Identity and permission: Web Bot Auth, PAP, PACT and passkeys
Three pieces answer "who's who," and they're easy to mix up:
- The agent. Web Bot Auth, an IETF draft from authors at Cloudflare and Google, has an agent cryptographically sign its HTTP requests, so a site knows which agent is calling.
- The delegation. Sierra's draft Personal Agent Protocol (PAP) covers who the agent is acting for, and what it may do. The agent signs in with "a session token that grants only the access the customer approved." Its example: a retailer that lets an agent "start a return but not change the payment details on file." Decagon's PACT, the Personal Agent Consent & Trust Protocol, does the same job on top of A2A and OAuth 2.0: the agent proves who it is with a signed token, and the customer approves specific scopes with the business. Decagon says it's joining the PAP working group, so the two may well converge.
- The customer. Passkeys, built on WebAuthn, let the customer approve on their own device without ever handing an agent a password.
Finding a brand: directories vs. well-known files
When an agent needs help with an order, it first has to find the brand's real support. There are now two ways to do that.
A shared directory. Zendesk's Open Service Directory is "a specification and public directory of verified support destinations," built on the Agentic Resource Discovery (ARD) spec. The agent looks the brand up once, and the directory has already checked the listing against the brand's domain and screened it for impersonation. We covered it in depth in our Open Service Directory (OSD) post.
A file on the brand's own domain. The others put discovery on the business itself, at a standard address:
- PAP: "Companies publish one file at a standard address on their website (
/.well-known/poppy.json)," which "tells personal agents how to interact with the company, how customers can sign in, and what the agent can do." - PACT: the agent reads the business's A2A Agent Card, which advertises its endpoint, how to authenticate and which permissions are available.
- A2A Agent Cards themselves live at
/.well-known/agent-card.jsonand describe any agent: its skills, capabilities and endpoints. - UCP does the same for commerce, with a store profile at
/.well-known/ucp.
Two halves of the same answer. A directory is good at trust: one lookup, already verified. A file is good at control: the brand decides how agents sign in and what they're allowed to do. That's why Zendesk describes OSD as complementing PAP, PACT and UCP rather than replacing them. The likely future is both: the directory gets the agent to the right brand, and the brand's own file tells it how to talk to support.
It's still early. These are mostly drafts and specs, and few brands publish these files yet. But the work behind them isn't technical. It's policy: what an outside agent may see, what it may change, and when it goes to a person. That's worth deciding before the first agent asks.
Two layers, one sentence. The directory decides which door is the real one. Zendesk Bridge decides what each side is allowed to do once it's through. (From our AI Summit recap.)
After checkout: the empty row
Now look at the last row of the map.
- UCP has an order capability, with webhooks for status updates, shipment tracking and return processing. The agent hears about a return. It doesn't start one.
- Shopify's Order MCP gives an agent one read-only tool,
get_order, for orders it placed. - WebMCP stops at a tool that opens the order history page.
- ACP and AP2 stop at the purchase and the payment.
- PAP is the one exception in spirit: its own example is a return. But it defines how the agent gets permission, not what a return is.
Veliu's comparison comes to the same conclusion from the payments side: across the protocols, settlement and disputes are the least covered steps. It also asks the question every brand should be asking its providers: "When an authorized agent transaction fails after cart approval, who contacts the customer and who reverses the funds?"
So every protocol on the map can tell an agent where an order is. None of them defines how to change it: start the return, approve the exchange, change the address, reissue the gift card, or reverse the loyalty points. As Veliu puts it: "The merchant still has to operate the complete sale."
Sources
- https://www.agenticcommerce.dev/
- https://ap2-protocol.org/
- https://ucp.dev/
- https://webmachinelearning.github.io/webmcp/
- https://sierra.ai/blog/poppy
- https://www.ietf.org/archive/id/draft-ietf-webbotauth-httpsig-protocol-00.html
- https://www.w3.org/TR/webauthn-3/
- https://www.zendesk.com/blog/product-news/open-service-directory/
- https://decagon.ai/blog/introducing-the-personal-agent-consent-trust-protocol-pact
- https://openpactprotocol.org/
- https://shopify.dev/docs/agents/orders/order-mcp
- https://veliu.com/en/blog/agentic-commerce-protocol-comparison
- https://www.mckinsey.com/capabilities/growth-marketing-and-sales/our-insights/who-wins-when-ai-does-the-shopping-new-evidence-on-agentic-commerce
Keep reading
All posts →Blog
Agentic checkout is here: What UCP and October's AI innovations mean for your eCommerce brand
In three weeks, Google, Shopify, Salesforce and Commerce.com all opened checkout to AI agents, much of it over the Universal Commerce Protocol (UCP).
Engineering
Zendesk's Open Service Directory: How Personal AI Assistants find Customer Support
Zendesk's Open Service Directory gives personal AI assistants a verified way to find a brand's official support. Here's how it works, what it isn't, the open questions, and what commerce brands need behind it.
Engineering
WebMCP for agentic commerce: Shopify and Stripe made checkout agent-ready. Post-purchase is next.
Every Shopify store and Stripe Checkout page now exposes WebMCP tools, so browser agents call functions instead of reading pages. Here's what that changes, what it does for brands, and the gap it still leaves after checkout.


