A retailer with 50,000 SKUs wants to make their catalog available to AI shopping agents. ChatGPT has 800 million weekly users. Google's Gemini is integrated across Android, Chrome, and Search. Microsoft Copilot reaches hundreds of millions through Windows and Office. Each platform has different APIs, authentication requirements, and data formats.

Without standardization, that retailer faces an integration nightmare. Build a custom connection for ChatGPT. Another for Gemini. Another for Copilot. Maintain all three as each platform evolves. Multiply this across every retailer and every AI platform, and the math becomes untenable: thousands of bespoke integrations that slow the entire ecosystem's shift toward agent-mediated commerce.

The Universal Commerce Protocol (UCP) solves this problem. Co-developed by Google with Shopify, Etsy, Wayfair, Target, and Walmart, UCP establishes a common language for AI agents to discover products, negotiate checkout terms, and complete transactions with any merchant. One integration, every agent.

What UCP does for agentic commerce

UCP is an open-source standard that enables AI agents to interact with merchant backends through a unified interface. Rather than building custom integrations for each AI platform, merchants implement UCP once and become accessible to any agent that speaks the protocol.

The protocol covers the full commerce lifecycle:

The key distinction from earlier approaches: UCP is merchant-centric. Retailers remain the merchant of record, control their pricing and business logic, and own the customer relationship. The protocol standardizes the interface without standardizing the experience.

How UCP compares to other agentic commerce protocols

UCP enters a landscape with several protocols addressing different pieces of the agentic commerce stack.

UCP and ACP represent two philosophies for agentic commerce. ACP optimizes for agent-native buying within the OpenAI ecosystem. UCP optimizes for merchant control across any AI platform.

Universal Commerce Protocol (UCP)

UCP treats merchants as the source of truth. Retailers publish a machine-readable profile declaring what they support: which capabilities (checkout, orders, catalog), which extensions (fulfillment options, loyalty programs, subscriptions), and which payment handlers (Google Pay, Shop Pay, regional processors). Agents discover these profiles and negotiate based on what both sides can handle.

The protocol uses a layered architecture that separates concerns:

This separation means the protocol can evolve without breaking existing integrations. A merchant can add support for subscription commerce through an extension without touching their core checkout implementation. An agent that does not support subscriptions simply will not negotiate that capability.

The partner ecosystem includes co-developers Shopify, Etsy, Wayfair, Target, and Walmart, with endorsements from Adyen, American Express, Best Buy, Flipkart, Macy's, Mastercard, The Home Depot, Stripe, Visa, and Zalando. UCP powers checkout in Google's AI Mode in Search and the Gemini app, with PayPal support coming soon.

Agentic Commerce Protocol (ACP)

ACP emerged from OpenAI and Stripe to enable purchases directly within ChatGPT. Where UCP emphasizes merchant-published capabilities, ACP emphasizes agent-mediated execution. The protocol handles single-item transactions with Stripe processing payments, optimized for the conversational interface where users discover and buy without leaving the chat.

Shopify enabled over one million merchants automatically when ACP launched, providing immediate scale within the ChatGPT ecosystem. The tradeoff is ecosystem specificity: ACP is deeply integrated with OpenAI's infrastructure rather than designed for cross-platform interoperability.

Model Context Protocol (MCP)

Anthropic's MCP provides a standard way for AI models to access external tools and data sources. While not commerce-specific, MCP enables the context layer that shopping agents need: access to user preferences, previous purchases, loyalty information. UCP explicitly supports MCP as a transport option, allowing merchants to expose their capabilities through MCP servers.

Agent Payments Protocol (AP2)

Google's AP2 handles the payment layer with cryptographic proofs of user consent. Every authorization includes verifiable evidence that the buyer approved the transaction. UCP integrates with AP2 for payment processing, combining UCP's commerce capabilities with AP2's security model.

How UCP's technical architecture works

UCP's design reflects lessons from decades of protocol development. As Shopify's engineering team explains: "Monolithic protocols eventually collapse under complexity: too rigid to adapt, too slow to evolve. Thoughtfully layered protocols survive and thrive by separating responsibilities, defining clear APIs, and enabling composition."

Discovery and negotiation

Merchants publish a profile at a standard endpoint: /.well-known/ucp. This JSON document declares everything an agent needs to know: supported services, capabilities, extensions, and payment handlers.

When an agent makes a request, it passes its own profile URL. The merchant computes the intersection of what both sides support and responds with the negotiated result. Capabilities both support get activated. Extensions neither supports get ignored. Payment handlers overlap determines which payment options appear.

This negotiation happens per-transaction. Change the cart contents, change the buyer's location, change any variable, and the available capabilities may shift. A merchant might support buy-now-pay-later for orders over $100 but not for smaller purchases. The protocol handles this dynamically rather than through static configuration.

Extensibility without committees

UCP uses reverse-domain naming for capabilities: dev.ucp.shopping.* is hosted at ucp.dev, while com.loyaltyprovider.* belongs to loyaltyprovider.com. Own the domain, own the namespace.

This means a loyalty program provider can define their own extension without seeking approval from a central registry. Merchants who want that loyalty functionality advertise support for the extension. Agents that understand it can negotiate reward options, provide member credentials, or redeem points. Agents that do not simply skip those fields.

The result is what Shopify calls an "open bazaar of capabilities, evolving as freely as commerce itself." New commerce patterns can emerge from any participant without waiting for protocol governance to catch up.

Checkout state machine

UCP models checkout as a state machine with three states:

