The HTTP of AI Shopping: Inside UCP, MCP, and the Open Protocol Stack

In a nutshell (TL;DR)...

This document explores the shift toward "Agentic Commerce," where AI agents independently execute shopping tasks. This ecosystem is powered by three key open protocols: MCP for live data access, UCP for transaction management (carts, identity, and payments), and A2A for dynamic negotiations between software agents. These open standards are vital for a friction-free, competitive future in retail.

In a previous post I talked about the rise of Agentic Commerce and how it will transform the way we shop online. I asked you to imagine asking your Personal AI Assistant: "Find me a waterproof hiking jacket in olive green under $200, apply my store rewards, and ship it to my apartment by Friday."

Five years ago, that prompt would yield a list of web links. Today, the AI Agent doesn't just find the jacket, it checks real-time inventory, verifies your loyalty tier, negotiates dynamic discounts, and executes the purchase without you ever loading a checkout page.

I’ve also delved into the magic sauce that makes this happen but let’s try and bring together the main components into one post and try to understand what is at play. It is an underlying stack of open protocols, a collection of open-source technical standards forming what experts are calling the "HTTP of Agentic Commerce".

If you want to understand how software will trade billions of dollars over the next decade, you need to understand the protocols making it happen: MCP, UCP, and A2A.

1. The Context Layer: Model Context Protocol (MCP)

Before an AI agent can buy anything, it needs access to real-time information. Language models are inherently isolated; they don't natively know if a store has 3 items left in stock or if a price dropped five minutes ago.

Enter Model Context Protocol (MCP), open-sourced by Anthropic.

MCP acts as a universal adapter between AI models and external data tools. Think of it as USB-C for AI: instead of developers writing custom API connectors for every single product database, store backend, or CRM, MCP provides a standardized format for agents to query live data.

What MCP Handles in E-Commerce:

• Live Inventory Checks: Quoting real-time stock counts across multiple warehouse locations.

• Spec Parsing: Extracting structured technical specifications (e.g., precise dimensions, fabric weight, voltage) from unstructured databases.

• Contextual Inputs: Feeding user preferences, sizing profiles, and past purchase histories securely to the AI model.

2. The Commerce Layer: Universal Commerce Protocol (UCP)

While MCP provides data context, it isn't built to orchestrate end-to-end retail transactions. Querying an API for stock is easy; creating a multi-item cart, applying promotional codes, initiating identity verification, and managing payments requires a formal commerce standard.

To solve this, Google teamed up with retail and infrastructure giants—including Shopify, Etsy, Target, Walmart, Visa, and Stripe—to release the Universal Commerce Protocol (UCP).

+----------------------------------------------------+
|               CONSUMER AI SURFACES                |
|     (Gemini, AI Search, Custom Assistants)         |
+----------------------------------------------------+
                            |
                            v
+----------------------------------------------------+
|        UNIVERSAL COMMERCE PROTOCOL (UCP)           |
| Standard primitives for Cart, Identity & Checkout |
+----------------------------------------------------+
            /              |              \
            v               v               v
  +---------------+---------------+--------------+
  |    MERCHANT  |   LOYALTY &   |    PAYMENT  |
  |    BACKEND   |    IDENTITY   |   PROVIDERS |
  +---------------+---------------+--------------+

UCP defines an open-source communication specification for e-commerce operations. It doesn't replace existing merchant platforms like Shopify or WooCommerce; it gives AI agents a set of standard functional primitives to talk directly to them.

Core UCP Primitives:

1. Catalog & Discovery: Exposing structured, real-time product catalogs directly to AI crawlers.

2. Cart Management: Enabling agents to create, modify, and calculate sub-totals for multi-item carts programmatically.

3. Identity & Loyalty Linking: Recognizing that "John Doe" is a Gold Tier member at a store, applying member pricing automatically without forcing a manual login on a website.

4. Checkout & Orchestration: Tokenizing payments and completing transactions securely while keeping the merchant as the official Merchant of Record.

3. The Negotiation Layer: Agent-to-Agent Protocol (A2A)

The ultimate evolution of agentic commerce isn't just a buyer bot interacting with a static website backend—it's software negotiating with software.

Agent-to-Agent (A2A) protocols establish rules for buyer agents (representing consumers) and seller agents (representing brands) to interact dynamically.

How A2A Dynamics Work in Practice:

• Dynamic Bundling: A buyer agent requests a camera, lens, and tripod. The brand's seller agent calculates real-time margins and responds: "If you buy all three together, I can offer an instant $45 bundle discount."

• Inventory Clearing: A merchant's AI agent notices excess seasonal inventory and dynamically grants targeted discounts to consumer agents searching for deals in that specific category.

• Automated Terms Negotiation: Negotiating bulk order delivery timelines or return window extensions for enterprise purchases.

The Big Shift: Why Open Protocols Win

Why does this open architectural stack matter so much? Because walled gardens create friction, and friction kills conversion.

If every AI assistant required a proprietary integration to buy from every merchant, only massive platforms (like Amazon) would survive. Open standards like UCP, MCP, and A2A democratize the landscape. They allow a boutique clothing store running on a standard e-commerce platform to sell to a consumer using ChatGPT, Gemini, or a standalone personal AI assistant seamlessly.

The web was built on open transport protocols like HTTP and HTML. The era of agentic commerce is being built on data, transaction, and negotiation protocols. Brands that adopt these standards early won't just keep up, they will be the first ones discovered when software starts doing the shopping.

A Tale of Two Commerce Protocols

In previous posts I discussed the advent of Agentic Commerce and how that is primed to become the new way to shop for products online.

