AI agents are about to do your customers’ shopping. Optimize for them

TL;DR: AI agents inside ChatGPT, Perplexity, and Microsoft Copilot can now search for products, compare them, and complete checkout without a human clicking through to your site. Whether they buy from you depends on structured product data, a machine-readable price and inventory feed, and support for one of the emerging agent-checkout protocols (ACP, AP2, or UCP), not on your homepage copy or your ad spend.

---

Table of contents

1. What is AI agent commerce, and why now
2. The protocols powering agent commerce: ACP, AP2, and UCP
3. How a shopping agent actually finds your product
4. The product data an agent needs before it will buy
5. Checkout for agents: mandates, tokens, and who is liable
6. Where agent-driven orders are already showing up
7. What changes in your SEO and content workflow
8. A 90-day rollout plan
9. What nobody has solved yet
10. Frequently asked questions
11. Key takeaways

---

What is AI agent commerce, and why now

AI agent commerce is a purchase where an AI system, not a human clicking through a browser, does the searching, comparing, and checking out. A shopper tells ChatGPT or Copilot what they want, the assistant queries a merchant’s product feed, presents options, and completes payment through a protocol built for machine-initiated transactions. McKinsey estimates the addressable opportunity for this shift at $3 trillion to $5 trillion by 2030, a number large enough that every major platform has shipped infrastructure for it inside the last twelve months.

Three things landed within weeks of each other in September 2025: OpenAI and Stripe launched the Agentic Commerce Protocol with Instant Checkout inside ChatGPT, Google published the Agent Payments Protocol (AP2) with more than 60 supporting organizations, and Shopify rolled out agent integrations across ChatGPT, Microsoft Copilot Checkout, Google’s AI Mode, and Perplexity in the same release cycle. None of this is speculative. It is shipped, documented, and already moving orders.

The same friction that has always killed conversions, the roughly 70% average cart abandonment rate the Baymard Institute has tracked across 50 studies since 2006, is the exact problem these protocols target. An agent that can check out in one authenticated step removes the multi-page checkout flow that causes a chunk of that abandonment. If your product data is not readable by the agent, the agent skips you and recommends a competitor whose feed is clean. This is not a future-tense warning. It is happening in current release builds of ChatGPT and Copilot right now, and the ai visibility audit work most teams already run for AI Overviews only covers half of what agent commerce checks.

The protocols powering agent commerce: ACP, AP2, and UCP

Three protocols now govern how an AI agent talks to a merchant, and they solve different parts of the transaction. None of them replaces your existing storefront. All three sit on top of it.

Agentic Commerce Protocol (ACP), built by OpenAI and Stripe, is an open standard released under the Apache 2.0 license for “programmatic commerce flows between buyers, AI agents, and businesses,” according to the protocol’s own specification site. It handles PCI-compliant payment credentials through a Shared Payment Token, works over REST or Model Context Protocol connections, and covers physical goods, digital products, subscriptions, and asynchronous purchases. ChatGPT is the first AI platform running it; Stripe is the first payment processor compatible with it. Merchants keep the customer relationship and control how their products are presented, and the agent never becomes the merchant of record.

Agent Payments Protocol (AP2), from Google, extends the existing Agent2Agent and Model Context Protocol standards and was built with more than 60 organizations including Mastercard, American Express, PayPal, Coinbase, Adobe, Etsy, and Shopify, per Google’s launch post. AP2 solves a narrower, harder problem than ACP: proving three things cryptographically, that a user actually authorized the agent, that the agent’s request reflects the user’s true intent, and who is accountable if something goes wrong. It does this with signed digital contracts called Mandates. An Intent Mandate captures what the user asked for; a Cart Mandate is a cryptographically signed, unchangeable record of the exact items and price the user approved. For unattended tasks, like an agent buying a jacket only when it drops below a price threshold, the Intent Mandate is signed upfront with the rules baked in, and the Cart Mandate fires automatically once conditions are met.

