Agentic commerce is the point where a shopper stops browsing and starts delegating. Instead of opening ten tabs, a customer asks an AI assistant to find a mid-range espresso machine under $400 with free returns, and the assistant browses, compares, checks stock and, increasingly, completes the purchase. For retailers this is not a distant thought experiment. As of mid-2026, ChatGPT, Google’s Gemini surfaces, Microsoft Copilot, Perplexity and Amazon’s own assistants can all move a shopper from a question to a checkout with a small number of taps, and the payment networks have shipped the credential layer that lets an agent pay on a customer’s behalf. This guide explains how the stack works end to end, where stores drop out of the funnel without knowing it, and what to fix first.
In short
- Agentic commerce means AI agents discover, evaluate and buy products for a shopper; the merchant’s job shifts from persuading a human to being legible and transactable to software.
- Inclusion is decided by data, not design: agents pull from structured product feeds, schema markup and crawlable pages, so an incomplete feed or a blocked crawler removes you from the shortlist before any comparison happens.
- Checkout runs on protocols: OpenAI’s Agentic Commerce Protocol, Google’s Universal Commerce Protocol and Agent Payments Protocol, plus Visa Intelligent Commerce and Mastercard Agent Pay, define how an agent presents an order and a tokenized payment credential.
- Agents weigh trust signals mechanically: return windows, delivery promises, review counts and total landed price are compared as fields, and vague or missing values lose to explicit ones.
- Attribution is the quiet problem: agent-driven orders show up as direct traffic, generic referrals or API calls, so most retailers undercount this channel and underinvest in it.
What agentic commerce means and what is already live
The phrase covers a spectrum, and it helps to separate the layers before deciding what matters for a given store. At the shallow end, an assistant answers a product question and links to a product page: this is closer to AI search than to agentic buying, and it is already the largest source of agent-originated traffic for most retailers. In the middle, the agent builds a comparison, checks live availability and hands the shopper a pre-filled cart. At the deep end, the agent holds a payment credential, places the order and manages post-purchase steps like tracking and returns, with the human only approving the final total.
Several of these deep-end experiences are commercially live. OpenAI introduced Instant Checkout inside ChatGPT in late 2025, built on the Agentic Commerce Protocol it co-developed with Stripe, and opened it first to Etsy sellers and then to Shopify merchants. Google announced the Universal Commerce Protocol at NRF in January 2026 with launch partners that reportedly included Shopify, Walmart, Target, Etsy and Wayfair, and wired it into AI Mode and Gemini. Microsoft launched Copilot Checkout with PayPal and Shopify support in the same window. Perplexity’s shopping features let users complete purchases inside the answer surface, and Amazon’s Rufus and “Buy for Me” show how a marketplace can act as both agent and merchant.
What changed underneath is the payment layer. Visa Intelligent Commerce and Mastercard Agent Pay, both first announced in 2025, extend network tokenization so an agent can hold a scoped, revocable credential rather than a raw card number. PayPal and Stripe shipped agent-facing toolkits that let a merchant accept those credentials with limited integration work. The practical consequence is that “can an agent buy from my store” is now mostly a question of whether the merchant has turned the capability on, not whether the technology exists.
Three tiers of readiness
Retailers tend to sit in one of three tiers. The first tier is visible: the agent can find and describe your products accurately. The second tier is comparable: the agent can pull price, stock, shipping cost and return terms as structured fields and put them next to competitors. The third tier is transactable: the agent can hand off or complete an order through a supported protocol. Most mid-market stores are partially in tier one and nowhere in tier three, and the gap is rarely a technology problem so much as a data hygiene problem, which is why this guide spends so long on feeds and markup before it reaches checkout.
How an agent moves from question to purchase
An agent’s shopping journey is not a web session; it is a sequence of retrieval and tool calls, and each step is a filter. Understanding the sequence explains why a store can rank well in classic search and still be absent from an agent’s shortlist. The following description is a synthesis of how the major assistants have publicly described their shopping flows, and the specifics vary by platform and change often.
Step one: intent parsing and constraint extraction
The agent turns a natural-language request into a set of hard and soft constraints: category, budget ceiling, must-have attributes, delivery deadline, preferred retailers, and exclusions. Anything the shopper states explicitly becomes a hard filter. This is the first place a merchant can lose: if your product data does not expose an attribute the shopper filtered on (say, “dishwasher-safe” or “fits a 15-inch laptop”), the agent cannot confirm the match and will often drop the product rather than guess.
Step two: candidate retrieval
The agent gathers candidates from whatever sources it has: a partner product feed (Google Merchant Center, OpenAI’s merchant feed spec, Microsoft Merchant Center), a live web search, a marketplace API, or a cached index built by its own crawler. Retrieval is usually generous at this stage, pulling dozens of candidates, but it is only generous among products it can see. A store that blocks the relevant crawlers, has no feed relationship and thin structured data is effectively not in the candidate pool.
Step three: verification and comparison
The agent then fetches or re-reads candidate pages to verify price, stock and terms, because feed data can be stale. It normalizes what it finds into a comparison: total cost including shipping and tax estimates, delivery window, return policy, and rating signals. This is the step where explicit beats implied. A page that says “free returns within 30 days” in a structured returns policy field is compared cleanly; a page that says “hassle-free returns” in a banner may be read as unspecified.
Step four: recommendation and handoff or checkout
The agent presents a shortlist, typically three to five options with reasoning. If the shopper picks one and the merchant supports a checkout protocol, the agent assembles the order, applies any eligible promotion it can verify, and either presents a pre-authorized total for one-tap approval or hands the shopper to the merchant’s checkout with the cart pre-filled. Where no protocol is supported, the agent links to the product page and the merchant reverts to a normal web session, losing the conversion advantage of a warm, pre-qualified buyer.
Retailers who already invest in feed quality for Shopping ads have a head start here, which is one reason we treat agent readiness as an extension of the broader retail marketing playbook for AI search and social commerce rather than a separate discipline. The same product data that earns a Shopping placement is what an agent reads first.
Where agents get product data and why yours may be missing
Every agent platform draws on a mix of three data sources, and each has a distinct failure mode for merchants. Diagnosing which one is dropping your catalog is the single most valuable exercise a retailer can run this quarter.
Source one: merchant feeds
Google Merchant Center feeds power Shopping, AI Mode product results and, through the Universal Commerce Protocol, Gemini’s shopping surfaces. OpenAI published a product feed specification for ChatGPT shopping that mirrors many Merchant Center fields and adds agent-specific ones like return policy details and fulfillment options. Microsoft Merchant Center feeds Copilot. Feeds are the highest-fidelity path because the merchant controls the values, but they fail when fields are missing, inconsistent with the live page, or updated too infrequently to reflect stock. The product feed for AI shopping agents breakdown lists the fields that decide inclusion and how to audit them. Our analysis of why the agentic commerce bottleneck has shifted to product feeds goes into the specific fields that platforms have started treating as mandatory.
Source two: structured data on the page
Schema.org Product, Offer, AggregateRating, MerchantReturnPolicy and OfferShippingDetails markup is what an agent reads when it verifies a candidate page, and it is what search-based agents rely on when there is no feed relationship. The failure mode here is partial markup: a Product with a name and image but no Offer, or an Offer with a price but no availability or priceValidUntil, or a return policy described only in prose. Agents treat missing structured values as unknown, and unknown loses comparisons.
Source three: crawled page content
Assistants also crawl and index pages directly. OpenAI operates OAI-SearchBot for search indexing, GPTBot for training and ChatGPT-User for live fetches on a user’s behalf. Google uses Googlebot for its AI surfaces and Google-Extended as a training control. Perplexity, Anthropic, Meta and others run their own crawlers. Many retailers blocked all AI crawlers in robots.txt during 2023 and 2024 to protect content from training and never revisited the decision, which now means their pages cannot be fetched at the verification step even when they appear in a feed.
| Data source | Who reads it | Typical failure | Fix owner |
|---|---|---|---|
| Merchant feed (Google, OpenAI, Microsoft) | Shopping surfaces, ACP and UCP checkout, Copilot | Missing return, shipping or GTIN fields; stale stock | Feed manager or e-commerce ops |
| Schema.org markup on product pages | Verification fetches, search-based agents | Product without Offer; policy in prose only | Platform team or theme developer |
| Crawled HTML content | All assistants for retrieval and answers | Crawlers blocked in robots.txt; JS-only rendering | SEO lead with security sign-off |
| Marketplace listings (Amazon, Walmart, Etsy) | Marketplace-native agents, some third-party agents | Listing owned by a reseller; wrong brand data | Marketplace or channel manager |
A quick self-audit
Three checks cover most of the risk. First, fetch your robots.txt and look for disallow rules on OAI-SearchBot, ChatGPT-User, Google-Extended, PerplexityBot and any wildcard that catches them; training-bot blocks and retrieval-bot blocks are different decisions and should be made separately. Second, run a product URL through a structured data validator and confirm Product, Offer with price, priceCurrency and availability, plus shipping and return policy nodes. Third, open your Merchant Center diagnostics and count disapproved or limited items, because the same issues that limit Shopping eligibility limit agent eligibility.
Checkout: the protocols and permissions agents need
Discovery gets a product onto a shortlist; checkout determines whether the merchant captures the order or watches the agent route it to a competitor who supports a smoother path. As of mid-2026 there are several overlapping protocols, and the sensible way to read them is by which layer each one addresses.
Order-layer protocols
OpenAI’s Agentic Commerce Protocol (ACP) defines how an agent presents a cart, retrieves a checkout session, applies fulfillment options and submits an order to a merchant endpoint, with Stripe’s Shared Payment Token as the reference payment method. Google’s Universal Commerce Protocol (UCP) covers a similar surface for Google’s assistants and, according to Google’s launch materials, was designed to interoperate with the Agent Payments Protocol and to be adopted by other platforms. Shopify, Commerce Cloud, BigCommerce and commercetools have all shipped or announced native support for at least one of these, which is why platform choice increasingly decides how much integration work a merchant faces.
Payment-layer protocols
Google’s Agent Payments Protocol (AP2) introduces signed “mandates”: a cryptographically verifiable record that the shopper authorized an agent to buy a specific item at a specific price, which gives merchants and issuers evidence in a dispute. Visa Intelligent Commerce and Mastercard Agent Pay work at the network level, issuing agent-scoped tokens that carry spending limits and merchant restrictions. Stripe and PayPal provide the merchant-facing wrappers. The retailer-controlled checkout model that most large merchants have pushed for keeps the order of record on the merchant side while accepting the agent’s tokenized credential, and that model appears to be winning.
| Protocol | Sponsor | Layer | What the merchant integrates | Where it appears |
|---|---|---|---|---|
| Agentic Commerce Protocol (ACP) | OpenAI with Stripe | Order and checkout | Checkout endpoints plus feed; Shared Payment Token | ChatGPT Instant Checkout |
| Universal Commerce Protocol (UCP) | Google with retail partners | Order and checkout | Merchant Center feed plus checkout capability | AI Mode, Gemini, Google Shopping |
| Agent Payments Protocol (AP2) | Google with payment partners | Payment authorization | Mandate verification via PSP | Cross-platform, adopted by PSPs |
| Visa Intelligent Commerce | Visa | Network credential | Token acceptance through acquirer | Any agent using Visa tokens |
| Mastercard Agent Pay | Mastercard | Network credential | Token acceptance through acquirer | Any agent using Mastercard tokens |
Permissions and what the agent is allowed to do
Beyond the technical handshake (the store-side requirements are itemized in our guide to agentic checkout for merchants), a merchant sets policy: which agents may transact, whether agent orders can use promotions, whether loyalty accounts can be linked, and whether the agent may act on a stored customer profile. These settings live in the platform’s agent or channel configuration and in the merchant’s terms. Getting them wrong in the permissive direction exposes the store to coupon abuse at machine speed; getting them wrong in the restrictive direction silently disqualifies the store from most agent checkouts. A reasonable starting posture is to allow verified agents from named platforms, permit promotions only where the agent passes a verifiable mandate, and log every agent order with the platform identifier for later analysis.
Governance of these protocols is still moving. The question of whether ACP and UCP converge, hand off to a neutral body or continue to compete is open, and platforms have shipped abstraction layers that let a merchant support several at once. For most stores the practical approach is to integrate through the commerce platform’s native capability rather than build against any single protocol directly.
Pricing, promotions and how agents compare offers
Agents compare offers as arithmetic, which changes how pricing tactics behave. A human might be persuaded by a strikethrough price, a countdown or a bundle; an agent computes the total landed cost for the shopper’s specified quantity and delivery window and ranks accordingly. Several consequences follow that retailers should reason about carefully rather than assume.
Total cost beats headline price
When an agent can see shipping cost and estimated tax, it compares the delivered total. A $79 item with $9.95 shipping loses to an $85 item with free shipping in a straight comparison, even though the first would likely win on a search results page where only the headline price shows. Merchants that have optimized for a low displayed price and recovered margin in shipping fees should expect that strategy to underperform in agent channels, and should model whether a threshold-based free shipping offer or a delivered-price display does better.
Promotions only count if the agent can verify them
An agent applying a promotion needs to know the code, the eligibility rules and whether the code is valid for the shopper. Public, structured promotions (a sitewide code exposed in the feed, or a cart-level rule the checkout API returns) get applied. Promotions that exist only as a banner image or an email offer do not. This tends to reward simpler, transparent promotion structures and penalize complex stacking rules, because the agent will often show the shopper the verified total rather than an optimistic one.
Personalized pricing and steering are under scrutiny
Agents also surface pricing behavior that used to be invisible. If the same product shows a different price to a logged-in agent session and an anonymous fetch, the agent may report the discrepancy or treat the lower price as the reference. Regulators have taken an interest: the Federal Trade Commission has been examining surveillance-based and personalized pricing practices, and consumer protection authorities in the US and EU have signaled interest in how AI recommendations are ranked and disclosed. None of this constitutes legal guidance; it means pricing logic that varies by session or device should be reviewed with counsel before it meets an agent channel at scale.
What a comparison actually looks like
The table below is an illustrative example of how an assistant might normalize three offers for a shopper who asked for delivery within three days and free returns. It is a model of the logic, not a report on any specific product, and the exact weighting differs by platform.
| Field | Store A | Store B | Store C |
|---|---|---|---|
| Listed price | $79.00 | $85.00 | $82.00 |
| Shipping to shopper’s ZIP | $9.95 | Free | $4.99 |
| Delivered total (pre-tax) | $88.95 | $85.00 | $86.99 |
| Delivery window | 4–6 days | 2–3 days | Not stated |
| Return policy (structured) | 30 days, free | 30 days, free | Not stated |
| Meets shopper constraints | No (delivery) | Yes | Unknown |
| Likely shortlist rank | 3 | 1 | 2 or excluded |
Store C is the instructive case. It may well ship in two days with free returns, but because those values are not exposed as data, an agent cannot confirm them, and a conservative agent will either rank it below a verified option or exclude it. The cheapest fix in the entire agentic commerce stack is often just stating policies in structured form.
Trust signals agents weigh: returns, delivery, reviews
Human shoppers form trust from design, brand familiarity and a general sense that a site looks legitimate. Agents form trust from fields and corroboration. The signals below are the ones that platforms have publicly documented or that show up consistently in agent output, roughly in order of how often they decide a shortlist.
Return policy
Return window, whether returns are free, restocking fees and the method (mail-in, in-store, carrier pickup) are the most frequently compared trust fields, because “can I send it back” is the first risk a delegating shopper wants covered. Schema.org’s MerchantReturnPolicy type and the returns fields in merchant feeds are the channels agents read. A policy page in prose is better than nothing, but it depends on the agent’s reading of the text rather than a clean value.
Delivery promise
Agents parse handling time, transit time and cutoff time, and they prefer a committed window over an estimate. Merchants that expose per-region shipping details in the feed or OfferShippingDetails markup get compared accurately; those that only show a delivery estimate after a ZIP code is entered at checkout are often treated as “not stated” at the comparison stage. Real-time carrier integration is a bonus, but a simple published matrix of handling plus transit days by region covers most of the value.
Reviews and ratings
AggregateRating markup with a rating value and review count is read directly, and agents cross-check against third-party sources like Google’s seller ratings, Trustpilot and marketplace ratings where the same product is listed. Very high ratings with low counts are discounted; consistent ratings across sources are trusted. Retailers that gate reviews behind JavaScript widgets should confirm the markup is rendered in the HTML the crawler sees, not injected client-side after load.
Merchant identity and corroboration
Agents look for a consistent business identity: a legal name, physical address and contact details on the site that match the Merchant Center or platform profile and, where relevant, a payment processor’s merchant record. Mismatches are a common reason an agent hedges its recommendation with cautions about an unfamiliar seller. Publishing Organization markup with sameAs links to verified profiles is inexpensive and helps.
Stock and price stability
Because agents re-verify at purchase time, a store whose live price or availability frequently disagrees with its feed acquires a reliability penalty on some platforms. Merchant Center’s automatic item updates exist precisely to keep feed and page in sync, and equivalent freshness controls in the OpenAI feed spec reward merchants who update at least daily and ideally on every price or stock change.
Attribution: agent traffic in your analytics
Most retailers are underestimating how much of their traffic and revenue already involves an AI agent, because agent activity falls through the gaps in standard analytics. Understanding the mechanics of the gap is the first step to closing it.
Why agent traffic hides
There are four mechanisms. First, many assistants open links in an in-app browser or through a proxy that strips the referrer, so the session lands as direct. Second, when a referrer is preserved, GA4’s default channel grouping files chatgpt.com, perplexity.ai, gemini.google.com or copilot.microsoft.com under Referral, mixed with hundreds of other domains. Third, protocol-based checkouts do not generate a web session at all; the order arrives through an API and appears in order data with a channel or source field only if the platform integration writes one. Fourth, the human often finishes a purchase later on a different device after an agent did the research, which is the classic assisted-conversion problem with a new assist source.
What to build
A workable attribution setup has three parts. In GA4, create a custom channel group with an “AI assistants” channel matched on source regex for the known assistant domains, and review the list quarterly because new domains appear often. In order data, ensure the commerce platform records the agent platform identifier from ACP or UCP orders as a first-class field, and report it alongside web channels rather than leaving it in raw metadata. In server logs, count fetches by verified agent user agents (ChatGPT-User, PerplexityBot’s fetch variant, Google’s fetch agents) per product URL, which is the closest thing to an impression share metric for agent channels today.
Measurement plumbing has been fragile across the platform layer this year: we covered why the Shopify checkout cutover was more likely to break measurement than checkout itself, and the same pattern applies to agent integrations, where the order flow works on day one and the reporting takes a quarter to catch up. Instrument attribution before volume arrives, not after.
A realistic view of the numbers
Published figures on agent-originated commerce vary widely by source, and most are estimates from vendors with an interest in the number being large. A more useful internal metric is the share of sessions and orders that a retailer can positively attribute to an assistant referrer or protocol order, tracked monthly, alongside the share of product pages that are being fetched by agent user agents. Those two curves, and the gap between them, show whether your store is being read but not chosen, or simply not read.
Risks: scraping, margin pressure and losing the customer relationship
The upside of agentic commerce is real, but the retailers who benefit will be the ones who managed its risks deliberately. Three deserve board-level attention, and the goal in each case is a considered policy rather than a reflexive block or a reflexive open door.
Scraping, crawl load and content control
Agent traffic includes both legitimate retrieval on a user’s behalf and bulk crawling for training or index building, and the two are hard to separate at the network edge. Cloudflare and other CDNs have introduced controls that distinguish verified agents from anonymous scrapers, including signed bot identity proposals and pay-per-crawl models. A retailer’s crawler policy should distinguish at least three cases: training crawlers (a commercial decision about content), search and retrieval crawlers (almost always worth allowing), and unverified high-volume scrapers (rate-limit or block). Wholesale blocking of anything with “AI” in the user agent is the most common mistake we see and it is the one that removes stores from the candidate pool entirely. Whether a given scraper’s activity is lawful is a jurisdiction-specific legal question and outside the scope of this guide; treat the framework here as operational, not legal, and seek counsel for terms-of-service and enforcement decisions.
Margin pressure from perfect comparison
When every offer is normalized to a delivered total and ranked, price competition intensifies and differentiation through presentation weakens. Retailers with genuine advantages (exclusive assortment, faster delivery, better return terms, bundled service) will find agents reward those advantages more consistently than humans did. Retailers whose model depends on friction, confusion or presentation will be squeezed. The strategic response is to make real advantages machine-readable and to model unit economics for the agent channel separately, including any platform fees that ACP or UCP checkouts carry.
Disintermediation of the customer relationship
If the assistant owns the conversation, the merchant risks becoming a fulfillment endpoint with no email address, no loyalty enrollment and no second purchase. The retailer-controlled checkout model mitigates this by keeping the order of record with the merchant and, on most protocols, passing the customer’s contact details with consent. Merchants should confirm what customer data each protocol delivers, ensure post-purchase communication is set up for agent orders, and treat loyalty linkage as a priority feature request to their platform.
Disputes and fraud in an agent-initiated order
Card network rules for agent-initiated transactions are still being written, and merchants have reasonably asked how liability works when a customer disputes an order their agent placed. The signed-mandate approach in AP2 and the scoped tokens in Visa and Mastercard’s programs are designed to provide evidence, but the operational rulebooks have lagged. We analyzed why agent chargeback rules were likely to miss the 2026 holiday season, and the practical implication is that merchants should retain mandate and token evidence for every agent order and monitor dispute rates on that channel separately from web orders.
Ranking and disclosure exposure
Agents are recommendation engines, and how they rank offers is attracting regulatory attention on both sides of the Atlantic. Retailers do not control the assistant’s ranking, but they do control what they submit, and submitting inaccurate structured data (a return policy that is not honored, a delivery window that is not met) is the kind of discrepancy that surfaces quickly when an agent re-verifies. Keep the data honest and the exposure stays with the platform.
A practical readiness checklist for retailers
The following sequence is ordered by leverage per hour of effort. Most retailers can complete the first two stages in a quarter with existing staff; the third depends on platform capabilities and is largely a configuration and policy exercise on modern commerce platforms.
Stage one: be visible (weeks 1–4)
- Audit robots.txt and any CDN bot rules. Explicitly allow retrieval crawlers from the major assistants; make a separate decision on training crawlers.
- Confirm product pages render name, price, availability, images and description in server-side HTML, not only after JavaScript execution.
- Validate schema.org Product and Offer markup on a representative sample of pages and fix the top three error classes sitewide.
- Check Merchant Center for disapprovals and limited items; the same catalog quality issues affect agent surfaces.
Stage two: be comparable (weeks 4–10)
- Add structured return policy (MerchantReturnPolicy) and shipping details (OfferShippingDetails) to markup and the corresponding feed fields.
- Expose delivery windows by region in the feed rather than only at checkout.
- Populate GTIN, brand, MPN and the category-specific attributes shoppers filter on; fill the attribute gaps with the highest search volume first.
- Ensure AggregateRating is in the HTML and that review counts are consistent across the site and third-party profiles.
- Publish Organization markup with legal name, address and sameAs links to verified profiles.
- Move feed updates to at least daily, with event-driven updates for price and stock changes where the platform supports them.
Stage three: be transactable (weeks 8–16)
- Enable the agent checkout capability native to your platform (ACP, UCP or both), or scope the integration if you are on a custom stack.
- Confirm token acceptance with your PSP for Visa and Mastercard agent credentials, and turn on mandate verification where offered.
- Set agent permissions policy: allowed platforms, promotion eligibility, loyalty linkage, and data passed with the order.
- Build the attribution layer: GA4 AI assistants channel, order-level agent identifier, and server-log fetch counts by product.
- Run a controlled test: place agent orders through each supported assistant, verify the order of record, customer data, and post-purchase emails, and measure time to reporting.
Where a retailer sits on this path is now measurable from the outside. Third-party assessments have begun to score retailers on whether AI agents can actually shop their stores, and one such ranking framed the question bluntly, with results that mostly tracked feed and markup quality rather than brand size. Marketing teams should treat this checklist as part of the same operating plan as search and social, and coordinate it with the priorities in the retail marketing guide for AI search and social commerce, because the data work overlaps almost entirely.
Who owns it
Agent readiness fails most often for organizational rather than technical reasons: feed quality sits with performance marketing, markup with the platform team, robots.txt with SEO, checkout protocols with payments, and attribution with analytics, and nobody owns the whole. Naming a single owner, typically the head of e-commerce or digital product, with a quarterly readiness scorecard is the intervention that most reliably turns the checklist into progress.
Where agentic commerce goes next
Three developments are worth watching through 2027. The first is protocol consolidation: the market is unlikely to sustain several competing checkout standards indefinitely, and either a handoff to a neutral body or a de facto winner through platform adoption would simplify integration considerably. The second is the expansion from considered purchases into replenishment and local fulfillment, where an agent reorders household staples or arranges same-day pickup, which favors retailers with strong inventory visibility by store. The third is the maturation of network rules for agent-initiated transactions, which will settle the liability questions that currently make some merchants cautious.
For a retailer, none of these change the near-term work. The store that is visible, comparable and transactable today is positioned for every version of the future; the store that is waiting for the standards to settle is absent from the shortlist while it waits. Public data on the underlying trend is easy to find: the US Census Bureau’s quarterly e-commerce reports track the share of retail sales that happen online, and the broader concept of software acting on a principal’s behalf has a long history documented in Wikipedia’s overview of intelligent agents. Agentic commerce is where those two lines meet, and the merchants who make their catalog legible to software will be the ones the software recommends.
FAQ on agentic commerce
What is agentic commerce in plain terms?
Agentic commerce is shopping where an AI agent, acting on a person’s instructions, does the searching, comparing and often the buying. The shopper sets constraints and approves the result; the agent handles retrieval, verification and, where the merchant supports it, checkout using a tokenized payment credential.
Which AI assistants can actually complete a purchase as of 2026?
As of mid-2026, ChatGPT supports Instant Checkout with participating merchants through the Agentic Commerce Protocol, Google’s AI Mode and Gemini support checkout through the Universal Commerce Protocol with partner retailers, Microsoft Copilot offers Copilot Checkout, and Perplexity supports in-answer purchasing with selected merchants. Amazon’s assistants can buy within Amazon. Availability varies by country and merchant, and platforms change eligibility frequently, so verify current status with each platform’s merchant documentation.
Do I need to support every protocol?
Not directly. Most major commerce platforms expose agent checkout as a native capability and handle protocol differences for you. If you are on a custom stack, prioritize by where your customers already are: ChatGPT and Google surfaces currently reach the largest audiences, and the payment token layer from Visa and Mastercard is shared across them.
Should I block AI crawlers to protect my content?
Separate the decision into training crawlers and retrieval crawlers. Blocking training crawlers like GPTBot or Google-Extended is a content and commercial decision with no direct effect on agent shopping. Blocking retrieval agents like OAI-SearchBot or ChatGPT-User removes your store from the candidate pool for shopping queries. Many retailers blocked everything in 2023 and 2024 and should revisit that configuration.
How do agents decide which product to recommend?
They match the shopper’s stated constraints, then compare candidates on total delivered cost, delivery window, return terms and rating signals, all read as structured fields where available. Products with missing or unverifiable fields are usually ranked below products with explicit ones, so completeness of data often matters more than the values themselves.
How do I see agent traffic in Google Analytics 4?
Create a custom channel group with an “AI assistants” channel that matches source or referrer against domains such as chatgpt.com, perplexity.ai, gemini.google.com and copilot.microsoft.com. Expect undercounting, since many assistant sessions land as direct traffic, and complement GA4 with order-level agent identifiers from protocol checkouts and server-log counts of agent fetches.
Who is liable if a customer disputes an order their agent placed?
Rules are still developing. Signed mandates in the Agent Payments Protocol and scoped tokens in Visa Intelligent Commerce and Mastercard Agent Pay are designed to provide evidence that the customer authorized the purchase, but network dispute rules for agent-initiated transactions have lagged the technology. Retain mandate and token evidence for each agent order and track dispute rates on the channel separately. This is general information, not legal or financial advice; consult your acquirer and counsel for your specific exposure.
Does agentic commerce only matter for large retailers?
No. The data work that determines inclusion (feeds, markup, crawler access, structured policies) is within reach of small and mid-size stores, and platform-native checkout support means a Shopify or BigCommerce merchant can often enable agent checkout with configuration rather than engineering. Third-party readiness rankings have found that data quality, not company size, predicts whether an agent can shop a store.
What is the single highest-leverage fix for most stores?
Stating return and shipping policies as structured data in both the feed and page markup. It is inexpensive, it moves a store from “not stated” to “verified” on the two trust fields agents compare most often, and it frequently changes shortlist rank without any change to price.