The requires_escalation state handles situations where autonomous completion is not possible: regulatory requirements, merchant policies, or capabilities the agent does not yet support. When escalation is required, the merchant response includes a continue_url where the buyer can pick up exactly where the agent left off.

This handoff mechanism means no transaction gets abandoned because an agent hit a capability gap. The buyer follows the link, completes whatever the agent could not handle, and the purchase proceeds.

Two-sided payment negotiation

Payments in UCP separate what consumers use to pay (instruments) from how merchants process payments (handlers). Both sides declare preferences, and the protocol negotiates per transaction.

An agent might support Google Pay and Apple Pay. A merchant might accept Google Pay, Shop Pay, and Klarna. The intersection (Google Pay) becomes the available option. Add buy-now-pay-later support to the agent, and suddenly Klarna appears as an option for eligible purchases.

Payment handlers are not hardcoded into the protocol. Each provider publishes their own handler specification. The merchant advertises which handlers they accept; the agent picks one and follows its spec. New payment methods enter the ecosystem without protocol changes.

Multi-protocol commerce in practice

A typical agent-mediated purchase involves multiple protocols working together. Consider a customer asking Gemini to "find running shoes under $150 with good arch support."

‍Discovery phase: The agent queries merchants using UCP to understand available products, inventory levels, and capabilities. MCP might provide access to the customer's sizing preferences and previous purchases.

‍Selection phase: The customer narrows choices through conversation. The agent retrieves detailed product information, reviews, and availability through UCP catalog capabilities.

‍Checkout phase: UCP handles cart creation, applies the customer's loyalty discount through a negotiated extension, and calculates shipping options based on the fulfillment capability.

‍Payment phase: AP2 processes the payment with cryptographic proof of consent. The agent presents negotiated payment options (Google Pay available, Shop Pay available), the customer selects one, and the transaction completes.

‍Post-purchase phase: UCP's order capability provides tracking updates. If the customer needs to initiate a return, the agent can handle it through UCP or hand off to merchant support via the escalation mechanism.

The customer experiences a continuous conversation. Behind it, protocols layer to handle discovery, context, commerce, and payment.

Implementation considerations for enterprises

Adopting UCP requires coordination across technical, operational, and strategic functions.

Technical requirements

The core integration involves three REST endpoints: session creation, session updates, and checkout completion. Merchants publish a profile at /.well-known/ucp declaring supported capabilities and payment handlers.

Optional components include embedded checkout for rich handoffs (using JSON-RPC 2.0 for bidirectional communication), OAuth 2.0 for account-linked experiences, and webhooks for order status synchronization.

For Google's implementation specifically, merchants need an active Merchant Center account with configured shipping, returns, and product feeds. Products must be eligible for checkout to surface in AI Mode and Gemini.

Data infrastructure requirements

UCP standardizes the interface but does not solve the underlying data challenges. Merchants need:

The merchants who struggle with UCP implementation typically have fragmented product information systems. Getting UCP working is straightforward; getting the underlying data clean enough to perform well is the harder problem.

Organizational considerations

The implementation timeline for Google's path runs roughly 60 days: 30 days for Merchant Center setup and profile publication, another 30 for endpoint implementation and testing, then approval through Google's waitlist before going live.

The protocol landscape in 2026

Two major protocols now define agentic commerce infrastructure: UCP from Google's retail coalition and ACP from OpenAI and Stripe. They represent different bets on where value accrues.

ACP bets that the agent interface becomes the primary commerce surface, with OpenAI's ecosystem capturing that relationship. UCP bets that merchants retain control and agents become a channel, with the protocol layer commoditized across platforms.

The coalitions behind each protocol signal strategic positioning. Google partnered with major retailers (Walmart, Target, Home Depot) who want to preserve their direct customer relationships. OpenAI partnered with Stripe, optimizing for payment volume through agent-mediated transactions.

Analyst perspectives suggest the next 18 months will determine whether these protocols converge toward interoperability or fragment into competing ecosystems. The open question is Amazon: their closed ecosystem has not adopted either protocol, and their participation would significantly influence which approach becomes standard.

For merchants, the practical path is implementing both. UCP for Google surfaces and broad agent compatibility. ACP for ChatGPT's massive user base. The integration burden is manageable because both protocols connect to the same underlying commerce infrastructure.

Building for protocol-agnostic commerce

The emergence of multiple agentic commerce protocols creates a familiar enterprise challenge: supporting multiple interfaces to the same underlying capabilities. Merchants who built clean APIs for their commerce operations can expose them through UCP, ACP, or whatever protocol emerges next.

The harder problem is not protocol compliance. It is the data infrastructure beneath the protocols.

When an agent requests a checkout, the merchant needs real-time inventory visibility, accurate pricing, proper tax calculation, and fulfillment options that reflect actual operational capability. When an agent-mediated transaction completes, the merchant needs to connect that purchase to customer identity, attribute it correctly for marketing measurement, and maintain the signals needed for personalization.

Protocols standardize the handshake. They do not standardize the data that flows through it.

Companies building first-mile data infrastructure address this layer: capturing behavioral signals at origin, maintaining unified customer identity across agent-driven and traditional channels, and ensuring the commerce data that protocols transmit is accurate, compliant, and actionable.

The merchants who win in agentic commerce will not be those who implement protocols fastest. They will be those whose underlying data infrastructure makes every protocol interaction accurate, measurable, and connected to the customer relationships that drive long-term value.

‍

MetaRouter is first-mile data infrastructure for agentic commerce: server-side collection at the point where agent signals enter your ecosystem, identity resolution that connects transactions to customer profiles, and real-time routing that makes every commerce surface measurable. See how it works.

‍