A2A Protocols in Agentic Commerce: How AI Agents Communicate and Transact

Q1: What Are A2A Protocols in Agentic Commerce, and Why Do They Matter Now?

A distinguished engineer told a room of founders about a small failure that should scare every merchant. He asked an agent to call an API, the call broke, and the model quietly decided to "stub it." No error. No alert. It just faked the result and moved on. When agents shop for your buyers, that silent failure is a lost sale you never see.

🛒 The short answer

A2A (Agent2Agent) is an open protocol Google launched in April 2025 that lets AI agents from different frameworks discover each other, exchange capabilities, and delegate tasks over JSON-RPC and HTTP. It is now stewarded by the Linux Foundation. In agentic commerce, A2A handles agent-to-agent orchestration, the "communicate" layer, while transactions run on companion protocols like Google's AP2 and the OpenAI-and-Stripe Agentic Commerce Protocol.

The confusion between those two layers is the whole problem. A2A is how agents talk. It is not how they pay. This is precisely the shift our agentic commerce service is built to solve.

🧩 What A2A actually is

Google introduced A2A in April 2025 with more than 50 launch partners. It runs on plain web foundations: JSON-RPC 2.0, HTTP, and server-sent events. Because it is open and framework-neutral, an agent built by one vendor can call an agent built by another.

The design goal is interoperability, not lock-in. That is why stewardship moved to the Linux Foundation, a neutral home for the standard. If you are new to this space, our what is agentic commerce primer covers the basics.

🏗️ Why the "communicate vs transact" split matters

Think of agentic commerce as a three-layer stack. Each layer has one job.

• MCP (Anthropic): connects agents to your data and tools.
• A2A (Google): orchestrates communication between agents.
• ACP + AP2 (OpenAI/Stripe and Google): handle the actual transaction and payment.

Mix these up and you build the wrong thing first. The category itself is messy right now. As one practitioner put it, there is "still quite a mess when it comes to all of the vocabulary." Our agentic web stack report maps how these pieces fit together.

📱 The stakes: an app-store moment

Around 800 million people now use ChatGPT. That scale rivals the 2008 iPhone App Store moment, except the "apps" are agents that can buy on a user's behalf. "Intent is the interface" now, and every merchant will likely need one canonical intent endpoint that accepts structured requests instead of the click-around web we built for human eyes.

At MaximusLabs, we treat A2A readiness as a data-science problem, not an SEO checklist. Whether an agent can even find and transact with your brand is now binary. This is what "become the answer" turns into for commerce: you have to become the shelf the agent picks from, or you are invisible at checkout. Traditional Google-only SEO was never built for that question, which is why our GEO service exists.

Q2: How Do AI Agents Communicate Using the A2A Protocol?

Picture two agents meeting for the first time. One needs a task done. The other can do it. Neither shares its private code or logic. They just exchange a card, agree on terms, and get to work. That handshake is A2A, and it either fires cleanly or it fails in ways you cannot see.

🤝 The short answer

AI agents communicate through A2A by exposing an Agent Card, a JSON profile of their capabilities. Then they follow a three-step lifecycle: Discovery, Authentication, and Communication. A client agent finds a remote agent's card, authenticates using OAuth or OpenID Connect, then delegates a Task carrying Messages and returning Artifacts, all over JSON-RPC 2.0 and HTTP with server-sent events. Agents stay "opaque," collaborating without exposing internal logic.

📇 The core building blocks

A2A uses a small set of named parts. Each one has a clear role.

• Agent Card: a public JSON file listing what an agent can do and how to reach it.
• Task: the unit of work one agent hands to another.
• Message and Part: the content exchanged during a task.
• Artifact: the finished output the remote agent returns.

The Agent Card is the discovery primitive. It works much like an OpenAPI spec: it tells other agents your capabilities before any work begins. Getting this layer right is a core part of our technical SEO and website audit work.

🔌 The transport layer and why opacity matters

A2A rides on JSON-RPC 2.0, HTTP, and server-sent events for streaming updates. These are boring, proven web standards, which is the point. Agents keep their internal reasoning private and only expose the interface, so companies can collaborate without leaking IP.

Meanwhile, MCP is becoming the default way any single service, whether Stripe, GitHub, or Notion, talks to an LLM. A2A sits one level up, connecting agents to each other. For the deeper standard, see our WebMCP agent-ready web standard report.

⚠️ Where the handshake breaks

Here is the risk most guides skip. When a handshake misaligns, an agent may not stop. It may "stub" the call and fabricate a result, the silent failure that engineer described. Cluttered requests make it worse. A model like GPT-4o has a focus window of roughly 200,000 tokens, and if your endpoint is full of boilerplate noise, intent fidelity drops and the transaction can fail.