Universal Commerce Protocol (UCP) is Shopify and Google’s joint open standard, purpose-built for merchants who want one integration surface instead of three. Shopify’s own numbers, published on its enterprise blog, show why the incentive is there: AI-driven orders on the platform grew 15-fold in 2025.

Here is how the three actually compare for a merchant deciding where to invest first.

Protocol	Backed by	What it standardizes	Payment method	Merchant integration effort	Live in production
ACP	OpenAI, Stripe	Buyer-agent-merchant commerce flow	Stripe Shared Payment Token	✓ Moderate, REST or MCP	✓ ChatGPT Instant Checkout
AP2	Google, 60+ orgs (Mastercard, PayPal, Coinbase, Etsy)	Authorization, authenticity, accountability via signed Mandates	Cards, stablecoins, bank transfers	✗ Higher, cryptographic mandate handling	✓ Reference implementations shipped
UCP	Shopify, Google	Single integration surface across AI shopping surfaces	Platform-dependent	✓ Low if already on Shopify	✓ ChatGPT, Copilot, AI Mode, Perplexity via Shopify
No protocol	None	Nothing; agent falls back to scraping your site	None	✗ N/A	✗ Agent typically skips or degrades to a link

You do not have to pick exactly one. A Shopify merchant on UCP already inherits ACP compatibility for ChatGPT checkout. A merchant on a custom stack has to evaluate ACP and AP2 independently, and the honest answer as of August 2026 is that ACP has the larger current footprint because ChatGPT shipped Instant Checkout first, while AP2’s cryptographic mandate model is the one built for the accountability question regulators will eventually ask about.

How a shopping agent actually finds your product

An agent does not browse the way a human does. It queries a feed, a schema graph, or an API, and it discounts anything it cannot parse with confidence. Understanding the four discovery paths tells you where to spend the next engineering sprint.

Path one: structured data on the page. The agent (or the crawler feeding it) reads Product schema markup directly from your HTML. Schema.org’s own specification defines the properties that carry the most weight for a purchase decision: offers with nested price, priceCurrency, and availability; identifiers like gtin, sku, mpn, and productID; and trust signals like aggregateRating and review. A product page with no schema is legible to a human and largely illegible to an agent evaluating hundreds of candidates in a single query. This is the same gap covered in depth in the complete schema markup guide, and it is worth running that checklist against your top revenue pages before anything else on this list.

Path two: a dedicated product feed. Google Merchant Center feeds, Shopify’s product API, and platform-specific catalogs are increasingly the primary source agents pull from, because a feed is structured, machine-parseable, and updated on a schedule the agent can trust. A feed with stale pricing or “in stock” flags that lag reality does not just hurt Google Shopping. It gets an agent’s cart mandate built on wrong data, which either fails at checkout or gets refunded, and either outcome teaches the agent to deprioritize your catalog on the next query.

Path three: the MCP or ACP connection itself. Once a merchant implements ACP or exposes an MCP server, the agent can query live inventory and pricing directly rather than relying on a cached feed. This is the highest-trust path and, as of August 2026, the one with the smallest number of merchants actually running it.

Path four: fallback web search. When none of the above exists, the agent degrades to a general web search and either summarizes what it finds (with no purchase path) or presents a link for the human to click through manually, at which point you are back to ordinary AI visibility and AEO mistakes territory, not agent commerce at all.

flowchart TD
    A[Shopping agent receives a purchase intent] --> B{Does a product feed exist?}
    B -- No --> C[Agent falls back to web search]
    C --> D[Presents a link, no direct checkout]
    B -- Yes --> E{Is Product schema present and valid?}
    E -- No --> F[Agent can list the product but confidence is low]
    E -- Yes --> G{Does the merchant support ACP, AP2, or UCP?}
    G -- No --> H[Agent recommends, human completes checkout manually]
    G -- Yes --> I[Agent completes Instant Checkout or signs a Cart Mandate]
    I --> J[Order placed inside the AI platform]

Every merchant sits somewhere on this diagram today. The gap between box D and box J is the entire opportunity, and most of it is closed with data hygiene, not a rebuild.

The product data an agent needs before it will buy

