ACP vs UCP: Which Agentic Commerce Protocol Should You Build For in 2026?

In September 2025, OpenAI launched Instant Checkout in ChatGPT, with more than a million Shopify merchants lined up as the next wave. Six months later, about a dozen of them had integrated, and OpenAI moved checkout back to merchants' own sites.¹ Walmart reportedly saw purchases inside ChatGPT convert at roughly a third of the rate of its own website.² Over the same months, Google turned its Universal Commerce Protocol into a cart that spans retailers across Search, Gemini, and YouTube.

So when an ecommerce team asks about ACP vs UCP in 2026, the question has changed. OpenAI's Agentic Commerce Protocol and Google's Universal Commerce Protocol both let an AI agent find a product, check price and stock, and help a shopper buy it. They differ in where your data lives, where checkout happens, and which AI surfaces they reach.

Our bet is that through 2027, agents will drive discovery on every major AI surface, while most purchases close where payments and identity already live: UCP-style embedded checkout or your own site. The protocols will keep shifting. The commerce capabilities underneath them (catalog, pricing, inventory, checkout) are the layer you own.

In June we mapped the four engineering workstreams behind agentic commerce. This post zooms into the protocol layer: what each protocol does, how they differ, how to sequence the work, and a hands-on guide for Shopify, the one platform wired into both.

What is ACP (Agentic Commerce Protocol)?

ACP stands for Agentic Commerce Protocol, an open standard that OpenAI and Stripe published under Apache 2.0 in September 2025.³ It defines how an AI agent, a merchant, and a payment provider exchange data during a purchase. OpenAI's developer docs now describe it as the layer that lets ChatGPT ingest structured catalog data, understand merchant inventory, and surface products in context.⁴

ACP has three moving parts:

• Product feeds. Merchants push structured catalog data (titles, variants, price, availability, promotions) through a file upload or the Feeds and Products APIs. Most of OpenAI's current investment goes here.
• Checkout sessions. A REST contract for creating, updating, and completing a checkout the agent starts. The merchant can accept or decline the order and stays the merchant of record.
• Delegated payments. The agent never holds raw card data. It passes a single-use, time-bound, amount-capped token (Stripe's Shared Payment Token, for example) to the merchant's existing processor.⁵

PayPal joined as a payment provider in October 2025. The April 2026 stable spec added cart, orders, authentication, and an MCP hook, so ACP-aware agents can advertise checkout through standard tool discovery.⁶

What changed in 2026

The protocol survived; the flagship product did not. Instant Checkout charged merchants a 4 percent fee per sale,¹ handled single-item purchases only, and showed prices and stock that could lag the merchant's own site.³ On March 24, 2026, OpenAI relaunched ChatGPT shopping around discovery. Merchants keep their own checkout, ACP mainly carries product feeds, and retailers such as Target, Best Buy, and Wayfair signed on as discovery integrations.³ Brands that want purchases inside the chat now build a ChatGPT app.

For engineering teams, the lesson is that a protocol is only as useful as the surface that runs it. Treat ACP today as a catalog distribution channel into ChatGPT, not a checkout replacement.

What is UCP (Universal Commerce Protocol)?

UCP stands for Universal Commerce Protocol, an open standard Google launched at NRF on January 11, 2026, co-developed with Shopify and retailers including Walmart and Target.⁵⁷ It covers the whole shopping lifecycle for agents: discovery, comparison, cart, checkout, order tracking, and post-purchase support. Merchants publish their capabilities once, and any UCP-compliant agent can use them.⁷

Architecturally, UCP is decentralized. Instead of sending your catalog to one AI company, you publish a JSON profile at /.well-known/ucp that declares which services and capabilities your store supports.⁸ Agents read that profile, then call your endpoints for checkout, cart, catalog search, or identity linking. UCP sits alongside MCP, A2A (agent-to-agent), and AP2 (Agent Payments Protocol) rather than replacing them. In the live Shopify profiles we inspected, MCP is one of the declared transports.⁹

How UCP evolved in 2026

• January: launch with single-item checkout in Search AI Mode and Gemini, paid with Google Pay, for select U.S. retailers.⁵
• March 19: Cart, Catalog, and Identity Linking capabilities (OAuth 2.0, so member pricing and free shipping follow the shopper), plus simpler onboarding through Merchant Center.¹⁰
• May: Universal Cart, a cart that spans retailers across Google surfaces. Shoppers pay with Google Pay or hand the cart to the merchant's site. Google also announced UCP checkout in YouTube Shopping ads, Affirm and Klarna inside Google Pay, and expansion to Canada, Australia, and later the U.K.¹¹
• August: the spec version Shopify stores serve today is dated 2026-08-25 and layers fulfillment and discount extensions on top of cart and checkout.⁹

In every flow, the retailer stays the merchant of record.¹¹ The trade-off is distribution. "Universal" describes the spec; most of the traffic today runs through Google.

ACP vs UCP: key differences

ACP is a catalog pipe into ChatGPT, and UCP is a capability contract that agents discover on your domain. Both keep you as merchant of record and both tokenize payments. They differ in who holds your data and where checkout happens.

Two differences matter most for engineering planning.

1. Data ownership and freshness. With ACP, you keep a copy of your catalog current on someone else's platform, and stale price or stock in chat was one of the reasons in-chat checkout struggled.³ With UCP, agents query your endpoints, so freshness depends on your own APIs and their latency.
2. Where conversion lives. ACP now routes most buyers back to you, which keeps your checkout, upsells, and analytics intact. UCP can close the sale inside Google, which removes friction but moves part of the experience out of your control.

How ACP and UCP relate to MCP

Neither protocol is a superset of the other, and neither replaces MCP. MCP standardizes how an agent calls tools; ACP and UCP define the commerce those tools carry.

ACP or UCP: which should you build for first?

For most U.S. merchants in late 2026, the answer is UCP for transactions, ACP for discovery, and a protocol-agnostic commerce layer underneath both. Checkout.com, which processes payments for both protocols, reached a similar conclusion and advises merchants to prepare for both rather than pick a winner.⁵ Here is how we would sequence the work.

Phase 1: Fix the data layer (weeks 1 to 4)

Neither protocol survives bad data. Agents compare your listing against competitors on price, availability, and attribute completeness, so gaps cost you placement before any checkout logic runs.

• Audit variant modeling, GTINs, and how many minutes stock changes take to reach every channel.
• Rewrite product copy with conversational attributes ("waterproof hiking boot for wide feet"), not only keyword strings.
• Expose real-time price and inventory through an internal API you control.

Phase 2: Pick your first protocol by traffic source (weeks 4 to 8)

Phase 3: Abstract the protocol (weeks 8 to 12)

Wrap catalog, cart, and checkout behind one internal commerce capability service. Expose it once as MCP tools, then add thin ACP and UCP adapters. When the next spec version ships, you update an adapter, not your checkout. It's the same principle we apply when choosing agent harnesses: keep business logic behind your own interfaces, and switching layers becomes a refactor instead of a rewrite.

Kill criteria

Agentic channels are still small, so set exit conditions before you invest:

• Agent-referred revenue below 1 percent of online revenue after two quarters: freeze new protocol work and keep only feed maintenance.
• In-surface conversion more than two times worse than your site: route buyers to your own checkout. Walmart's reported gap in ChatGPT was roughly three times.²
• Catalog sync errors above 2 percent of SKUs: stop adding surfaces until data quality is fixed.

These thresholds are our suggested starting points, not industry benchmarks. Tune them to your margins.

ACP and UCP on Shopify: Agentic Storefronts

On Shopify, you don't have to choose between ACP and UCP. Shopify's Agentic Storefronts handles both, and Shopify switched it on for eligible U.S.-facing stores on March 24, 2026.¹² Shopify co-developed UCP with Google, serves /.well-known/ucp and /api/ucp/mcp on every store, and syndicates Shopify Catalog into ChatGPT. What's left for your team is configuration, data quality, and measurement.

How each AI channel behaves for a Shopify store

Status as of mid-2026, per Craftshift's channel guide.¹² Check your admin for current availability.

The Shopify agentic commerce checklist

1. Review Sales Channels > Agentic. Turn off "Allow Shopify to manage for me" if you want per-channel control. Each channel has separate toggles for catalog access and direct checkout.
2. Decide direct checkout per channel. Embedded checkout removes friction but may carry per-partner fees and moves the experience off your site. Start with catalog-only on one channel if you need a baseline.
3. Complete your policies. Terms, privacy, and returns are required for eligibility, and agents read them to answer shopper questions.
4. Fix product data first. Specific titles (type, material, color, differentiator), factual descriptions, variant-level images, and alt text. Agents rank on these before anything else.
5. Install Shopify Knowledge Base so agents answer shipping and returns questions from verified content, then review the auto-generated answers.
6. Tag AI channels in analytics. Create a GA4 channel group for ChatGPT, Copilot, Gemini, and Perplexity referrals so you can apply the kill criteria from the decision framework.
7. Verify what agents can discover on your domain, starting with your UCP profile.

A quick UCP audit script

The script below fetches a domain's UCP profile and lists the protocol version, transports, and capabilities it declares. It's a smoke test, not a validator, so check field names against the current spec at ucp.dev.

import requests

DOMAINS = ["allbirds.com", "www.target.com"]

def audit_ucp(domain: str) -> None:
    url = f"https://{domain}/.well-known/ucp"
    try:
        resp = requests.get(url, timeout=10, headers={"User-Agent": "ucp-audit/0.1"})
        resp.raise_for_status()
        profile = resp.json()["ucp"]
    except (requests.RequestException, ValueError, KeyError) as exc:
        print(f"[FAIL] {domain}: no valid UCP profile ({type(exc).__name__})")
        return
    transports = {s["transport"] for svcs in profile.get("services", {}).values() for s in svcs}
    print(f"[OK]   {domain}: UCP {profile['version']}, transports: {sorted(transports)}")
    for cap in sorted(profile.get("capabilities", {})):
        print(f"       - {cap}")

for d in DOMAINS:
    audit_ucp(d)

We ran it on October 1, 2026, against Allbirds (a Shopify store) and Target (a UCP launch partner):

[OK]   allbirds.com: UCP 2026-08-25, transports: ['embedded', 'mcp']
       - dev.shopify.catalog
       - dev.ucp.common.identity_linking
       - dev.ucp.shopping.cart
       - dev.ucp.shopping.catalog.lookup
       - dev.ucp.shopping.catalog.search
       - dev.ucp.shopping.checkout
       - dev.ucp.shopping.discount
       - dev.ucp.shopping.fulfillment
       - dev.ucp.shopping.order
[FAIL] www.target.com: no valid UCP profile (HTTPError)

Allbirds declares nine capabilities, from catalog search to identity linking, with no custom work, because Shopify serves the profile for every store. Target returns a 404 at that path. That doesn't mean Target is missing from UCP flows (it's a named Universal Cart partner¹¹); large retailers can integrate with Google directly. What it shows is that a public profile is one path among several, so check what agents can discover on your own domain instead of assuming. Run the script against your store and two or three competitors before you plan anything.