So machine-legible communication is not optional plumbing. Agents do not browse, they call structured endpoints. A site that only speaks "click" becomes a high-latency failure point, and the agent quietly routes your buyer to a competitor it can actually parse. You can test this yourself with our AI crawlability checker.

Q3: How Do AI Agents Actually Transact? From Cart to Checkout with AP2 and ACP

A practitioner shared a moment that captures the gap perfectly. "I was in Gemini and I was like, hey, I want to buy snowboard pants and I'd like you to do the checkout for me end to end. And it didn't work. Just in a couple different loops." The agent found the product. It just could not pay. That wall is the transaction layer, and most A2A explainers wave right past it.

💳 The short answer

AI agents transact through a worked flow: discover the product, compare options, then pay using signed mandates and scoped tokens, not typed card numbers. Google's AP2 records a cryptographically-signed Intent Mandate and Cart Mandate as auditable proof of what the user authorized. ChatGPT's Instant Checkout, built with Stripe's Agentic Commerce Protocol, uses a Shared Payment Token, for example "$10 that expires end of day for one Stripe seller," to complete the purchase safely.

🔎 The worked flow: discover, compare, checkout

The buying journey has three moves, and each one leans on machine-readable data.

1. Discover: the agent reads Agent Cards and product feeds to find candidates.
2. Compare: it weighs attributes, price, and stock across options.
3. Checkout: it triggers payment through a transaction protocol, not a web form.

If any step lacks clean data, the agent stalls, exactly like the snowboard-pants loop. Our ChatGPT instant checkout guide breaks down each step in detail.

📝 How AP2 authorizes a payment

Google announced the Agent Payments Protocol (AP2) in September 2025, and it extends A2A while relying on MCP. It works through signed mandates that create a non-repudiable trail.

• Intent Mandate: cryptographic proof of what the user asked for.
• Cart Mandate: signed confirmation of the exact cart before payment.

Google later donated AP2 to the FIDO Alliance, a sign the standard is built to last.

🔐 How ACP completes the purchase

Stripe and OpenAI released the Agentic Commerce Protocol in September 2025, powering Instant Checkout inside ChatGPT for Etsy and Shopify merchants. The key primitive is the Shared Payment Token: a one-time token scoped to a single session, amount, and merchant. That scoping shrinks the "blast radius" if an agent is ever compromised.

The scale behind this is real. Stripe's network handles roughly 50,000 new transactions every minute, about 1.3% of global GDP, which is why Stripe built a BERT-based financial foundation model for the "differentiated payment sequences" general LLMs never see.

💡 Why this is the new trust currency

Cryptographic certainty of stock and payment is the point. An agent wants to know an item is in stock and buyable before it commits. When an agent transacts with you, it stakes its own credibility on the outcome, which makes verifiable data the machine-readable analog of E-E-A-T.

We implemented WebMCP and A2A-style protocols for a California nutrition brand so an agent could search, find, and buy end-to-end. In the six months after, the brand's e-commerce sales roughly doubled, as detailed in our nutrition SEO agentic commerce case study. That is the difference between being findable and being buyable.

On the evidence side, I want to be straight with you. The strongest public data point I can attribute cleanly here is Webflow's reported 6x higher conversion rate from LLM traffic versus Google search, shared by Ethan Smith, CEO of Graphite.

"Webflow saw a 6x higher conversion rate from LLM traffic compared to Google search traffic."
Ethan Smith, CEO, Graphite, Graphite AEO Interview

Q4: What Is the Agentic Commerce Protocol Stack: A2A vs MCP vs ACP vs AP2?

Most agencies conflate these four protocols because they have not sat inside the actual builds. The standard read treats them as competitors fighting for one slot. That gets it backwards. They are layers in one stack, and knowing which layer you are building for is the fastest way to stop wasting engineering hours.

🗺️ The short answer

In the agentic commerce stack, each protocol owns a layer: MCP (Anthropic) connects agents to data and tools; A2A (Google) orchestrates agent-to-agent communication; and ACP (OpenAI and Stripe) plus AP2 (Google) handle transactions and payments, with UCP (Shopify and Google) emerging for universal carts. They are complementary, not competing. But brands must choose which on-ramp to build first, because the vocabulary is "still quite a mess."

🔗 Why they interoperate

These layers stack rather than clash. AP2 extends A2A and relies on MCP underneath, so a single purchase can touch three protocols at once. Think of the LLM as a "Universal Intent Decoder": it turns a messy human prompt into a structured JSON request, then the stack routes that request through data, orchestration, and payment. For the full picture, read our state of agentic commerce 2026 report.

