Agent-to-Agent Commerce: When Your Customer’s AI Talks Directly to Your Catalog
The retail transaction has always had a human on both sides of the interaction. A customer browses, selects, and checks out. Your storefront — the product pages, the cart, the checkout flow — exists to facilitate that journey. The entire infrastructure of e-commerce was designed around this assumption.
That assumption has a shelf life.
A growing share of commercial transactions in 2026 are being initiated not by humans browsing your storefront, but by AI agents operating on behalf of humans who never visit your site at all. A user tells their AI assistant “find me the best espresso machine under $400 and buy it.” The agent goes to work. It does not browse your product pages, read your reviews, or respond to your retargeting ads. It queries your catalog data directly, compares structured data across merchants, evaluates against the user’s stated preferences and spending limits, and executes a transaction — often through an API call, not a cart checkout.
This is agent-to-agent (A2A) commerce: the emerging pattern where a customer’s AI agent communicates directly with a merchant’s AI layer, bypassing the conventional web storefront entirely. The merchants who have built the infrastructure to receive these requests are capturing demand that is invisible to everyone else.
What A2A Commerce Actually Looks Like
The term “agent-to-agent” can sound abstract, so it helps to walk through a concrete transaction.
A user’s shopping agent — embedded in a major AI assistant or a dedicated shopping tool — receives a purchase request. The agent queries its tool registry for merchants that expose A2A-compatible interfaces: structured product catalogs, machine-readable pricing APIs, and agent authentication endpoints. It authenticates itself using a signed credential, requests a product manifest, evaluates the options against the user’s criteria and budget, and — if a match is found — calls a purchase endpoint to complete the transaction.
The entire flow may involve zero human-facing page views. No product detail page visit. No add-to-cart event. No checkout funnel. No session in your analytics platform. If your measurement and attribution model are built around those events, the transaction is invisible — or it appears in your backend as an order with no acquisition source attached.
QAIL’s analysis of 30 million website visits found that AI bot and agent traffic now represents 38–52% of all web traffic. A substantial and growing share of that traffic is not passive — it is transactional: agents evaluating commercial intent on behalf of users who are ready to buy. The storefront-bypass pattern is not hypothetical. It is happening at scale, and most merchants are not instrumented to see it.
The Three Infrastructure Layers A2A Commerce Requires
To participate in A2A commerce — rather than being excluded from it — you need three things working together.
1. A Machine-Readable Product Layer
Your website’s product pages are built for humans. A2A commerce requires a parallel layer built for machines: structured, queryable, and maintained in real time.
This starts with proper Schema.org markup — specifically the Product, Offer, and Availability properties — but Schema.org alone is not sufficient for transactional agents. The more capable discovery format is ai-catalog.json: a machine-readable catalog file served at a well-known URL that gives agents direct access to your inventory without requiring them to parse HTML or infer meaning from page structure.
A well-formed ai-catalog.json implementation includes product identifiers (ideally standard codes in addition to your own SKUs), real-time pricing, availability status, shipping estimates, and any agent-specific offers or pricing tiers you choose to expose. Agents that find a structured, current catalog will preferentially source from it over merchants that require HTML scraping — because reliability and parsability are competitive advantages in machine-to-machine commerce.
2. An Agent Authentication Layer
An AI agent claiming to represent a user can claim anything. Without authentication, A2A commerce is wide open to spoofed agents, unauthorized transactions, and fraud at scale.
Visa’s TAP standard, Google’s AP2, and FIDO device-bound credentials provide the authentication framework. In a production A2A flow, a legitimate agent carries verifiable credentials — a signed token that identifies the agent, its provider, the user’s authorization scope, and the spending limits the user has set. Your merchant layer needs to verify that token before processing a transaction, not after.
The failure mode here is concrete. An agent that claims to be a major AI assistant’s shopping agent but isn’t — or that claims to have purchase authorization it does not have — represents exactly the kind of risk that Know Your Agent verification is designed to catch. Treating every inbound agent request as trusted because it arrives via a well-formed API call is the merchant equivalent of trusting every email that arrives in the inbox.
3. An Agent-Compatible Payment Rail
Once a product is selected and a transaction is authorized, A2A commerce requires a payment mechanism that does not depend on a human completing a checkout form. The x402 protocol — which enables AI agents to initiate payment via HTTP headers without a browser-based checkout flow — has become the de facto standard for agent-native payments since the Linux Foundation’s x402 Foundation began operations in mid-2026.
If your payment infrastructure requires a human to be present at checkout, you are structurally excluded from a growing category of A2A transactions. This is not a minor edge case. As agentic purchasing scales, the ability to receive payment from an authorized agent without human intervention is table stakes, not a differentiator.
The Trust Problem at the Center of A2A Commerce
The most underappreciated challenge in A2A commerce is not technical — it is trust.
In a human transaction, trust accumulates through signals built up over decades: SSL certificates, payment processor reputation, return policy clarity, review volume. In an A2A transaction, the merchant’s trust problem is inverted: you need to decide, in milliseconds, whether the agent requesting a transaction is what it claims to be, has the authorization it claims to have, and is operating within the scope the user actually intended.
A customer’s AI assistant that has been compromised by a prompt injection attack can make purchases the user did not authorize. Prompt injection and agent impersonation are the active threat vectors that bad actors are already deploying against merchant API layers. The move from browser-based checkout to API-based A2A commerce removes the friction that catches some of this — and removes the human review that catches the rest.
Three principles should govern your A2A trust architecture:
Verify credentials at every transaction, not just session initiation. Token replay attacks and stolen credentials mean that a valid credential at the start of an interaction does not guarantee legitimacy when the charge request arrives. Build per-transaction signature verification into your flow.
Honor spending limits and authorization scopes as hard constraints. If a user has authorized an agent to spend up to $150, a request to charge $280 should fail regardless of whether the agent credentials are technically valid. Your merchant layer needs to understand and enforce user-set constraints, not just authenticate the agent identity.
Maintain a complete audit trail. Every A2A transaction should be logged with the agent identifier, credential hash, user authorization scope, transaction amount, and product identifiers. When disputes arise — and they will — this log is the only authoritative record of what actually authorized the purchase. Disputes in A2A commerce move faster than in human commerce, and merchants without logs lose them by default.
What A2A Commerce Does to Your Analytics and Attribution
The analytics model built around page views, sessions, and conversion events is not equipped to measure A2A transactions. An agent that hits your catalog API, evaluates three products, and completes a purchase through x402 generates no pageview events, no add-to-cart events, and no checkout events in your analytics platform. The order appears in your backend with no acquisition source attached — or it gets misattributed to direct traffic.
This is not a minor measurement nuance. It means that your ROAS calculations, channel attribution, and CRO hypotheses are all being computed on an increasingly incomplete dataset. If 20% of your transactions are now agent-originated and invisible to your analytics stack, every optimization decision you make on that data is systematically wrong in the same direction. You are undervaluing whatever drove the agentic traffic and overvaluing whatever appears correlated with the human traffic you can see.
The fix requires tagging A2A transactions at the API layer — capturing the agent provider, the credential identifier, the authorization source, and any referral attribution the agent carries — and feeding that into your attribution model alongside session-based data. Several A2A standards already include referral metadata in request headers. Your catalog and payment endpoints should be logging it from day one.
Getting Started: Practical Steps in Order
If you are early in building for A2A commerce, prioritize in this order:
Audit what agents are already doing with your site. Before you build new infrastructure, understand what AI agents are already hitting your pages, your catalog, and your API endpoints. An agent readiness assessment surfaces this baseline. You may find that agents are already attempting catalog queries and failing — or that they are scraping page HTML because no structured alternative exists.
Publish a machine-readable catalog. An ai-catalog.json file served at /.well-known/ai-catalog.json is the highest-leverage single action you can take. It does not require changing your storefront. It makes your inventory discoverable to the agents that are already routing commercial intent to merchants who are ready to receive it.
Implement agent authentication before you accept transactions. Build credential verification before you build the transaction endpoint. An unauthenticated A2A API is a fraud surface — and unlike a misconfigured cart, it is one that automated systems can probe and exploit at scale before you notice.
Add x402 payment support. This is the infrastructure work that converts agent interest into agent revenue. Your payment processor’s A2A support will determine how straightforward this is; as of mid-2026, Stripe, Adyen, and Braintree all have x402 SDKs in production.
Instrument your API endpoints for attribution. Whatever agents are already doing with your catalog, you need it in your data. Add agent provider, credential type, and any referral metadata to your order logging from the start — retrofitting attribution to a mature A2A flow is significantly harder than building it in from the beginning.
A2A commerce is not a future scenario to prepare for. The agents are already querying catalogs, evaluating products, and routing transactions. The merchants who have built the infrastructure to receive these requests are capturing demand that is invisible to competitors operating on storefront assumptions alone.
The question is not whether your customers’ AI agents will try to transact with your catalog. It is whether they will find your catalog ready when they do.
→ Get your Agent Readiness Score and see exactly where your site stands for A2A commerce.