How E-Commerce Brands Prepare for Agentic Commerce

TL;DR

• Adobe's Q1 2026 data shows AI-referred traffic to U.S. retail sites grew 393% year over year and converted 42% better than non-AI traffic by March 2026, yet independent survey data puts agent-initiated purchases at only about 3% of current transactions: real and growing, not yet dominant.
• Three protocols are standardizing how agents transact: OpenAI and Stripe's Agentic Commerce Protocol (ACP), Google's Agent Payments Protocol (AP2), and Anthropic's Model Context Protocol (MCP) as adopted by Shopify for catalog and cart access.
• No protocol currently assigns liability when an agent buys the wrong item. Merchants carry the dispute burden today, which is why a written agent-purchase policy (spending caps, revocation, return terms) is 2026 work, not someday work.
• Agentic checkout completed through an API call never touches a browser, so it has no cookies, no referrer header, and no JavaScript tag to fire, which means GA4 and Shopify Analytics miss it by design, not by misconfiguration.

Your SEO content won't make you agent-ready, here's what will

A page written to rank in Google and a product record an agent can act on solve different problems, and most e-commerce teams are still optimizing for the first one. Strong on-page copy, backlinks, and even solid agentic search visibility tell a human, or a citation-focused AI Overview, that a page is relevant. None of that tells a shopping agent whether an item is in stock, what it costs after tax, or whether it ships in time.

What AI shopping agents actually read

An agent evaluating a product doesn't read your headline or your hero copy. It queries structured fields:

• Price
• Availability
• Shipping speed
• Return policy

These are typically exposed through JSON-LD product schema, a merchant feed, or a protocol-specific catalog endpoint like Shopify's Storefront MCP. If that data is missing, ambiguous, or only implied by page layout ("free shipping on orders over $50" buried in a banner rather than encoded as shippingDetails), the agent treats it as a disqualifier, not a detail to guess at, and moves to the next listing.

Where your existing SEO/GEO work still matters and where it stops

Content work isn't wasted, it's just scoped differently than most teams assume. Informational content (buying guides, comparison pages, category explainers) still gets cited in AI Overviews and ChatGPT answers, and citation is often what puts a brand into an agent's shortlist of options to evaluate in the first place. Where SEO/GEO work stops mattering is at the transaction step itself: no amount of well-optimized prose substitutes for a hasMerchantReturnPolicy field an agent can actually parse. Crawlers and shopping agents are also frequently different bots hitting a site for different reasons, and treating every AI visitor the same way hides that distinction. Promptwatch's own bot directory separately classifies commerce-specific agents like Amazon's product-discovery bot and Henry, a shopping agent, apart from citation crawlers such as AI crawlers like GPTBot, precisely because a page can be fully reachable by one and still be functionally invisible to the other.

What agentic commerce actually is and how much volume it really has right now

Agentic commerce is AI agents autonomously finding, comparing, and, with permission, completing purchases on a user's behalf, using structured product data and standardized payment protocols instead of a person clicking through a storefront. It runs on the same catalogs, payment processors, and fulfillment systems that already power e-commerce; what changes is who, or what, is doing the browsing and clicking.

The honest answer on volume is that it's still small, but the growth curve underneath it is not. In Q1 2026:

• AI-referred traffic to U.S. retail sites grew 393% year over year (Adobe Analytics)
• That traffic converted 42% better than non-AI traffic by March 2026, a full reversal from March 2025, when it converted 38% worse
• Visitors arriving from AI sources spent 48% longer per visit and viewed 13% more pages than other visitors

That's referral traffic, though: a person following an AI recommendation to a site, not an agent completing a checkout autonomously. On the narrower question of agent-initiated transactions specifically, Checkout.com's 2026 survey of UK and US merchants and consumers shows:

• Current adoption sits at roughly 3% of transactions
• 89% of merchants surveyed report they're already preparing
• 72% expect consumer adoption to outpace merchant readiness

That gap, low current transaction share against high expected near-term adoption, is the actual case for budgeting now rather than waiting for the number to look more urgent.

Agent-assisted browsing vs. fully agentic checkout

These are two different behaviors worth separating, because they require different readiness work. Agent-assisted browsing is a person using ChatGPT, Perplexity, or a similar assistant to research and compare, then clicking through to buy manually, which shows up as AI-referred traffic in ordinary analytics. Fully agentic checkout is the agent completing the purchase itself, typically through a delegated payment flow like ACP's Checkout API, and it's this second behavior that current web analytics is largely blind to (see the measurement section below). Most of the volume growth Adobe is reporting today is almost certainly the first kind; the second kind is smaller but is what the liability and protocol questions in this piece are actually about.

The three competing protocols you need to know: AP2, ACP, and MCP