An agent evaluating your product against three competitors needs six data points with high confidence, and it needs them in a format it does not have to guess at.

Price and currency, current, not cached. Nested offers.price and offers.priceCurrency from Schema.org are the baseline. A price that differs between your schema and your actual checkout page is the single fastest way to get an order canceled after a Cart Mandate is signed under AP2, because the mandate is a cryptographically fixed record the merchant cannot silently change.

Availability, granular, not binary. “In stock” versus “out of stock” is not enough when an agent is comparing five sellers of the same SKU. Backorder windows, quantity thresholds, and per-variant stock all belong in the feed.

Stable identifiers. gtin, sku, and mpn let an agent confirm it is comparing the identical item across merchants rather than a similarly named substitute. Products without a GTIN are harder for an agent to place with confidence next to a branded competitor that has one.

Shipping and delivery data. shippingDetails, with destination, rate, and delivery time, feeds directly into an agent’s “which of these three options gets there fastest” comparison, a comparison agents are built to run automatically.

Trust signals. aggregateRating and review counts are the fastest proxy an agent has for “is this a real, reliable seller,” in the absence of a long-term relationship with the merchant.

A checkout path the agent can actually call. All the schema in the world does not close a sale if there is no ACP, AP2, or UCP integration behind it. This is the step most merchants skip, because it looks like an engineering project instead of a content one.

One structural note worth stating directly: the same feed and schema discipline that makes a product agent-ready is the discipline multi-channel publishing already demands. A retailer syndicating product content across WordPress, Shopify, and a headless storefront has to keep price, stock, and identifiers consistent across every surface, or agents querying different channels return conflicting answers for the same product. Vrid.ai handles the publishing side of that problem, generating word-count-controlled product and category content and pushing it to WordPress, Ghost, Shopify, and custom endpoints via webhook, so the copy stays in sync with the feed instead of drifting into its own stale version on one channel. It does not touch your payment protocol or your inventory feed; those still need direct integration work on ACP, AP2, or UCP.

Checkout for agents: mandates, tokens, and who is liable

The mechanics differ by protocol, but the underlying question is the same one every checkout has always had to answer: who is liable if this transaction is wrong.

Under ACP, a Stripe Shared Payment Token carries the payment credential in a PCI-compliant form that the merchant’s existing payment stack can process without becoming responsible for storing raw card data, per the ACP specification. The agent never sees the card number; it sees a token scoped to the specific transaction.

Under AP2, the liability question is answered explicitly through the Mandate chain. The Intent Mandate is the auditable record of what the user asked for. The Cart Mandate is the cryptographically signed, unchangeable record of the exact items and price the user approved before payment fired. If a dispute happens, the Cart Mandate is the evidence: it proves what was actually authorized, distinct from what the agent might have interpreted or hallucinated along the way. Stavan Parikh, VP and GM of Payments at Google, describes the goal as giving the ecosystem “a trusted foundation to fuel a new era of AI-driven commerce.” Pablo Fourez, Chief Digital Officer at Mastercard, one of AP2’s 60-plus backers, frames the same problem from the network side: ensuring “trust and safety remain at the core of every transaction” as payment volume shifts from a human tapping a screen to an agent executing a signed mandate.

For delegated purchases, where the agent buys on the user’s behalf without a human present at the moment of purchase, AP2’s model requires the Intent Mandate to be signed upfront with explicit constraints, a price ceiling, a time window, a specific SKU, so the Cart Mandate that eventually fires is bounded by rules the user actually agreed to, not by whatever the agent decides is reasonable in the moment.

The practical takeaway for a merchant: your existing checkout does not need to be rebuilt. What needs to exist is a compliant entry point, a Shared Payment Token handler for ACP or a Mandate-verification step for AP2, that your payment processor increasingly ships as a plugin or API extension rather than custom code.

Where agent-driven orders are already showing up

The numbers so far come from platforms with a direct stake in this shift, so read them as directional rather than independently audited, but they are consistent with each other and with the protocol rollout timeline.

