The Agentic Commerce Acronym Map: ACP, UCP, MCP, AP2 and A2A

If you’ve spent any time in agentic-commerce discussions over the last six months, you’ve watched the acronym soup thicken. ACP, UCP, MCP, AP2, A2A, five protocols, three layers, two open-standards strategies, and a fair amount of marketing on top of the technical reality.

This post is a merchant-focused map. The goal is not to evangelise any one protocol but to give you a clean mental model of which acronym means what, which layer it operates at, and which decisions it actually affects in your operations roadmap.

The three layers

Almost every protocol confusion in this space resolves once you name the layer. There are three.

Layer 1: agent tooling

This is the layer that lets an AI agent, Claude, ChatGPT, Gemini, an embedded coding assistant, discover and use tools, including tools that touch merchant systems. The dominant protocol here is MCP (Model Context Protocol). It defines how an agent enumerates available tools, calls them, passes context, and handles authentication. MCP is processor-neutral, surface-neutral, and commerce-agnostic, it’s the plumbing, not the storefront.

Layer 2: agent-to-agent and payment coordination

When agents have to coordinate with each other or negotiate with payment infrastructure, you’re in protocol territory designed for that purpose. A2A (Agent2Agent) defines how agents talk to each other. AP2 (Agent Payments Protocol) defines how agents authorise and execute payments. These are infrastructure-level protocols, they don’t tell a merchant how to publish a catalogue, but they shape how purchases flow once an agent has decided to buy.

Layer 3: merchant-side commerce

This is the layer where merchants actually care. ACP (Agentic Commerce Protocol) and UCP (Universal Commerce Protocol) are the two big merchant-side standards. They cover catalogue, discovery, checkout, and post-purchase. ACP is the OpenAI-led standard for ChatGPT shopping; UCP is the Google-led standard for AI Mode and Gemini commerce.

Once you put each acronym in its layer, the relationships clarify. UCP at Layer 3 explicitly declares interop with AP2 (Layer 2) and MCP (Layer 1). ACP and Stripe-led delegated payment sit at Layer 3 with a tight Layer 2 dependency on Stripe.

Now the protocol-by-protocol breakdown.

ACP, Agentic Commerce Protocol

Layer: merchant-side commerce. Built by: OpenAI, co-authored with Stripe. Lives at: developers.openai.com/commerce and agenticcommerce.dev (open spec on GitHub). Surface: ChatGPT shopping, ChatGPT search citations.

ACP is the standard OpenAI uses to let merchants surface products and complete transactions inside ChatGPT. It has three spec layers, product feed, agentic checkout, and delegated payment, and a partner programme via chatgpt.com/merchants.

The merchant work is split clearly. Product feed onboarding happens through file upload or API. Checkout happens through the agentic checkout spec. Payment happens through Stripe-led delegated payment, with the merchant remaining the Merchant of Record.

The most useful thing to understand about ACP is that it’s prescriptive and end-to-end. OpenAI plus Stripe define the whole stack, which makes integration cleaner but also tighter. There’s less protocol-level flexibility than UCP, and more reliance on the OpenAI-plus-Stripe ecosystem.

For a field-by-field walkthrough of the ACP product feed, see our OpenAI ACP feed spec deep-dive.

UCP, Universal Commerce Protocol

Layer: merchant-side commerce. Built by: Google. Lives at: developers.google.com/merchant/ucp. Surface: AI Mode in Google Search, Gemini web (mobile coming).

UCP is Google’s standard for converting AI conversations into completed purchases. It sits on top of Google Merchant Center, which means most of the catalogue work is already done if you publish a Merchant Center feed today.

UCP offers two checkout flavours, native (default, full agentic) and embedded (iframe-based, for approved merchants with complex flows), and is currently expanding into Lodging and Food verticals via a waitlist.

The structural choice that makes UCP distinct is interop. Google’s UCP page explicitly describes the protocol as “interoperable with major industry standards (Agent Payments Protocol (AP2), Agent2Agent (A2A) and Model Context Protocol (MCP)).” That positions UCP as a hub rather than a silo, and it’s why Shopify’s Agents stack is UCP-compliant rather than ACP-compliant.

For a deeper merchant-operations walkthrough of UCP, see our Universal Commerce Protocol guide.

MCP, Model Context Protocol

Layer: agent tooling. Built by: Anthropic, now adopted across major AI providers. Lives at: the MCP specification site and many provider documentation surfaces. Surface: any agent runtime, Claude, ChatGPT, Gemini, agent frameworks, IDE-embedded assistants.

MCP defines how an AI agent calls a tool. Think of it like a structured calling convention plus auth model, an agent enumerates available tools (e.g., cart.add_line_item, checkout.complete, order.get), calls them with typed parameters, and receives typed responses.

