AI·January 2025·9 min read

E-Commerce Innovations

The real e-commerce innovation of the last eighteen months arrived as three open protocols: Universal Commerce Protocol, Agentic Commerce Protocol, and Agent Payments Protocol. Together they let an AI agent discover a product, build a cart, and pay for it on a shopper's behalf, released by Google, Shopify, Stripe, OpenAI, and a coalition of payment networks between September 2025 and early 2026. Gamification and NFTs, the previous cycle's hyped trends, produced nothing at this scale.

What actually shipped: three protocols, one shopping surface change

Three separate but connected open standards now define how AI agents transact with merchants. Each addresses a different layer of the same problem: an agent needs to find a product, complete a checkout, and prove it has permission to pay, all without a human clicking through a traditional storefront.

Protocol	Built by	What it defines
Universal Commerce Protocol (UCP)	Google and Shopify, with Etsy, Target, Walmart, and Wayfair	Discovery and negotiation between agent and merchant, plus checkout handoff via an Embedded Checkout Protocol
Agentic Commerce Protocol (ACP)	Stripe, OpenAI, and Meta	Cart and feed browsing, checkout sessions, delegated payment tokens, OAuth 2.0-based delegated authentication
Agent Payments Protocol (AP2)	Google, with 60-plus payments and technology partners	Cryptographically signed mandates that prove a user authorized a specific agent-initiated payment

UCP defines the discovery and negotiation mechanisms between an agent and a merchant, and the core capabilities that make commerce programmable for agents and humans alike, according to Shopify's own engineering writeup (Shopify Engineering — Building the Universal Commerce Protocol). Merchants publish a capability profile at a standardized endpoint; agents negotiate the intersection of what they and the merchant both support, rather than every agent needing a custom integration per merchant.

Why three protocols instead of one

They sit at different layers on purpose. UCP handles discovery and catalog negotiation. ACP handles the checkout session itself, cart contents, fulfilment options, and passing a payment token between buyer, agent, and business through a payment handler (Stripe Documentation — Agentic Commerce Protocol).

AP2 sits underneath both, providing the signed proof of payment authorization that either protocol can rely on. It's explicitly designed to extend Google's Agent2Agent (A2A) protocol and Anthropic's Model Context Protocol (MCP) rather than replace them (Google Cloud Blog — Announcing the Agent Payments Protocol (AP2)).

Today's payment systems assume a human is directly clicking "buy" on a trusted surface. An autonomous agent initiating that same payment breaks the assumption, which is the specific gap AP2's signed mandates exist to close.

The payment authorization problem AP2 actually solves

AP2's core mechanism is the mandate: a tamper-proof, cryptographically signed digital contract that serves as verifiable proof of a user's instructions (Google Cloud Blog — Announcing the Agent Payments Protocol (AP2)). There are two working modes:

Intent Mandate: a shopper asks an agent to find something, and that request becomes the auditable context for the transaction.
Cart Mandate: once the agent presents a specific cart, the shopper's approval signs a Cart Mandate, locking the exact items and price before payment executes.
Delegated Intent Mandate: for pre-authorized automation, such as "buy tickets the moment they go on sale," the shopper signs conditions upfront, price limits, timing, and the agent executes within them later without a real-time approval step.

That sequence, intent to cart to payment, creates a non-repudiable audit trail addressing three questions Google frames explicitly: authorization, authenticity, and accountability if a transaction goes wrong (Google Cloud Blog — Announcing the Agent Payments Protocol (AP2)). This is the actual engineering answer to "how do you trust an AI agent with a credit card," not a marketing claim about AI-powered shopping.

The agentic commerce stack as it shipped: a discovery and negotiation layer (UCP), a checkout and payment-token layer (ACP), and a signed-mandate authorization layer (AP2), sitting in front of the merchant's existing catalog, checkout, and payment processor.

Agentic checkout moved from announcement to live merchants fast

Stripe, OpenAI, and Meta describe ACP as an open standard that defines how AI agents interact with businesses to complete purchases on behalf of buyers, with the full specification published at agenticcommerce.dev and the reference implementation on GitHub under Apache 2.0 (Stripe Documentation — Agentic Commerce Protocol, GitHub — agentic-commerce-protocol/agentic-commerce-protocol). Stripe's own announcement confirms Instant Checkout shipped inside ChatGPT starting with Etsy sellers, with Shopify merchant support following (Stripe Newsroom — Stripe powers Instant Checkout in ChatGPT).

What this means for a merchant's own checkout code

A merchant implementing ACP exposes a checkout session API, a cart and feed endpoint for the agent to browse the catalog, and a delegated-payment handler, on top of infrastructure that likely already exists for the merchant's own storefront checkout. The heavier lift is usually feed quality and structured product data, not the checkout logic itself, because an agent can only negotiate a capability the merchant's feed actually declares.