Shopify’s 2025 Global Holiday Report found 64% of shoppers said they were likely to use AI when making a purchase, rising to 84% among shoppers aged 18 to 24. That age skew matters for category planning: apparel, footwear, and beauty brands with a younger buyer base are the ones seeing agent-influenced orders first. Shopify’s own AI-driven order volume grew 15-fold across 2025, with brands including Keen Footwear and Pura Vida cited as early adopters on the enterprise blog.

Microsoft’s data point is the sharpest one available: shoppers using Copilot to research a purchase were 194% more likely to complete the sale than shoppers who did not, according to the same Shopify report. That is not an AI-Overviews-style traffic story, where a summary satisfies the query and the click never happens. It is closer to the opposite, an assistant that walks a shopper through comparison and objection-handling that a static product page does on its own, then hands off to checkout.

None of this shows up yet in standard GA4 acquisition reports, because agent-initiated checkouts often complete inside the AI platform rather than routing through a referral click to your site. If you are already running AI search tracking in GA4, extend it: watch for a widening gap between impressions in your product feed dashboards and sessions in your analytics, because that gap is the agent-completed order you cannot currently attribute. It is the same measurement problem covered in the share of answer framework, applied to a purchase instead of a citation, and the platform behavior differs enough between Perplexity, ChatGPT, and Gemini that a single blended metric will hide more than it reveals.

What changes in your SEO and content workflow

Agent commerce does not replace conventional SEO. It adds a parallel discipline with its own priorities, and the two overlap less than most teams assume.

Conventional product-page SEO optimizes for a human who reads a headline, scans bullet points, and decides to click “add to cart.” Agent-commerce readiness optimizes for a machine that never reads the headline at all; it reads the schema, the feed, and the checkout protocol response. A page can rank on page one and still be invisible to an agent if the Product schema is missing the gtin field or the feed price is 90 days stale. Conversely, a page with mediocre on-page copy but a clean, current feed and ACP support can win an agent-driven order a human search would never have surfaced.

The practical shift for a content or SEO team: audit product data quality with the same rigor you already apply to structured data for AI search, treat your feed as a ranking surface in its own right, and stop assuming that a well-written product description is sufficient input for a purchase decision an agent is making on your behalf. Category pages need the same discipline; the ecommerce category page SEO work on faceted navigation and index bloat directly affects whether an agent can resolve “show me waterproof hiking boots under $150” into a clean, comparable product set instead of a duplicated mess.

Pair this with the broader AI visibility audit you likely already run, and decide deliberately whether to allow or block AI crawlers that feed these agents; a merchant that blocks the crawler behind ChatGPT’s shopping surface is opting out of Instant Checkout entirely, which may be the right call for a luxury brand protecting price integrity, and the wrong call for a commodity retailer competing on convenience.

A 90-day rollout plan

Weeks 1 to 2: audit. Run every top-revenue product page through a schema validator and check for offers.price, offers.availability, gtin or mpn, and aggregateRating. Cross-check the schema price against the live checkout price; any mismatch is priority one.

Weeks 3 to 6: fix the feed. If you run Google Merchant Center, Shopify’s product API, or a comparable feed, verify update frequency matches your actual inventory change rate, not a default weekly sync that leaves stale stock flags live for days.

Weeks 7 to 10: pick a protocol. Shopify merchants get UCP largely for free through existing platform integrations. Non-Shopify merchants should evaluate ACP first, given ChatGPT’s current lead in production volume, and treat AP2 as the next step once the Mandate-based liability model matters for your transaction size or regulatory exposure.

Weeks 11 to 13: instrument and monitor. Extend GA4 or your analytics stack to flag traffic and conversion patterns consistent with agent referral, and set a recurring review of feed impressions versus completed checkouts so a growing gap gets caught early instead of discovered in a quarterly report.

This sequence deliberately puts data hygiene before protocol integration. A merchant that implements ACP on top of a feed with stale pricing has automated the exact failure mode that erodes agent trust fastest: a Cart Mandate signed against a price that turns out to be wrong. Treat the rollout the same way you would decide what to automate versus what to handle manually anywhere else in your stack: feed sync is a strong automation candidate, protocol selection and liability review are not.