In order to enable the AI platforms to be aware of your brand presence and product information there are a number of strategies and techniques, specifically GEO (Generic Engine Optimization) and AEO (Answer Engine Optimization), that can attract the AI bots to prefer your brand and recommend your products within the many conversations that customers are now having with AI applications.

GEO is a broad strategy that involves a number of techniques that involve changes in how you write product content and optimize your websites so that AI will pick you first as the authoritative source for the answers within the Agentic Commerce experience.

Very recently a couple of new developments have emerged that both sound like it’s attempting to answer a similar question. Namely OpenAI’s Agentic Commerce Protocol (or ACP) and Google’s Universal Commerce Protocol (or UCP).

OpenAI’s ACP is an open, cross-platform protocol designed to enable shopping and payments directly within AI assistants, independent of any single platform or user interface. It allows AI agents to discover products via merchant-provided feeds, surface accurate pricing and availability, and autonomously initiate checkouts on the user's behalf without redirecting them to an external website.

The checkout process uses secure, delegated payment tokens (which are single-use, time-bound, and amount-restricted), while ensuring that the merchant retains full control over settlement, refunds, chargebacks, and compliance. The first implementation of this protocol is the Instant Checkout experience within ChatGPT.

Google’s UCP is a new open standard designed to establish a common language that allows AI agents, businesses, and payment providers to work together across the entire shopping journey from product discovery to post-purchase support. They also have massive Industry Endorsement collaborating with the likes of Etsy, Shopify, Best Buy and Walmart (US) who are either implementing, or have gone live with AI Agents.

While it is designed to be compatible with other agentic protocols, UCP is initially rolling out exclusively on Google-owned surfaces, such as Search AI Mode, Google Shopping, and the Gemini App. It enables shoppers to buy from eligible retailers directly during product discovery without leaving Google, utilizing Google Pay for seamless transactions while the retailer remains the seller of record.

Why ACP/UCP are More Helpful Than AIO/GEO

While Artificial Intelligence Optimization (AIO) and Generative Engine Optimization (GEO) are critical strategies, they are fundamentally focused on top-of-funnel visibility. AIO and GEO ensure that an AI model correctly parses, embeds, and cites your brand as the "source material" when answering a user's question. However, simply getting found is only the first step of the commerce journey.

ACP and UCP are arguably more helpful because they bridge the gap between discovery and execution, transforming the entire commercial funnel:

• Moving from Recommendation to Action: AIO/GEO might prompt an AI to recommend your product, but the user still has to navigate to your site, browse, add to cart, and manually checkout. ACP and UCP grant the AI "agency" to act on the user's intent and execute the purchase directly within the conversational interface.

• Frictionless Shopping: Traditional e-commerce is linear and rigid (search → browse → filter → product page → cart → checkout). ACP and UCP collapse these steps into a natural dialogue, drastically reducing friction and lowering cart abandonment.

• Capturing Immediate Revenue: By allowing shoppers to move from intent to purchase without breaking context or leaving the app, these protocols turn high-intent discovery moments directly into revenue.

In short, AIO and GEO help AI talk about your product, but ACP and UCP allow AI to buy your product on the customer's behalf.

Which one to choose?

Both OpenAI's Agentic Commerce Protocol (ACP) and Google's Universal Commerce Protocol (UCP) share the same overarching goal: to reduce friction in the shopping journey by allowing AI agents to handle product discovery and checkout seamlessly, without redirecting the user to an external website.

However, they differ significantly in their execution environments, how they handle payments, and their initial scope.

OpenAI’s Agentic Commerce Protocol (ACP)

• Design & Environment: ACP is an open, cross-platform protocol built to enable shopping and payments directly within AI assistants. It is designed to be independent of any single platform, user interface, or distribution surface. Currently, its primary implementation is the "Instant Checkout" experience inside ChatGPT.

• Payment Mechanism: ACP initiates checkout on the user's behalf using delegated payment tokens. These tokens are highly secure because they are single-use, time-bound, and amount-restricted.

• Merchant Role: In this model, merchants maintain complete control over the transactional backend, retaining responsibility for settlement, refunds, chargebacks, and compliance.

Google’s Universal Commerce Protocol (UCP)

• Design & Environment: UCP is pitched as a new open standard designed to support the entire shopping lifecycle, from product discovery and buying to post-purchase support. However, unlike ACP's cross-platform focus, UCP is initially being rolled out exclusively across Google-owned surfaces, including Search AI Mode, Google Shopping, and the Gemini App.

• Payment Mechanism: Instead of delegated tokens, UCP leverages Google Pay to complete transactions natively during product discovery, with PayPal support planned for the future.

• Additional Features: Alongside UCP, Google launched a feature called "Business Agent," which allows retailers to engage shoppers conversationally and enable direct purchases right within Google Search.

The Core Differences

• Where the Shopping Happens: ACP enables agent-led commerce primarily across the OpenAI ecosystem as a standalone destination, while UCP currently focuses on reducing checkout friction specifically within Google's massive search and discovery surfaces.

• Coexistence Over Competition: Google designed UCP to be compatible with other agent-to-agent standards and protocols. This means the two protocols are not necessarily meant to replace one another, but rather to coexist. UCP helps convert high-intent shoppers who are actively searching on Google, while ACP opens the door to new demand where AI chat assistants act as the shopping destination.

So it’s not like the old VHS/Beta video wars of the 80s. The question isn't which protocol "wins" it's whether your product data (and infrastructure) is ready to feed both. The reality is that you may need to support a multi-protocol ecosystem, just like supporting Apple Pay, Google Pay, and PayPal today. We are entering a multi-agent, multi-protocol world where structured product data is the "source code" of commerce.