ACP's delegated-authentication piece runs on OAuth 2.0, which means most commerce platforms aren't starting from zero. The new work is scoping what an agent-issued token is allowed to do, place an order, apply a stored payment method, versus what still requires a human in the loop, and building the webhook handlers ACP expects for order confirmation, shipping, and refund lifecycle events (Stripe Documentation — Agentic Commerce Protocol).

Google consolidated Shopping around feed quality, not new UI

Google's Merchant Center changes in 2026 point the same direction: agentic and AI-driven shopping surfaces are only as good as the underlying product feed. Google now accepts AI-generated product descriptions in feeds, provided they're factually accurate and consistent with the landing page, and Performance Max became the only available campaign format for new advertisers as Standard Shopping campaign creation was phased out (Google for Developers — Merchant API, Latest Updates).

Combined with UCP's default rollout across Search's AI Mode and the Gemini apps, this is a consistent bet: merchants that keep clean, structured, current product data win visibility across both traditional Shopping ads and the newer agent-driven surfaces, and the two are increasingly reading the same feed.

The old foundation still matters: structured data is agent bait too

None of this replaces the basics. UCP's negotiation layer, ACP's cart and feed browsing, and Google's AI-generated-description rules all depend on a merchant's product data being structured and accurate in the first place. The underlying vocabulary for that is still schema.org's Product type, unchanged in kind since long before agentic commerce existed (schema.org — Product).

Google's own structured-data documentation distinguishes product snippets, for pages where a visitor can't buy directly, from merchant listings, for pages with a real purchase path, price, availability, and shipping data attached (Google Search Central — Intro to Product Structured Data). An agent negotiating a UCP capability profile or reading an ACP product feed is consuming a superset of the same underlying facts: price, availability, variant options, shipping terms.

Why this is the most consequential fix most catalogs still need

A merchant with incomplete or stale structured data doesn't fail loudly under agentic commerce, they just don't show up in the negotiation. An agent can't declare a capability, gift wrap, a specific delivery window, a loyalty discount, that the merchant's feed never described in a machine-readable way. Fixing feed completeness is unglamorous work, and it's also the actual bottleneck standing between most catalogs and being visible on either classic Shopping or an agentic surface.

What didn't pan out: the previous generation of "innovations"

Gamified loyalty tiers, NFT-backed product drops, and "shoppertainment" live-shopping formats got heavy trade coverage a few years ago. None of them produced the kind of primary-source, platform-level standards work that UCP, ACP, and AP2 represent, and none of them shipped with comparable merchant adoption or open specifications. That's the honest correction to make: those were marketing experiments run by individual brands, not platform-level shifts in how commerce infrastructure works.

A platform-level innovation ships an open spec, a reference implementation, and a coalition of named partners. A marketing-team innovation ships a press release and a single brand activation. Only one of those changes how every merchant's checkout works.

Tracking platform changes without falling behind

Shopify, Stripe, and Google all publish first-party changelogs, and treating them as a required read, not an occasional check, is the actual discipline behind staying current.

Subscribe to Shopify's changelog for storefront and checkout API changes (Shopify — Changelog) and the biannual Editions summary for platform-level themes (Shopify Changelog — Spring '26 Edition).
Watch Stripe's developer changelog for API version changes before upgrading a pinned integration (Stripe Documentation — Changelog).
Review Google's Merchant API latest-updates page before assuming a feed attribute still behaves the way it did last quarter (Google for Developers — Merchant API, Latest Updates).
Read the actual protocol spec, not a summary blog, before scoping an ACP or UCP integration; the GitHub repos carry the OpenAPI and JSON Schema definitions that implementation actually depends on.

FAQ

Do UCP, ACP, and AP2 compete with each other?

No, they operate at different layers. UCP handles discovery and catalog negotiation, ACP handles the checkout session and payment token handoff, and AP2 provides the signed authorization mandate underneath either.

What does a merchant actually need to build to support agentic checkout?

A checkout session API, a cart and product feed endpoint the agent can query, and a delegated-payment handler, per the ACP specification. Clean, structured product data matters more than new UI.

Is agentic commerce live today, or still a pilot?

It's live. Stripe's own announcement confirms ChatGPT Instant Checkout shipped for US Etsy sellers with Shopify merchant support rolling out, and UCP is enabled by default across Google Search's AI Mode and the Gemini apps.

What happened to gamification, NFTs, and shoppertainment as e-commerce trends?

They didn't produce comparable platform-level adoption or open specifications. They remain individual brand marketing experiments rather than infrastructure-level shifts.

Does AP2 require using a specific payment processor?

No. AP2 is payment-agnostic by design, and includes extensions like A2A x402 for stablecoin and cryptocurrency payments alongside traditional card and bank rails.

Where's the actual technical specification for these protocols?

UCP's writeup and spec references live at Shopify Engineering, ACP's full specification is at agenticcommerce.dev with a GitHub reference implementation, and AP2's technical detail is published on Google Cloud's blog and ap2-protocol.org.

References

From the Destm engineering archive. For current work on this topic, start at Solutions or the blog.