🧭 Which on-ramp to build first

Your first on-ramp depends on where your buyers already are.

• Consumer / DTC merchants: start with ACP, since Instant Checkout is live in ChatGPT today.
• B2B and multi-agent workflows: start with A2A plus MCP to expose your backend safely.
• Payment-heavy or regulated flows: prioritize AP2 for its signed, auditable mandates.

When we advise clients on on-ramp sequencing, we start with the transaction layer their buyers actually use, usually ACP for ChatGPT-native audiences. Traditional SEO agencies rarely reach this conversation at all, because it lives in the algorithms and specs, not in a keyword tool. Owning the correct stack diagram, and building to it, is itself a trust signal that AI engines and buyers both reward, and it is the heart of how we approach generative engine optimization.

Q5: Why Is Machine-Legible Product Data the New Battleground for Visibility?

A founder once showed me a Shopify dashboard with healthy ad spend and flat agent-driven sales. The pants were beautiful. The photos were perfect. But an agent asked for "waterproof black snowboard pants, size 32" and got nothing back, because those attributes lived inside JavaScript filters no machine could read.

💸 The situation: budget still flows to ads

Most brands still pour money into PPC, meaning pay-per-click ads on Google. That habit made sense when humans scanned a results page. The spend feels safe because you can watch the impressions climb.

The trouble is that agents do not scan results pages. They parse data, which is exactly why our GEO vs traditional SEO approach starts with the machine reader first.

❌ The complication: unreadable data means invisible

In agentic commerce, visibility is earned through the data, not through the ads. If your product data is not machine-readable, you are pretty much invisible to the AI, whatever your ad budget. An agent needs a clean product feed and real-time APIs to know, with near-cryptographic certainty, that an item is in stock, priced right, and buyable.

Here is the part that surprises teams. Ad dollars cannot buy a spot the agent literally cannot see. Our e-commerce product AEO work exists to close that exact gap.

🔎 The proof: expose your facet data

The fix starts with facet data, meaning the specific attributes buyers filter on. One practitioner put it plainly: expose "the closure and the fabric and the material and the neck style," because most follow-up questions are "best product with these attributes." Pull that metadata out of JavaScript filters and into structured schemas an agent can read.

There is a nuance worth respecting. As one contrarian take goes, "tokenization sort of destroys the schema," like repeating a foreign radio phrase without understanding it. So agents often prioritize clean, raw HTML readability over ornate code, which means both matter: readable HTML and structured data. Our schema markup basics guide walks through the setup.

✅ The resolution: the clean-feed playbook

Treat the transaction layer like a "Ghost Kitchen." The pretty website is the dining room. The agent is the delivery driver, and it only needs the data feed to fulfill the order. So build for the kitchen.

• Publish a clean, current product feed with SKU, price, and stock.
• Expose facet attributes as machine-readable schema, not JavaScript-only filters.
• Wire real-time inventory APIs so stock status is never stale.

⏰ Monday-morning check

Pick one bestselling product. Ask an agent to find it by attribute, not by name. If it stalls, your data, not your ad budget, is the problem to fix first. You can start with our AI crawlability checker.

Our trust-first methodology engineers product data and content for agent parsing first and human polish second, because the agent is now the first reader. This is where MaximusLabs breaks from Google-only PPC thinking. Ads chase clicks a human might make. We build the machine-legible shelf an agent selects from, which is Krishna's binary logic applied to commerce: if you are not in the agent's selectable set, you do not exist. This is the core of our agentic commerce service.

Q6: How Should You Architect Your Site So Agents Can Navigate and Transact?

The standard read says "just add schema and you're done." From what surfaces when you actually run agent tests, that gets it backwards. Structure and navigation break the retrieval chain long before schema ever gets a chance to help.

🗂️ The short answer

To make a site agent-navigable, keep everything in one filing cabinet. Move help centers and docs to subdirectories, not subdomains, because agents treat subdomains as orphaned entities and will not cross to them. Use point-to-point internal links so deep pages are not stranded, expose facet metadata as machine-readable schema, and build a canonical intent endpoint that accepts structured requests. The goal is zero dead-ends between an agent's intent and your transaction layer.

📁 Subdirectories, not subdomains

Think of subdomains as separate filing cabinets in one big room. If an agent is told to look in one cabinet, it will not automatically check the others. So a help center on help.yoursite.com can sit invisible to an agent working inside yoursite.com.

The fix is simple and cheap. Move that content to yoursite.com/help so it lives in the same cabinet the agent already opened. This is standard practice in our technical SEO and website audit process.

