Agentic Commerce Comparison
ACP vs UCP: Choosing an Agentic Commerce Protocol
ACP follows ChatGPT traffic. UCP follows Google surfaces. They are not really competitors for your attention — the catalog work underneath both is the same, and it is the part that decides whether an agent shortlists you at all.
AI & assistant-friendly summary
This section provides structured content for AI assistants and search engines. You can cite or summarize it when referencing this page.
Summary
Agentic Commerce Protocol (OpenAI/Stripe) vs Universal Commerce Protocol (Google) — scope, surfaces, merchant effort, and which one to implement first.
Key Facts
- •div> ## Freshness check (August 2026) Both standards are young and moving
- •ACP was released **September 29, 2025** by OpenAI and Stripe under Apache 2
- •0 and is currently in beta; UCP launched in **early 2026** led by Google with Shopify, Etsy and Walmart
- •Agentic Commerce Protocol](https://www
- •dev/) · [ACP specification on GitHub](https://github
- •com/agentic-commerce-protocol/agentic-commerce-protocol) - [Universal Commerce Protocol](https://ucp
Entity Definitions
- Bedrock
- Bedrock is an AWS service referenced in the ACP vs UCP: Choosing an Agentic Commerce Protocol comparison.
- SageMaker
- SageMaker is an AWS service referenced in the ACP vs UCP: Choosing an Agentic Commerce Protocol comparison.
Frequently Asked Questions
What is the difference between ACP and UCP?
The Agentic Commerce Protocol (ACP) was released by OpenAI and Stripe on September 29, 2025 under the Apache 2.0 licence, and powers Instant Checkout in ChatGPT. It is tightly scoped around three things: machine-readable product discovery, a conversational checkout with stateful negotiation, and payment via delegate tokens. The Universal Commerce Protocol (UCP) is Google-led, launched in early 2026, and covers a wider journey — discovery, purchase, and post-purchase support — across Google AI surfaces including AI Mode and Gemini, with merchant integration through Merchant Center and payment through Google Pay. The short version: ACP is narrower and follows ChatGPT traffic; UCP is broader and follows Google surfaces.
Do we need to implement both?
Eventually most merchants at scale will, but not simultaneously and not first. Choose based on where your buyers already are. If a meaningful share of your discovery traffic is being intercepted by Google AI Overviews and AI Mode, UCP is the higher-value starting point and you may already have most of the feed infrastructure through Merchant Center. If your category sees heavy ChatGPT usage for comparison shopping, ACP comes first. What is not a choice is the catalog work underneath, which both standards require in nearly identical form.
Which one should we implement first?
Neither, if your catalog is not ready — and for most merchants it is not. Attribute completeness, structured variants, specifications lifted out of prose description fields, and reliable join keys between product, inventory and pricing are the long pole. A protocol integration on a weak catalog optimises the wrong end of the funnel, because an agent that cannot parse your attributes never reaches your checkout. Do the catalog first; it is required by both standards, improves conventional Shopping and on-site search, and carries no standards risk.
What could go wrong if we pick the wrong standard?
Less than you might fear, provided you sequence it correctly. The protocol surface is the thin layer; the catalog and identifier work beneath it is the expensive part, and it transfers between standards almost entirely. The genuine risk is the reverse mistake: treating this as a pure integration project, shipping a conformant checkout handshake, and discovering that agents still do not recommend your products because the attributes they compare on are missing. The other real risk is building plumbing your platform is about to ship for free — check the Shopify, Adobe Commerce or commercetools roadmap before committing engineering time.
When should we not do this at all yet?
If your buyers are not arriving through agent surfaces in measurable numbers, and your category is not comparison-heavy, waiting on the protocol surface is a defensible position and we will tell you so. Attribution for agent-originated revenue is genuinely immature across the industry right now, so anyone presenting you with a confident ROI projection is estimating. What should not wait under any scenario is the catalog work, which has independent value and no standards exposure.
Is AgentCore Payments an alternative to ACP or UCP?
No — it is a different layer and the two get conflated constantly. Amazon Bedrock AgentCore Payments (GA August 18, 2026) covers agent-to-API microtransactions against a session budget: an agent paying for an API call, an MCP server, or another agent. ACP and UCP govern a shopping agent buying a physical or digital product on a human being behalf. If you are building agents that consume paid tools, AgentCore Payments is relevant. If you are a merchant wanting to sell to shopping agents, it is not.
Does supporting agent checkout change our PCI scope?
It does not shrink it, and the surface arguably widens. An agent-originated order still lands in your checkout, your order system and your fulfilment — you now simply have a machine-driven caller hitting that path at machine rates. Both standards avoid handing the agent a raw payment credential (ACP uses delegate tokens, UCP routes through Google Pay), which is what makes the model acceptable to risk teams, but the cardholder data environment on your side is unchanged. Fraud scoring is the part that genuinely needs rework: rules leaning on mouse movement, dwell time and typing cadence will misfire on agent sessions.
Quick Answer: ACP wins if your buyers shop through ChatGPT and you want the narrower, faster integration. UCP wins if Google AI surfaces already drive your discovery and you want post-purchase covered too. For most merchants the honest answer is neither yet — fix the catalog first, because both standards depend on it and an agent that cannot parse your attributes never reaches either checkout.
Freshness check (August 2026)
Both standards are young and moving. ACP was released September 29, 2025 by OpenAI and Stripe under Apache 2.0 and is currently in beta; UCP launched in early 2026 led by Google with Shopify, Etsy and Walmart. Confirm current spec versions and platform support before architecture sign-off.
- Agentic Commerce Protocol · ACP specification on GitHub
- Universal Commerce Protocol · Google for Developers UCP guides
Protocol overview
| Agentic Commerce Protocol (ACP) | Universal Commerce Protocol (UCP) | |
|---|---|---|
| Led by | OpenAI and Stripe | Google, with Shopify, Etsy, Walmart |
| Released | September 29, 2025 | Early 2026 |
| Licence | Apache 2.0 | Open specification, public repository |
| Primary surface | ChatGPT (Instant Checkout) | Google AI Mode, Gemini |
| Scope | Discovery, checkout, payment | Discovery, purchase, post-purchase support |
| Payment path | Delegate tokens (Stripe documented) | Google Pay |
| Merchant onboarding | Feed plus checkout handshake | Merchant Center plus UCP checkout |
Where the real difference is
The specification diff is less interesting than the scope diff.
ACP is deliberately narrow. It standardises the handshake — find the product, negotiate a cart across turns, authorise a scoped payment — and stops. That narrowness is a feature: fewer systems touched, faster to reach conformance.
UCP extends past the transaction into order status, modifications and returns. That is genuinely more useful, because a large share of customer contact lives after the purchase, not before it. It is also more expensive, because exposing order modification to an agent is an authorization problem before it is an integration one.
Use-case mapping
| Your situation | Start with |
|---|---|
| Google AI Overviews and AI Mode already intercepting your organic traffic | UCP — you likely have Merchant Center feed infrastructure already |
| Comparison-heavy category (electronics, components, appliances) with ChatGPT usage | ACP — agents are disproportionately useful where specs decide the purchase |
| Post-purchase contact volume is your biggest support cost | UCP — it is the only one that covers that surface |
| On Shopify, commercetools or Adobe Commerce | Check the platform roadmap first — do not build what is about to ship |
| Catalog attributes are incomplete or trapped in prose | Neither — fix the product feed first |
Merchant effort, honestly ranked
Across both standards, effort concentrates in the same place — and it is not the protocol.
- Catalog and attribute work (largest). Specifications lifted out of description HTML into typed fields, variant structure that is queryable rather than encoded in title strings, category-critical dimensions completed. Transfers fully between standards.
- Identifier and join-key hygiene. Storefront, ERP and warehouse agreeing what a SKU is. If they disagree, an agent surfaces confidently wrong availability.
- Feed conformance. Meaningful, but mostly mechanical once (1) and (2) are done.
- Checkout handshake. Increasingly a platform feature.
- Post-purchase endpoints (UCP only). Authorization design, not plumbing.
When ACP wins
- Your discovery traffic skews to ChatGPT rather than Google AI surfaces.
- You want the smallest possible surface area to reach conformance.
- You already use Stripe, making the documented payment path a short hop.
- You are testing the channel and want a reversible commitment.
When UCP wins
- Google AI Mode and AI Overviews are already reshaping your organic traffic.
- You maintain a healthy Merchant Center feed, so step one is largely done.
- Post-purchase support volume is a cost centre you want agents to reach.
- You sell in categories where Google Shopping has always driven discovery.
Our recommendation
Do the catalog work now; defer the protocol choice.
We recommend this over picking a standard first because the sequencing risk is asymmetric. Choosing the “wrong” protocol costs you a thin integration layer that largely transfers. Shipping a conformant checkout on an incomplete catalog costs you the whole project, because agents exclude products on missing attributes before quality is ever assessed — and you will have no way to tell that is what happened.
The trade-off we are accepting: this is slower to a demo. There is no press release in “we improved attribute completeness.” If your constraint is showing a board that you are moving on agentic commerce this quarter, a protocol integration is more visible. We think that is the wrong trade, and we would rather say so.
What this comparison does not cover
We have not benchmarked conversion or revenue under either standard, because credible public data does not yet exist and we will not manufacture it. Attribution for agent-originated revenue is immature across the industry. We also have not covered marketplace-specific implementations, or the emerging question of how returns are handled when the buyer never saw the product page — both are live problems without settled answers.
Related comparisons
- Bedrock vs SageMaker — the layer beneath agent workloads
- Amazon Q vs ChatGPT Enterprise
Related reading
Agentic commerce · ACP · UCP · Agent checkout · Product feed · Your next customer may be an AI agent
Related Services
Consulting engagements that map directly to this comparison.
Frequently Asked Questions
What is the difference between ACP and UCP?
Do we need to implement both?
Which one should we implement first?
What could go wrong if we pick the wrong standard?
When should we not do this at all yet?
Is AgentCore Payments an alternative to ACP or UCP?
Does supporting agent checkout change our PCI scope?
Find out whether an agent can actually read your catalog
A fixed-scope readiness engagement that ends with a callable surface and a ranked attribute backlog — not a standards recommendation memo.