ACP Moved Checkout to the Merchant Surface. It Didn't Cede Commerce - Here's the Protocol Convergence.

Updated July 2026: this article originally ran as "ACP Pivoted from Checkout to Discovery. UCP Wins by Default." That call was wrong. ACP's March pivot moved the checkout **surface, not the checkout **capability* - and the 2026-04-17 spec release that landed weeks after this article was published added carts, an orders lifecycle, a public product feed spec, its own /.well-known/acp.json discovery document and MCP transport. ACP is not a discovery-only layer. The sections below are corrected; the implementation advice about UCP profile quality stands.*

In March 2026, OpenAI pivoted ACP (Agentic Commerce Protocol) away from its original premise: completing purchases inside ChatGPT. The "Instant Checkout" button that was supposed to revolutionize shopping? Narrowed. Replaced by a merchant app model where purchases complete on the retailer's own storefront.

That was widely read - including here - as ACP retreating to discovery and handing the commerce stack to UCP. Four months later, that reading has not held up.

What actually happened

OpenAI's ACP launched with an ambitious vision: users would discover products, compare options, and complete purchases entirely within ChatGPT. Stripe provided the payment rails. The promise was a seamless, one-tap checkout experience inside an AI conversation.

The in-chat version of that didn't work.

CNBC reported on March 20 that "OpenAI's first try at agentic shopping stumbled." Users browsed products in ChatGPT but abandoned purchases before completing them. The in-chat checkout experience lacked sales tax infrastructure, return policy visibility, and the trust signals that mature e-commerce storefronts provide.

The pivot, detailed by Digital Commerce 360 on March 24, shifts where checkout renders:

• Dedicated retailer apps inside ChatGPT (Instacart, Etsy, Shopify, Walmart)
• Product discovery and comparison happens in-chat
• Purchase completion happens on the merchant's own storefront (in-app browser on mobile, separate tab on desktop)

The commentary at the time framed this as a demotion. Roger Dunn wrote that "ACP's role shifts from universal long-tail merchant connector to plumbing for deep, bespoke retailer partnerships." Ken Huang's Substack went further: "Google's UCP Just Won Agentic Commerce."

Then OpenAI shipped the 2026-04-17 spec release, and the demotion thesis fell apart.

What ACP actually shipped after the pivot

The 2026-04-17 release is the largest in ACP's history. It added:

• Carts (rfc.cart) - merchant-hosted, pre-checkout basket building
• Orders (rfc.orders) - a full order lifecycle with fulfillments and adjustments
• A public product feed spec (rfc.product_feeds) - the feed model is now public
• /.well-known/acp.json (rfc.discovery) - ACP's own discovery document, structurally the same move UCP made with /.well-known/ucp
• Delegate authentication (rfc.delegate_authentication) - 3DS2 browser-based auth delegation
• MCP transport - an OpenRPC binding so agents can speak ACP over MCP
• Mandatory idempotency keys, marketing consent, decimal quantities

Carts and orders are not discovery primitives. They are the transaction layer. A protocol that ships a cart model, an order lifecycle and delegated authentication six weeks after "retreating from checkout" is not retreating from checkout - it is moving the checkout UI to a surface merchants already control while keeping the protocol underneath.

The protocol math - corrected

Before the pivot (January - February 2026):

• UCP: Discovery + browsing + cart + checkout, completed in the agent surface
• ACP: Discovery + Instant Checkout completed inside ChatGPT

After the pivot and the April spec release:

• UCP (latest 2026-04-08): Discovery + browsing + cart + checkout, agent-completed, identity linking, payment handlers
• ACP (latest 2026-04-17): Discovery + feeds + cart + orders + delegated payment, with the final purchase step rendered on the merchant surface

The protocols are converging structurally, not splitting into layers. Both now have a .well-known discovery document. Both have a cart model. Both have an orders/checkout lifecycle. They differ in architecture - UCP starts from a JSON manifest agents parse, ACP is a server-to-server REST API the agent calls - and in who completes the final step.

The clearest evidence that "pick the winner" is the wrong frame: Microsoft Copilot is deliberately dual-protocol. It added UCP feeds and UCP-powered checkout in April 2026 while continuing to consume ACP-side Shopify Catalog data. It did not switch. It added.

What this means for developers building today

Implement UCP if you want agent-completed checkout. It's co-created by Google and Shopify with 20+ partners, and it's what Google AI Mode, Gemini, Google Maps, YouTube Shopping and Microsoft Copilot use to discover and transact with stores. The full capability set - catalog browsing, cart, identity linking, payment handlers - is agent-side.

Implement ACP if you want ChatGPT reach - and treat it as a transaction protocol, not a billboard. Feed quality decides whether ChatGPT surfaces your products at all, and the checkout endpoints plus delegated payment decide whether the purchase completes. Payment is an open delegated model: Stripe first, Adyen in the provider enums, PayPal building.

If you have reach ambitions, the honest answer is both. That is what the dual-protocol merchants are doing.

The real implementation gap isn't protocol choice. It's quality. Most deployed UCP profiles fail at basic validation levels:

• Missing signing_keys means agents can't verify your manifest
• Namespace/origin mismatches break discovery before it starts
• Incomplete Cart capability definitions create failed add-to-cart experiences
• Identity Linking (the stable spec) is the least-implemented capability despite being the most valuable for cross-domain user recognition

At UCPtools, we scan thousands of profiles. The average score sits well below what AI agents consider reliable. Being "detected" is not the same as being "buyable."

What to build

1. Implement UCP on your primary store domain first. The .well-known/ucp manifest is table stakes. Make sure it validates at all four levels: structural JSON validity, business rules consistency, network reachability, and SDK-level agent simulation.

2. Don't skip Identity Linking. It's the stable spec that enables cross-domain user recognition. When a user browses your store on one device and returns via an AI agent on another, Identity Linking is what connects those sessions. Note that the 2026-04-08 UCP revision declares it via config.scopes with PKCE S256 mandatory - validate against whichever version your profile declares.

3. Treat ACP as a full protocol surface. Publish a clean product feed, stand up the checkout endpoints, and make sure /.well-known/acp.json is reachable. The handoff to your storefront is a UX decision by OpenAI, not a reason to implement half the protocol.

4. Monitor continuously. Protocols evolve - this article is itself an example of how fast a confident read can go stale. Your profile that validated perfectly in April might fail in June when a capability gets promoted from draft to stable. Continuous validation catches regressions before they cost you AI agent traffic.

The bottom line

There is no protocol war with a winner. ACP moved its checkout surface and then expanded its transaction layer. UCP shipped its own April revision. Microsoft runs both on purpose.

The question for e-commerce developers isn't which protocol to bet on - it's whether your implementation of either one is good enough for an AI agent to actually complete a purchase.

Most aren't.

Validate your UCP profile at https://ucptools.dev?utm_source=devto&utm_medium=article&utm_campaign=202605 - the free tier runs all four validation levels and simulates a real AI agent interaction against your store. Check your ChatGPT/ACP readiness at https://ucptools.dev/acp-checker. If an AI agent can't buy from you, your customers can't either.