✈️ Link point-to-point, not hub-and-spoke

Internal linking follows an airline logic. A "point-to-point" model, like Southwest, connects pages directly so agents can reach deep ones. A "hub-and-spoke" model, like Singapore Airlines routing everything through one hub, leaves deep pages orphaned when the agent cannot find the connecting flight.

Link your important product and answer pages to each other directly. Do not force every path through the homepage. Our technical GEO implementation guide covers the linking patterns in depth.

🔌 Intent endpoints and MCP servers

Agents want a canonical intent endpoint, meaning one structured door that accepts a request instead of a click sequence. Underneath it, MCP (Model Context Protocol) is becoming the default way any single service talks to an LLM. A remote MCP server is the current prerequisite for letting an agent tap your backend safely.

Build the door, then wire it to your data. For the underlying standard, see our WebMCP agent-ready web standard report.

⭐ Monday-morning check

Roughly 5% of the work produces almost all of the impact here. Start there.

1. Migrate one orphaned subdomain to a subdirectory.
2. Add direct internal links to your top ten revenue pages.
3. Stand up a remote MCP server for your core catalog.

Across the GEO programs we have run, this retrieval-chain audit is where most brands find their fastest agent-visibility wins. Search Everywhere Optimization, as we practice it at MaximusLabs, means checking the whole chain: feeds, subdirectories, internal links, and MCP endpoints, so no agent hits a dead end. Traditional agencies optimize the website for Google crawlers and stop there, which is exactly the gap that leaves brands unbuyable by agents, and the reason our GEO service takes the full-chain view.

Q7: Is Agentic Commerce Secure? Trust, Tokens, and Threat Models

Every founder asks the same question before they let an agent touch checkout. What happens if the agent gets hijacked? It is the right fear, and the honest answer is that the safety model is built on scoping, not blind trust.

🔐 The short answer

Agentic commerce is secured by scoping and cryptographic proof. One-time Shared Payment Tokens are limited to a single checkout session and merchant, which shrinks the "blast radius" if an agent is compromised. AP2's signed Intent and Cart Mandates create an auditable, non-repudiable trail of exactly what the user authorized. Academic threat modeling with the MAESTRO framework stress-tests Agent Card management, task integrity, and authentication before deployment.

⚠️ Scoping shrinks the blast radius

The core trick is limiting what a token can do. A Shared Payment Token might be "$10 that expires at the end of the day for the Stripe seller with this identifier." If that token leaks, the damage is capped at $10, one merchant, one day.

Compare that to a stored card, where a breach exposes everything. Scoping turns a catastrophe into a rounding error.

🧪 Threat modeling with MAESTRO

Security researchers do not just hope A2A is safe. A 2025 arXiv paper applies the MAESTRO framework, a structured threat model for AI risks, to A2A deployments. It probes three weak points: Agent Card management, task-execution integrity, and authentication.

There are real open risks worth naming. Agents can fail silently, "stubbing" a broken call instead of erroring out. And payment authorization is hard enough that Stripe built a BERT-based financial foundation model, because general LLMs lack the "differentiated payment sequences" needed to move money safely.

✅ What to verify first

Before you let agents transact on your behalf, confirm a few basics.

• Payment tokens are scoped to amount, merchant, and time.
• Every agent action leaves a signed, auditable mandate trail.
• Agent authentication uses OAuth or OpenID Connect, not shared secrets.

The reason I keep this section free of any sales pitch is deliberate. Trust is the currency here, and MaximusLabs treats honesty about open risks as part of the trust-first standard, not a marketing afterthought. Our E-E-A-T for AEO framework carries that same principle into content.

Q8: What Does Agentic Commerce Mean for Your Pipeline and GTM Budget?

A VP of Marketing told me her board wanted "the AI number" for next quarter. She had impressions. She had pageviews. She had nothing that tied agent-driven discovery to pipeline, and that gap is exactly where budgets get misallocated.

💰 The situation: the shift is already priced in

The macro move is large and fast. Gartner projects roughly $15 trillion in B2B purchases flowing through AI agents by 2028. With around 800 million people on ChatGPT, the agent layer is where discovery now starts.

Around 1.3% of global GDP already flows through the financial APIs being wired for agent payments. This is not a someday market, as our state of agentic commerce 2026 report details.

❌ The complication: vanity metrics miss it

Here is the trap. PPC clicks and impression counts do not move agentic revenue. An agent does not click your ad, and it does not pad your pageview report.

So a dashboard full of TOFU metrics, meaning top-of-funnel awareness stats, can look healthy while agent-driven pipeline stays flat. The penalty for being average has never been so severe. Our GEO ROI and revenue attribution guide shows how to measure what actually moves pipeline.