When Shopify's defaults are not enough

The managed channel covers most stores. You need custom work when you sell configurable or B2B products the standard checkout can't express, when you want a branded ChatGPT app with account linking and loyalty, or when you run a headless frontend and need agent traffic to share pricing and promotions logic with your own site. Here is where a dedicated commerce capability service, exposed through MCP, pays off.

Serving UCP off the shelf with eve

You don't have to start the UCP side from a blank HTTP server. Vercel's eve, a framework for building and deploying agents, documents UCP support in three steps: author the profile as a typed object, serve it at /.well-known/ucp from a custom channel, and mount your checkout endpoints next to it. The channel that serves the profile is short:

// agent/channels/ucp.ts
import { defineChannel, GET } from "eve/channels";
import { profile } from "../ucp-profile";

const body = JSON.stringify(profile);

export default defineChannel({
  cors: true,
  routes: [
    GET("/.well-known/ucp", async () =>
      new Response(body, {
        headers: {
          "content-type": "application/json",
          "cache-control": "public, max-age=300",
        },
      }),
    ),
  ],
});

The hosting rules are easy to miss when you write this by hand: the spec requires HTTPS, forbids redirects on the profile path, and requires public caching of at least 60 seconds. The eve guide calls out all three.

What eve leaves to you is the commerce itself: the checkout, cart, and order state machines, payment-handler execution, and request signing. That split fits the capability-service pattern from Phase 3. The eve channel is your thin UCP adapter, and the business logic stays behind your own interfaces.

How we approach agentic commerce at Pento

We pick the protocol last. The traffic mix, the existing stack, and the team that will own the system come first, the same order we follow when choosing agent frameworks.

Most of the hard work sits in the data and retrieval layer, where we have spent years. For a U.S. subscription crafting-commerce platform serving more than 100 million search queries a month, we replaced keyword search with a semantic search engine that understands image content. Conversion rose 30 percent, successful asset discovery rose 40 percent, and the system answers in under 50 milliseconds at hundreds of requests per second. Agents query catalogs in natural language with rich constraints, so the same retrieval quality and latency budget now decide whether an agent can use your catalog at all.

Enrichment cost is the other half. A generative AI metadata-extraction pipeline we built for a company with a market cap above $2 billion ran 16 times cheaper than an API-based approach. Cost per item is what decides whether you can re-enrich a full catalog every time an AI surface changes its requirements, and UCP alone shipped three spec versions in 2026.⁹

ACP vs UCP: what this means for your roadmap

The ACP vs UCP debate looks like a format war, but 2026 showed it's a question of surfaces. ACP survived as ChatGPT's catalog layer after in-chat checkout stalled. UCP became the transaction layer for Google and for the embedded checkouts Shopify runs in Copilot and AI Mode. Both specs will keep changing, and both depend on the same foundation: clean product data, real-time pricing and inventory APIs, and a checkout you can expose safely to agents.

Whatever your stack, three moves get you ready:

• Fix the catalog first. Attribute completeness, variant modeling, and sync latency decide whether any protocol helps you.
• Ship one protocol end to end. Pick it by traffic source, measure agent-referred revenue, and apply the kill criteria before adding a second.
• Put a capability service between your commerce core and every protocol. Specs will keep versioning; your checkout shouldn't have to follow each one.

For the production discipline behind agent-facing systems, see our agents recipe book. If you want a second opinion on where your store stands, start with our free ecommerce audit or book a call with our agentic AI web development team. We build on your stack and hand over to your engineers.