Three specifications currently do most of the work of standardizing how an agent transacts with a merchant, and they solve different parts of the problem rather than competing head-to-head on the same layer.

A fourth standard is worth flagging even though it falls outside this table, because it's arguably the most consequential one in practice right now: Shopify and Google jointly published the Universal Commerce Protocol (UCP) in January 2026, with Etsy, Target, Walmart, and Wayfair also named as backers. UCP layers discovery, checkout, and payment-handler negotiation into one specification, and as of mid-2026 it carries more live agent-driven purchase activity, alongside Perplexity's separate Instant Buy feature, than ACP's own in-chat checkout does, a genuine reversal from ACP's early lead when it launched alongside ChatGPT's Instant Checkout in late 2025. For the full breakdown of where each protocol stands today, see our comparison of AP2 vs. ACP vs. MCP.

Who's backing which protocol

The pattern worth noticing isn't which protocol is “best,” it's who's aligned with whom, and that alignment is already shifting once. AP2 has the deepest bench of payments and enterprise partners (see Google Cloud's AP2 announcement and the protocol's own GitHub specification) but doesn't touch catalog discovery. ACP defined the fastest path to being purchasable inside ChatGPT specifically when it launched, though OpenAI narrowed its own in-chat checkout implementation in March 2026; the full specification, checkout flow, and adoption details are still published on the ACP GitHub repository and in Stripe's own documentation, and the protocol continues to be used outside that specific chat surface. MCP's commerce role runs through Shopify's Storefront MCP documentation, which is the most concrete, publicly available technical spec of the three for merchants who already run on that platform.

What “protocol-agnostic” readiness looks like in practice

The practical move is to do the readiness work that pays off no matter which protocol (or combination of protocols) ends up mattering for your buyers. That splits into two layers:

• Protocol-agnostic groundwork (structured product data, machine-readable policies, a written liability position) is useful under ACP, AP2, MCP, or UCP alike, since every one of them ultimately reads the same underlying product and policy data, even though they standardize different parts of the transaction.
• Protocol integration is the layer to treat as reversible. Pick the integration that matches where your buyers already are:
  • Shopify merchants have the most direct path through MCP and UCP, which is also where most live agent-driven purchase volume already sits.
  • Brands with strong ChatGPT referral traffic still have reason to watch ACP, even though its own in-chat checkout narrowed in March 2026.

Don't treat that choice as permanent, though. ACP's own trajectory this year is the clearest evidence that today's leader isn't guaranteed to stay one.

The liability question nobody answers: who eats the cost of a wrong agent purchase

This is the question every merchant preparing for agentic commerce eventually asks, and it currently has no clean answer. When an agent buys the wrong size, orders in the wrong quantity, or gets talked into a fraudulent transaction, existing dispute frameworks weren't built for a scenario involving a user, an agent, and a merchant instead of just a cardholder and a merchant.

What the protocols currently leave to merchant policy

Industry reporting on this gap is consistent: “no settled industry standard exists yet,” and in practice, merchants carry the burden today, because they're the ones responding to the dispute. Traditional chargeback evidence (device fingerprints, IP history, on-site navigation paths) often doesn't exist when an agent completes a purchase through a direct API call, which makes it harder to establish the link between a customer and a transaction that card issuers currently expect to see.

AP2's Mandates are a partial answer to the evidence problem specifically, since a signed Intent Mandate and Cart Mandate create an audit trail of what a user actually authorized. That helps prove authorization happened; it doesn't by itself settle who pays when authorization was real but the outcome was still wrong (the agent picked the wrong item, misread a size chart, or missed a discontinued-product flag). American Express has taken the most concrete public step so far, committing to cover erroneous purchases made by registered AI agents on its network, but that commitment is explicitly about agent error and hallucination, not fraud: what happens when a bad actor defeats the authentication step in the first place is still an open question, even in Amex's own framing.

A starter returns/liability policy for agent-initiated orders

Until a settled standard exists, a written policy that predates the first dispute is better than reacting to one. A reasonable starting point, built from where the current gaps actually are:

• Set an explicit default spending cap on agent-authorized purchases, and require a step-up confirmation above it. Consumer research on this specifically found buyers are comfortable letting an agent spend a moderate amount (roughly the mid-hundreds in local currency) without extra approval, so a cap in that range, adjustable per customer, is a defensible default rather than an arbitrary one.
• Build real-time revocation and cancellation into the flow, not just a support-ticket process. The same research found instant revocation and easy cancellation are two of the top three safeguards buyers say they want before trusting an agent with a purchase; offering neither is a trust gap that shows up as chargebacks later.
• Document delegation and authorization evidence at the point of purchase, not after a dispute is filed. Timestamped logs of when and how a customer set up agent purchasing authority are the closest current substitute for the device fingerprints and navigation history that traditional fraud tooling relies on.
• Use billing descriptors that make agent-initiated charges recognizable to the cardholder. A charge a customer doesn't recognize on their statement is the single most common trigger for an unnecessary dispute, agent-initiated or not.
• Set a return window for agent-initiated orders that's at least as generous as your standard policy, and encode it as structured data (hasMerchantReturnPolicy) rather than a PDF or FAQ paragraph, since an ambiguous or undiscoverable return policy is itself a reason an agent skips a listing before a purchase ever happens.