📈 The proof: pre-sold buyers convert higher

When a buyer arrives through an AI recommendation, they arrive pre-sold. The agent already did the research and named you as the answer. Practitioners report the gap is real.

"Webflow saw a 6x higher conversion rate from LLM traffic compared to Google search traffic."
Ethan Smith, CEO, Graphite, Graphite AEO Interview

✅ The resolution: reallocate toward being the answer

Move budget from clicks toward the things that get you selected by agents.

• Fund machine-legible product data and clean feeds first.
• Build one protocol on-ramp your buyers actually use.
• Invest in trust signals and citations, not raw impressions.

⏰ Monday-morning check

Pull one report. Can you tie any agent or LLM referral to closed revenue? If not, that measurement gap is your first fix, before you spend another dollar on ads.

This is exactly why we pioneered RAEO and R-GEO, meaning revenue-focused answer and generative engine optimization. At MaximusLabs, every article and integration we ship is tied to pipeline, not pageviews, because clicks that do not convert are just expensive noise. Traditional Google-only SEO was built to chase impressions, and over 50% of search traffic is projected to move to AI-native platforms by 2028, per Gartner, so chasing the old number is chasing a shrinking slice. Our R-GEO revenue-focused framework lays out the full model.

Q9: How Do You Get A2A-Ready Before Competitors Lock In the Advantage?

An OpenAI engineer named Christina built a complete working agent live on stage. Total time: about eight minutes. That is the moment to sit with, because if a working agent takes eight minutes, the reason your brand is not yet buyable is not difficulty. It is priority.

⏰ The situation: the window is open, but closing

The tooling is ready today. Agent Kit demos show end-to-end builds in minutes, and Instant Checkout is already live inside ChatGPT for real merchants. A2A launched with more than 50 partners, and that number keeps climbing.

So the barrier is no longer technical. It is whether you move before the consideration set hardens, which is exactly where our agentic commerce service focuses.

❌ The complication: is first-mover advantage even real?

Here the experts genuinely disagree, and I want to be honest about that. Ethan Smith calls first-mover advantage "a false concept," because content can rank instantly later once you publish it. His point is fair for pure content plays.

But integration is different from content. As Jakob Wolitzki argues, "there's always first mover advantage" for brands that wire into commerce protocols early and earn entrenched data patterns agents keep reusing. Our GEO competitive positioning work is built around that entrenchment.

✅ The proof: integration is what entrenches

The resolution sits on the integration side, not the content side. When an agent is asked to buy and can navigate your site but not a competitor's, you win that purchase by default. That advantage compounds every time the agent reuses your clean data.

• Content can be added later, so blog timing is forgiving.
• Protocol integration builds durable, reused data patterns.
• The brand that is buyable today gets picked today.

That is why "become the answer" now extends into "become the shelf." Being cited is nice. Being transactable is revenue, and our GEO service is built to deliver both.

🛠️ The resolution: a phased A2A-readiness roadmap

You do not need a moonshot. You need three sequenced moves.

1. Clean the feed. Turn product data into machine-readable schema with SKU, price, stock, and facet attributes.
2. Build one on-ramp. Pick the transaction protocol your buyers use, usually ACP for ChatGPT-native audiences.
3. Remove dead-ends. Migrate orphaned subdomains to subdirectories and add direct internal links.

The structured-data step is covered in our schema markup basics guide, and the architecture fixes sit inside our technical SEO and website audit process. On the evidence, I will stay straight with you again. The strongest attributable public data point is Webflow's reported conversion gap from LLM traffic, shared by Ethan Smith, CEO of Graphite.

"Webflow saw a 6x higher conversion rate from LLM traffic compared to Google search traffic."
Ethan Smith, CEO, Graphite, Graphite AEO Interview

At MaximusLabs, we make brands the answer agents cite and the shelf agents buy from. We combine trust-first, revenue-focused GEO with A2A and WebMCP integration, at a fraction of traditional agency cost. Google-only agencies optimize a website for crawlers and stop, which leaves brands findable but not buyable, exactly the gap that matters as over 50% of search traffic is projected to move to AI-native platforms by 2028, per Gartner. Our WebMCP agent-ready web standard report shows how we wire that integration.

💭 The question I'm sitting with

Here is my open hypothesis, and I could be early on this. I think "becoming the shelf" stops being an edge within two years and becomes table stakes, which means the brands wiring in protocols now will quietly own the default purchases later. If you are weighing whether to integrate this quarter or next year, that is the conversation I would want to have with you, and it is where our contact us page comes in.