The Agentic Commerce Protocol Wars: Whoever Owns the Layer Owns Commerce

Three of the largest platforms in software shipped competing checkout standards inside ten months. Read the specifications side by side and the surprise arrives fast: they barely overlap.

Everyone reported this as a standards war, the usual story of incompatible formats and a winner-take-all fight to become the one true protocol. That framing is wrong. Google’s Agent Payments Protocol answers who authorized a purchase, OpenAI and Stripe’s protocol answers how to execute one inside a chat surface, and the Google and Shopify standard answers what is for sale and how to assemble a cart. Those are three different questions. Stack them and you get a checkout, rebuilt from scratch, as a sequence of machine protocols with no browser in the loop.

The interesting fight is not which protocol wins. It is which layer of the new checkout stack each protocol manages to own, because the layer is where the power lives.

Checkout got taken apart into machine protocols

For twenty years, checkout was a page. A human landed on a product, clicked add to cart, filled a form, and pressed a button. The entire transaction lived inside one rendered surface, and the merchant owned that surface end to end.

Agentic commerce removes the page. When an AI agent buys on a user’s behalf, there is no form to fill and no button to render. The steps that a checkout page used to bundle together get pulled apart into discrete machine operations: prove the user authorized this, find the product, build the cart, present the total, move the money, confirm the order. Each of those steps is now a protocol call, and each one is up for grabs.

This is the same unbundling that hit every other monolith, arriving at the last layer that resisted it. The storefront UI does not disappear because someone declared it obsolete. It disappears because the operations underneath it became addressable without it. Once every step of a purchase is an API a machine can call, the rendered checkout is just one optional client, and a rarely used one at that.

AP2 owns the layer of trust

Start at the bottom, because that is where the hardest problem lives. When an agent presents a card to a merchant, the merchant faces a question the card networks never had to answer at this scale: did a human actually authorize this specific purchase, or did a model hallucinate it?

Google’s Agent Payments Protocol, announced on September 16, 2025 with more than sixty launch partners including Mastercard, PayPal, Coinbase, American Express, and Salesforce, is built entirely around that question. AP2 structures a purchase into signed mandates. An Intent Mandate captures what the user authorized the agent to do. A Cart Mandate locks the exact items and price, so what the user approved is what the merchant charges. A Payment Mandate carries the authorization to the network. Each is a verifiable credential, cryptographically signed, which turns a fuzzy question of trust into a tamper-evident record any party in the chain can check after the fact.

AP2 does not care what the agent is buying or where the conversation happens. It sits underneath both, defining how agents, merchants, wallets, and payment providers coordinate around a single fact: the boundary of what the human agreed to. This is the same gap we described in why agent identity is the missing primitive, applied to money. An agent with a payment credential and no verifiable proof of intent is a liability, and AP2 is Google’s attempt to make that proof a standard field rather than a per-merchant guess.

The signal that this layer matters most came on May 26, 2026, when Google and Mastercard contributed AP2 and Verifiable Intent to the FIDO Alliance to be developed as an open, vendor-neutral standard. Companies do not donate the layers they think are commodities. They donate the layers they want everyone to build on, so their design becomes the default nobody argues about.

ACP owns the layer where the buyer already is

Move up one level, to execution. A signed mandate is worthless if the purchase never happens inside a surface the user actually visits. In 2026 that surface is a chat window, and the platform that owns the most trafficked one owns the checkout that runs there.

The Agentic Commerce Protocol from OpenAI and Stripe launched first as Instant Checkout inside ChatGPT. Its core primitive is the Shared Payment Token, which lets ChatGPT initiate a payment without ever exposing the buyer’s card credentials to the agent. An order flows from the chat surface to the merchant’s backend, and the merchant accepts or declines, charges the token, calculates tax, and handles fulfillment. The merchant stays the merchant of record. ACP is the wire between the agent surface and the merchant’s order system.

The strategic tell here is what OpenAI did next. Rather than trying to render every retailer’s full catalog inside chat, OpenAI shifted toward an app-based model in early 2026, with ChatGPT handling discovery and research while checkout increasingly routes into retailer apps and partners like Shopify and PayPal, the latter building its own ACP server. That is not a retreat. It is a company deciding it wants to own the execution layer, the moment of transaction inside its surface, and let others own the catalog. ACP answers one question well: how does a purchase execute where the user is talking, without the user leaving and without the agent touching raw payment data.

UCP owns the layer of the cart

Now the top of the stack: what is actually for sale, and how does an agent assemble a valid, priced, tax-aware cart before anyone tries to pay.