What nobody has solved yet

Being direct about the gaps matters more here than in most SEO topics, because the incentive to overclaim readiness is high and the failure mode, a canceled or disputed transaction, is expensive.

Liability for a bad agent recommendation is not fully settled. AP2’s Mandate chain gives you an audit trail proving what the user authorized, but it does not resolve every dispute scenario, particularly when an agent’s summarization of a product introduces an error the user never saw before approving. Cross-platform identity, proving the same human is behind a request routed through ChatGPT one day and Copilot the next, has no unified standard yet. And return and refund flows for agent-initiated purchases are still handled through each merchant’s existing policy, with no protocol-level standardization for how an agent should communicate a return request back to the platform that placed the order. Nobody has clean data yet on return rates for agent-completed purchases versus human-completed ones, and any number claiming otherwise before enough transaction volume accumulates should be treated skeptically.

Frequently asked questions

What is AI agent commerce?

AI agent commerce is a transaction where an AI assistant, such as ChatGPT, Microsoft Copilot, or Perplexity, searches for products, compares options, and completes checkout on a user’s behalf, without the user manually browsing a website. It relies on structured product data and a checkout protocol like ACP or AP2 rather than a traditional click-through shopping session.

Do I need to support ACP, AP2, and UCP all at once?

No. Start with whichever matches your current stack: Shopify merchants inherit UCP through existing platform integrations with minimal extra work. Non-Shopify merchants should evaluate ACP first, since ChatGPT’s Instant Checkout has the largest current production footprint, and add AP2 later if Mandate-based liability protection becomes a priority.

Will agent commerce replace my regular ecommerce traffic?

Not in the near term. Shopify’s 2025 Global Holiday Report found 64% of shoppers likely to use AI when purchasing, rising to 84% among 18-24 year-olds, which signals a meaningful but not universal shift. Traditional search and direct traffic remain the majority of orders as of August 2026; agent commerce is an additional channel, not a replacement for the others.

How is this different from optimizing for AI Overviews?

AI Overviews optimization targets getting cited in a summary a human reads before deciding whether to click through. Agent commerce optimization targets getting selected and purchased by a system that never shows the human a summary at all; it acts directly on structured data and a checkout protocol. The two overlap on structured data hygiene but diverge completely on the checkout and feed requirements.

What is the single highest-impact fix for agent readiness?

Match your Product schema price and availability to your live checkout price and stock, exactly, with no lag. A schema mismatch is the fastest way to get an agent-initiated order canceled or refunded, and repeated mismatches teach agents to deprioritize your catalog on future queries.

Does my product need a GTIN to be agent-ready?

It is not strictly required by every protocol, but a stable identifier like a gtin, mpn, or sku lets an agent confirm it is comparing the identical item across sellers rather than guessing at a match. Products without one are harder for an agent to place confidently next to a branded competitor that has one.

What is a Cart Mandate in Google’s AP2?

A Cart Mandate is a cryptographically signed, unchangeable record of the exact items and price a user approved before payment executed under Google’s Agent Payments Protocol. It exists to prove, after the fact, exactly what the user authorized, separate from anything the agent may have summarized or interpreted along the way.

Can an AI agent buy something without a human present?

Yes, under AP2’s delegated-task model. A user signs an Intent Mandate upfront with explicit constraints, such as a price ceiling and a time window, and the agent’s Cart Mandate fires automatically once those conditions are met, without requiring the human to approve the specific transaction in real time.

Is Stripe required to support ACP?

Stripe is the first payment processor compatible with ACP and currently the reference implementation via its Shared Payment Token, but the protocol itself is open source under Apache 2.0, meaning other payment processors can build compatible integrations over time.

How does an agent handle out-of-stock products?

It depends entirely on how granular your feed’s availability data is. A binary “in stock or out” flag forces the agent to guess at partial availability or backorder timing. Feeds with quantity thresholds and backorder windows let the agent give the user an accurate answer instead of a failed checkout attempt.

Should small merchants worry about this yet, or is it enterprise-only?

