Conversational AI currently stops at "here are some recommendations." The next layer — now shipping in pilot at every major vendor — stops at "I bought it for you." That is the entire difference between AI search and agentic commerce, and it is not a small difference. One informs a purchase decision. The other makes it.
Agentic commerce: AI agents that don't just recommend products, they actually transact on the user's behalf — discovering, comparing, configuring, adding to cart, and (in some flows) completing checkout without the human touching a keyboard.
The standards stack underneath is still settling. OpenAI's Operator runs the agent layer at OpenAI. Anthropic's Model Context Protocol (MCP) is the open standard for agent-to-system communication. Google's Agent Payments Protocol (AP2) is the payments layer. The broader Agent Commerce Protocol (ACP) is an industry effort to standardize the orchestration on top. Most merchants will not need to integrate against all of these in 2026 — but most merchants do need to start thinking about what their catalog looks like to an agent.
This post is the merchant-side primer: what agentic commerce actually is, the standards stack, what to prepare for now, and where the prudent investment lies for the next 12–24 months.
What agentic commerce actually is
Agentic commerce is the discipline of designing your product catalog, your data layer, and your checkout flow such that AI agents (acting on behalf of human users) can complete shopping tasks against your site programmatically.
The canonical user flow:
- The user asks an agent a shopping-shaped question with constraints. ("Find me winter boots, women's, waterproof, under $200, fit a wide foot, ship to my address.")
- The agent searches a product candidate set across multiple merchants. This is partly retrieval (the engine's existing knowledge of products) and partly direct query (calling merchant catalog endpoints where available).
- The agent narrows to a shortlist based on the constraints and the user's stated preferences.
- The agent presents the shortlist to the user and asks for confirmation. (Some pilots skip this step for low-stakes purchases under explicit pre-authorization.)
- The agent initiates checkout. Where the merchant supports it, this happens via a programmatic endpoint; where the merchant doesn't, the agent navigates the live checkout flow using DOM automation.
- Payment, fulfillment confirmation, and order tracking flow back to the agent and surface to the user.
Each of those six steps is a place a merchant can be ready or unready. The good news: the readiness work is mostly familiar — clean schema, clean product data, accessible checkout, fast pages. The new work is the programmatic-endpoint and payment-authorization layer, which is what the standards stack is now defining.
The standards stack
Three protocols are doing the bulk of the work in 2026:
MCP (Model Context Protocol) — the tool layer
MCP is Anthropic's open standard for letting AI agents discover and call tools exposed by external systems. For a merchant, this means exposing an MCP server with tools like searchProducts, getProduct, getInventory, createCart, and getShippingOptions. Any compliant agent — Claude, Operator, agent frameworks like LangChain — can call those tools without per-merchant bespoke integration.
MCP is the most settled of the three protocols. Anthropic released it in late 2024; OpenAI and Google have shipped MCP support; the agent-framework ecosystem has standardized on it. The merchant-side playbook lives on our MCP for eCommerce page.
AP2 (Agent Payments Protocol) — the payments layer
AP2 is Google's emerging open protocol for letting agents initiate payments with merchant-side authorization and consumer-side consent. The protocol addresses two specific problems agentic commerce creates:
- Authorization scoping. How does the merchant ensure the agent is acting with the user's actual authority, not on a hallucinated request? AP2's verifiable-credential pattern is designed to let users pre-authorize an agent for specific scopes (amount, merchant, time window, product class).
- Fraud and reversibility. Agent-initiated transactions need a different fraud model than card-not-present transactions today. AP2 defines the contractual and technical layer for handling disputes and reversibility on agent-driven flows.
AP2 is less mature than MCP. The spec is public, reference implementations exist, but the broader payment ecosystem (issuers, processors, PSPs) is still building support. For merchants, AP2 is a 2026 awareness item and a 2027 build item.
ACP (Agent Commerce Protocol) — the orchestration layer
ACP is the industry-effort layer on top of MCP and AP2 that defines how the full commerce flow works end-to-end — product discovery, cart construction, payment, fulfillment confirmation, returns. ACP is the least mature of the three; the spec is still being drafted by working groups across the major AI vendors, payment networks, and major retailers.
For most merchants, watching ACP closely (and contributing to the working groups if you operate at the scale where your input matters) is more useful than implementing against a moving target. The component protocols — MCP and AP2 — will continue to be the integration surfaces even if ACP shifts.
OpenAI Operator — the most-shipped agent today
OpenAI's Operator is the most-deployed agentic-commerce surface in 2026. Operator is a browser-using agent that can navigate websites the way a human does — clicking, typing, scrolling, completing forms. It does not require merchant-side MCP integration to work; it works against any standard web checkout flow.
That makes Operator both the easiest agent to be discovered by (your site already works for it, mostly) and the agent most sensitive to bad UX. Operators struggle with:
- Aggressive interstitials and popovers that hijack the flow.
- Custom dropdowns and combo-boxes built without standard ARIA roles.
- Checkout flows with multiple unrelated friction steps (account creation walls, mandatory marketing opt-ins, surprise upsells).
- Single-page-app pages that take >3 seconds to render meaningful content.
- Inaccessible payment forms.
The single highest-leverage agentic-commerce investment most merchants can make in 2026 is making their existing site behave well for a browser-using agent. Accessibility audits, checkout flow simplification, dropping non-essential friction, ensuring server-rendered or fast-hydrated PDPs and cart pages — this is well-trodden eCommerce optimization work that pays out in agent compatibility.
What to prepare your catalog for in 2026
Even without building MCP or AP2 endpoints, every merchant should be working through this list:
Schema completeness and validity
Every PDP needs valid Schema.org Product markup with a nested Brand, complete Offer (price, priceCurrency, availability, priceValidUntil, itemCondition, url), AggregateRating where genuine, and a clean canonical URL. Schema is the universal interoperability layer; agents that don't speak your specific platform's API still read schema reliably.
Crawler access for the major AI bots
Robots.txt should allow GPTBot, ClaudeBot, PerplexityBot, Google-Extended, and OAI-SearchBot, with sensible rate limits. Blocking these is the most common mistake we see; it costs you discovery on every agentic-commerce surface that uses one of the underlying foundation models.
Catalog cleanliness
Variant explosions, duplicate PDPs, stale availability flags, inconsistent pricing between feed and page — all of these are problems for traditional SEO and bigger problems for agent-driven flows. An agent comparing five variant URLs of the same product is a confused agent.
Checkout simplification
Run your own checkout as if you were a browser-using agent. Can you complete a purchase in fewer than 60 seconds, without account creation, without surprise interstitials, without scroll-jacking confirmation modals? The slower and more brittle your flow, the lower your conversion rate on agent-driven traffic.
llms.txt
A curated llms.txt at the root of your domain pointing at categories, flagship products, and trust pages. Cheap, broad-cross-engine signal that any compliant agent will read.
What to invest in (and not) in 2026
The honest framework for 2026 agentic-commerce investment:
Yes:
- Schema completeness, technical SEO hygiene, accessibility, checkout simplification. Always-good investments that compound.
- Citation-share monitoring on the five major AI engines. The visibility surface that drives agent product candidacy.
- Internal-team MCP integrations where they reduce friction in your operations (catalog data for content teams, order data for customer service agents, etc.).
Maybe:
- A merchant-facing MCP server, if your category has high-AOV considered purchase, complex B2B SKU logic, or visible agent-driven traffic already.
Not yet, for most merchants:
- AP2 integration. The payment ecosystem is still maturing; merchants who build now will likely refactor.
- ACP-specific tooling. The standard isn't settled.
- Custom Operator integration. Operator works against standard web flows; the optimization is on the web flow, not on Operator-specific code.
For the deep merchant-side strategy on agentic commerce, see our agentic commerce page.
Common questions
How much agent-driven traffic is on my site today?
For most merchants we instrument, the answer in mid-2026 is "small but non-zero, and growing month-over-month." Agent user-agents are identifiable in server logs (Operator, Claude-User, agent-framework strings, plus the AI search crawlers). The volume is meaningfully higher in considered-purchase categories than in mass-market consumer.
Will agents kill conversion rate?
Mixed. Agents that complete the purchase on the merchant's behalf raise the conversion rate dramatically — the friction the human user normally hits (account creation, payment form, address entry) is eliminated. Agents that drop the user back into a clunky checkout flow have worse conversion than human users. The work is making sure your flow is in the first bucket, not the second.
How does this interact with my SEO program?
Agentic commerce is the fulfillment layer downstream of the discovery layer. Discovery still depends on AI citation behavior — being recommended by the agent in the first place. The optimization work for getting cited by ChatGPT, Claude, Perplexity, and Gemini is the same work we've covered across our AI SEO services. Agentic commerce extends that into "what happens after the agent picks you."
What about traditional eCommerce ads?
Traditional Google Shopping, Meta product ads, and so on are not going away. The agent-driven flow is additive: a fraction of high-intent traffic moves to agent-mediated purchase, and you need to be ready for it; the bulk of traffic continues to come through traditional channels for some years yet.
Key takeaways
- Agentic commerce is AI agents that don't just recommend, they transact. The stack is MCP (tools), AP2 (payments), ACP (orchestration). OpenAI Operator is the most-shipped agent today.
- For most merchants in 2026, the highest-leverage investment is making your existing site work well for a browser-using agent: clean schema, accessible UI, simplified checkout, fast pages.
- A merchant MCP server is worth building if you have high-AOV considered purchase, complex B2B SKU logic, or visible agent-driven traffic. Otherwise it can wait.
- AP2 and ACP are 2026 awareness items, 2027 build items. The standards are still settling.
- Discovery (AI citation) drives candidacy; agentic commerce drives fulfillment. The two work together.
If your team is thinking about agentic-commerce readiness — from catalog schema to checkout flow to optional MCP exposure — that's the work we run with clients through our agentic commerce program. Start with an AEO audit to see where you stand on the discovery layer, or reach out directly.