How to measure agent traffic your analytics stack can't currently see

A retailer can do everything right on structured data and liability policy and still be flying blind on whether any of it is working, because the most direct form of agentic traffic, an agent completing checkout through a direct API call, produces none of the signals standard web analytics depends on.

Why GA4/Shopify Analytics miss agent sessions

The mismatch is architectural, not a configuration mistake. GA4 measures browser behavior: it depends on client-side JavaScript, a DOM, a Google tag firing, and referrer headers arriving with a page request. An agent completing a purchase through ACP's Checkout API, or an equivalent server-to-server call, has none of that. There's no browser, so there's no JavaScript execution environment; no cookies get set because no client-side script ran to set them; and no referrer header arrives because the request never came from a page navigation at all. That transaction is a “silent cart”: it happened, revenue moved, and the analytics stack that's supposed to explain where revenue comes from has nothing to show for it.

This is a distinct problem from the AI-referral traffic Adobe is measuring, which does show up in GA4 because a human is still clicking through a browser to get there. It's specifically the agent-completes-the-purchase-itself case that goes dark, which is also the case most directly shaped by ACP, AP2, and similar protocols.

What to ask your analytics or CDP vendor

Closing this gap means moving measurement to the API layer instead of expecting the browser layer to catch up. Three concrete asks for an analytics or CDP vendor: server-side Measurement Protocol integration that lets a checkout API emit purchase events directly to GA4 rather than relying on client-side tags; API request logging that correlates agent calls back to eventual conversions using a persistent transaction ID, independent of any browser session; and user-agent or request-header detection rules that can segment known agent traffic instead of letting it default into “Direct/None,” where it's indistinguishable from everything else that shows no referrer.

The crawl side of this is more tractable today than the transaction side, and it's worth separating the two rather than waiting for a single dashboard to solve both. Promptwatch's bot directory already classifies commerce-specific agents distinctly from general citation crawlers, tracking named bots like Amazon's product-discovery agent and Henry, a shopping agent, alongside GPTBot and ClaudeBot. That shows whether shopping agents can reach and read a catalog in the first place, which is the precondition for any agent-initiated transaction; it doesn't, on its own, reconstruct the API-level checkout event itself, which is the harder half of the problem and squarely a question for a site's own checkout and analytics stack.

“In Promptwatch we are able to see how active the ChatGPT bot is on our client websites and exactly how often our content is being used in responses of LLMs.” - Marijn ten Bulte, Head of Organic Channels at Advise

FAQ

Do we need to pick one protocol now, or wait?

Neither. The defensible move in 2026 is doing the protocol-agnostic groundwork now (structured product data, machine-readable policies, a written liability position) while treating protocol integration itself as a reversible, buyer-driven choice rather than a bet placed once and locked in. ACP's own trajectory makes the case on its own: it had the earliest, most visible checkout integration in ChatGPT, and OpenAI still narrowed it back to a discovery-and-redirect model within months. With AP2 backed by a broad payments coalition, MCP rolling out across Shopify, and UCP already carrying more live purchase volume than ACP's chat checkout, picking a single winner this early is guessing, not strategy.

Who inside our company should own agentic commerce readiness?

No standard org chart answer exists yet, which is itself worth naming plainly. In practice the work splits across existing functions: e-commerce or product-data teams own structured data and feed accuracy, payments and legal own the liability and returns policy, and marketing or analytics owns attribution and measurement. What most teams are missing isn't a new hire, it's a single named owner pulling those three threads into one readiness effort instead of leaving them to happen independently, or not at all.

Is agentic commerce readiness worth budget in 2026, or is it too early?

It's worth budget now, for a reason that has little to do with predicting exactly when agent-initiated transactions will scale. The structured-data, crawlability, and content-freshness work this piece describes carries its own SEO and GEO value independent of agentic checkout ever reaching meaningful volume, so it isn't spend that gets wasted if the timeline slips further right. The transparency worth stating plainly: no protocol currently dominates, agent-initiated purchases are still roughly 3% of transactions by independent survey estimates, and anyone claiming certainty about which standard wins or how fast this scales is ahead of what the data actually shows.