Any merchant on Shopify already has a low-effort path through UCP, so the barrier to entry is lower than the protocol names suggest. A small merchant with clean Product schema and an accurate feed is often more agent-ready than a large retailer with a stale legacy catalog, because agent readiness rewards data hygiene over scale.

What happens if I block AI crawlers entirely?

You opt out of agent-driven discovery and checkout for whichever platforms’ crawlers you block. That may be the right call for a brand protecting price integrity or avoiding scraped content reuse, but weigh it against the decision framework for blocking AI crawlers, since the tradeoff differs by category and margin structure.

Do reviews and ratings actually influence an agent’s purchase decision?

They function as a trust proxy in the absence of a long-term merchant relationship. aggregateRating and review fields in your Product schema give an agent comparing several unfamiliar sellers a fast signal for reliability, similar to how a human shopper uses star ratings when choosing between two unfamiliar brands.

How do I track agent-driven orders in my analytics?

Agent-completed checkouts frequently complete inside the AI platform itself rather than routing a referral click to your site, so standard GA4 acquisition reports undercount them. Extend your AI search tracking setup in GA4 and watch for a widening gap between feed impressions and attributed sessions as an early signal of unattributed agent volume.

Is llms.txt required for agent commerce?

No. llms.txt is a separate, largely unrelated mechanism for guiding AI crawlers to documentation-style content; Google has stated it does not use llms.txt for Search, and agent commerce protocols rely on Product schema, feeds, and checkout APIs, not llms.txt, to evaluate and complete a purchase.

What is the Model Context Protocol’s role in agent commerce?

MCP is the open connection standard, originally built by Anthropic, that lets an AI application talk to external tools and data sources; ACP is explicitly built to work over MCP or REST, so a merchant exposing an MCP server can let an agent query live inventory and pricing directly rather than relying on a periodically refreshed feed.

Which product categories are seeing the most agent-driven purchases first?

Shopify’s data skews toward apparel, footwear, and beauty, consistent with the 84% AI-purchase-likelihood figure among 18-24 year-old shoppers in its 2025 Global Holiday Report. Categories with a younger buyer base and frequent repeat purchases are the early adopters; complex, high-consideration categories like furniture or major appliances are moving more slowly.

Does agent commerce affect B2B sellers too?

Google’s AP2 launch explicitly names autonomous procurement and automatic software license scaling as enterprise use cases, so B2B is part of the design intent, not an afterthought. A B2B seller with a clean product API and clear pricing tiers is positioned to benefit from agent-driven procurement the same way a B2C retailer benefits from agent-driven checkout.

How do returns work for an agent-initiated purchase?

There is no protocol-level standard yet for how an agent communicates a return request back through the platform that placed the order. Returns currently route through each merchant’s existing return policy and process, the same as any other order, which means your standard return workflow needs to work correctly regardless of how the order originated.

What is the fastest way to test whether my products are agent-ready today?

Ask ChatGPT or Copilot directly to find and compare your product against a named competitor, using the exact product name and category. If the assistant surfaces accurate price, availability, and a checkout path, your data is working. If it returns stale pricing, a generic description, or no purchase path at all, that gap points directly to the schema or feed fix to prioritize first.

Key takeaways

• AI agent commerce is live in production today through ACP (OpenAI, Stripe), AP2 (Google, 60+ organizations), and UCP (Shopify, Google), not a future roadmap item.
• Whether an agent buys from you depends on Product schema accuracy, feed freshness, and checkout protocol support, in that order of priority.
• A price or availability mismatch between your schema and your live checkout is the single fastest way to lose agent trust and get an order canceled.
• Shopify merchants get the lowest-effort path in through UCP; everyone else should evaluate ACP first given ChatGPT’s current production lead.
• Liability, cross-platform identity, and return-flow standardization for agent-initiated purchases are all still unresolved; treat any confident claim otherwise with skepticism.

Run the schema and feed audit in this guide against your top revenue products this week. The merchants seeing agent-driven orders today are not the ones with the biggest catalogs; they are the ones whose product data an agent can trust without a human double-checking it.