The Universal Commerce Protocol, announced by Google and Shopify on January 11, 2026 at NRF, owns that layer. Shopify’s engineering writeup on UCP describes the model plainly: merchants declare the capabilities they support, and each capability, Checkout, Orders, Catalog, is independently versioned. The protocol defines how an agent and a merchant discover and negotiate what a transaction can contain before it happens. UCP is the merchant’s machine-readable declaration of its own commerce surface.

This is the layer most native to headless thinking. A merchant running UCP is not exposing a storefront. It is exposing a typed contract describing what it sells, what a valid cart looks like, and what fulfillment options exist, and letting any agent negotiate against that contract. The rollout extended from checkout and order management into cart and product discovery, and later into a cross-retailer universal cart spanning Search, Gemini, YouTube, and Gmail. The direction is clear: UCP wants to be the catalog and cart layer that any agent on any surface reads from.

Where AP2 is payment-agnostic and ACP is surface-specific, UCP is catalog-specific. It does not care who authorized the purchase or where the chat happens. It cares that an agent can reliably learn what a merchant sells and construct a cart the merchant will honor.

Read the war as a stack, not a bracket

Put the three protocols next to each other by the layer each one owns, and the supposed war dissolves into a division of labor.

An agent-driven purchase can touch all three. UCP tells the agent what to put in the cart. ACP moves that cart to checkout inside ChatGPT and hands the merchant a scoped token. AP2 rides underneath, carrying the signed proof that the user authorized the amount, the items, and the agent acting for them. Nothing about these three specifications makes them mutually exclusive, and the partner lists openly overlap: Stripe, Mastercard, PayPal, and others appear across more than one.

This layering is not a coincidence. It is the same pattern we traced in the emerging agent protocol stack, where MCP handles tool access and A2A handles agent-to-agent coordination. AP2 is explicitly an extension designed to work with A2A and MCP, which means agentic commerce is not inventing a separate universe. It is adding a payments and catalog tier on top of the protocol stack agents already speak.

The real contest is not which protocol wins. It is which company ends up owning the layer that becomes non-negotiable, the one every other layer has to route through.

The card networks are fighting one layer below all of them

There is a fourth party in this, and it is the one with the most to lose. The card networks watched three software platforms redraw the checkout stack, and they are not sitting at the catalog or execution layer. They are fighting to keep the authorization and settlement layer, the part AP2 just standardized on top of them.

Visa’s Intelligent Commerce program leans on a delegated-authorization model, issuing tokenized Visa credentials that agents can use inside surfaces like ChatGPT. Mastercard’s Agent Pay introduces agentic tokens that bind a payment credential to a specific agent identity with per-session and per-merchant limits. As Forbes documented in its account of the networks fighting over how AI agents pay, each network is racing to ship the credential primitive that agent checkout has to use.

This is why Mastercard co-developed Verifiable Intent with Google and pushed it into FIDO alongside AP2. The networks understand the lesson the software platforms already learned. If the trust layer becomes an open standard someone else designed, the network becomes a commodity underneath it. If the network’s own token primitive becomes the thing agents must present, the network stays essential. We track how these credential primitives are shaking out in The Headless Index payments category, because the winner here sets pricing power for the next decade of machine transactions.

What this means if you build commerce backends

The practical takeaway is uncomfortable for anyone who still thinks of commerce as a storefront with an API bolted on.

Your checkout is becoming a set of protocol endpoints, and you will implement more than one. A backend that wants agent traffic will likely expose a UCP capability surface so agents can read its catalog and build carts, accept ACP orders so it can transact inside ChatGPT and other agent surfaces, and honor AP2 mandates so it can verify authorization independent of which agent showed up. These are not competing integrations you choose between. They are different layers of the same transaction, and skipping one leaves a hole an agent cannot cross.

The storefront UI is now the optional client it was always destined to become. The product is the protocol surface: the typed declaration of what you sell, the endpoint that accepts an agent’s order, the verifier that checks a signed mandate. A merchant with a beautiful checkout page and no machine-readable commerce contract is invisible to the agents doing the buying. A merchant with a strong protocol surface and no UI at all is fully in the market.

Watch where the ownership settles, because layers concentrate. The authorization layer is consolidating into FIDO, which means it will likely become a shared, boring standard nobody controls, the best possible outcome for merchants and the worst for any network hoping to tax it. The execution layer is consolidating around whoever owns the highest-traffic agent surface, which today is OpenAI and tomorrow is whoever displaces it. The catalog layer is the one still genuinely open, and it is the one merchants should fight hardest to own on their own terms, because a catalog surrendered to a single aggregator’s cart is a catalog rented back to you at their price.

The checkout page is not dying because it got ugly. It is dying because everything it used to do became a protocol, and protocols do not need a page. Whoever owns those protocols owns commerce, and that fight is being settled now, one layer at a time, mostly out of sight of the people who still think they are building websites.