For merchants, MCP is the developer-side shape of every agent integration. Shopify’s Cart MCP, Checkout MCP, and Order MCP are MCP servers, each one is a discoverable, callable surface for agents to drive Shopify operations. The same is true for the dozens of MCP servers being published by SaaS vendors across the ecosystem.

MCP is not a commerce protocol. It’s the plumbing that makes commerce protocols callable. ACP and UCP both rely on something MCP-shaped at the tool layer; UCP’s interop declaration formalises that.

For more on MCP in a commerce context, our Google Shopping MCP guide and MCP vs REST API vs OpenClaw cover the practical merchant view.

AP2, Agent Payments Protocol

Layer: payment coordination. Built by: open consortium aligned with major AI and payment vendors. Lives at: the AP2 specification site, declared as interoperable from Google’s UCP documentation. Surface: payment authorisation and execution flows initiated by AI agents.

AP2 is the open standard for AI agents to authorise and execute payments. The intent is processor-neutral, an agent acting on behalf of a buyer should be able to authorise a payment without being hard-wired to one payment processor, and AP2 defines the shared shape for doing that safely.

For merchants, AP2 is mostly a behind-the-scenes concern. If you process payments through Stripe today, AP2 conformance shows up in how Stripe routes agent-initiated charges; if you process through another provider, AP2 shows up in how they expose agent-payment primitives.

The relationship between AP2 and ACP’s delegated payment is the most common confusion. AP2 is the standard; ACP’s delegated payment is OpenAI’s specific implementation, tied to Stripe, in spirit aligned with AP2 but not the same artefact. UCP’s explicit AP2 interop means a UCP-side purchase can settle through any AP2-conformant payment provider.

A2A, Agent2Agent

Layer: agent coordination. Built by: open consortium aligned with Google and major AI vendors. Lives at: the A2A specification site. Surface: agent-to-agent communication, particularly across organisational boundaries.

A2A defines how AI agents from different vendors or organisations communicate with each other. A shopping assistant from one provider, talking to a logistics agent from another provider, talking to a fraud agent on the merchant side, is the A2A use case.

A2A is the least merchant-facing of the five protocols. Most individual merchants will never write A2A integration code; the platform providers and agent operators will. But the existence of A2A matters because it lets the agent ecosystem coordinate without every agent needing direct integration with every other, which is the same compounding-network effect MCP gives to tools.

The interop story

The structural picture, drawn cleanly:

• MCP is the tool-calling layer. Both ACP and UCP rely on MCP-shaped tool surfaces at the agent runtime. Shopify’s Cart MCP, Checkout MCP, and Order MCP are explicit MCP servers.
• A2A is the agent-coordination layer. UCP declares A2A interop. Most merchants won’t touch it directly.
• AP2 is the payment-coordination layer. UCP declares AP2 interop. ACP’s delegated payment is the OpenAI-plus-Stripe-specific implementation in this space.
• ACP is OpenAI’s end-to-end merchant-commerce stack. Prescriptive, tight, Stripe-bound on the payment side.
• UCP is Google’s hub-shaped merchant-commerce stack. Interoperable with MCP, AP2, and A2A by design.

That stack explains why Shopify chose UCP. By being UCP-compliant via MCP, Shopify inherits compatibility with every AI runtime that speaks MCP, every payment provider that speaks AP2, and every agent that speaks A2A, without having to commit to a single vendor’s end-to-end stack.

It also explains the trade-off ACP makes. By owning the whole stack, feed, checkout, delegated payment, OpenAI gets a cleaner end-to-end product surface, at the cost of being one of several merchant-commerce protocols rather than the universal hub.

A merchant-facing summary table

What to actually do with this

Three concrete moves:

1. Stop treating protocols as competitors at the feed layer

ACP and UCP catalogues overlap heavily. The work to publish a clean Merchant Center feed and the work to publish a clean ACP feed is mostly shared. Build a single source-of-truth catalogue with deterministic per-channel transformations and you have ~80% of both protocols solved before any checkout work begins.

2. Pick at the checkout-and-payment layer, by surface

Decide which AI surfaces your buyers actually use, ChatGPT, AI Mode, Gemini, Shopify-mediated agents, and prioritise the checkout integrations that match those surfaces. Most merchants will end up supporting two protocols; almost none will need to support all five.

3. Use MCP-shaped tools wherever possible

Whether you build internal agent tools or use SaaS-published MCP servers, MCP is the shape that compounds across protocols and providers. A team that’s already comfortable building and consuming MCP tools is well-positioned for whatever ACP and UCP turn into in 2027.

For the cross-protocol decision framework, see our ACP vs UCP comparison. For Shopify-specific implementation, see Shopify Agents explained. For the feed-spec deep dive that underpins all of this, see the OpenAI ACP feed spec walkthrough.

Five acronyms, three layers, one strategy: portable catalogue, surface-aware checkout, MCP-shaped tools. Get those right and the protocol churn stops mattering.