For years, digital commerce optimized for one kind of visitor: a human with a browser. That assumption is breaking down. A new class of buyer is arriving on storefronts and procurement portals, and it doesn’t scroll, hover, or abandon a cart out of frustration. It’s an AI agent acting on someone’s behalf, and increasingly it expects to talk to another agent on the other side.
This is the foundation of agent to agent commerce, where autonomous AI agents discover, negotiate, and transact directly with one another. What was a speculative idea a year ago now has a technical backbone: the Agent2Agent protocol, an open standard introduced by Google in April 2025 and now stewarded by the Linux Foundation. Understanding how A2A works, and how it intersects with commerce, is quickly becoming essential for any business that wants to stay visible and competitive as the buying journey gets automated.
This guide breaks down what the Agent2Agent protocol is, how it functions, where it fits into commerce, and how to make your own platform agent-ready.
What is the Agent2Agent (A2A) protocol?
The Agent2Agent protocol is an open communication standard that lets AI agents from different vendors, frameworks, and platforms discover each other, exchange structured information, and coordinate work securely. Google launched it in April 2025 with support from more than 50 technology partners, including Salesforce, SAP, PayPal, ServiceNow, MongoDB, and Atlassian, and donated it to the Linux Foundation in June 2025 as the open-source Agent2Agent project. IBM’s Agent Communication Protocol later merged into the effort, consolidating the industry around a single approach.
The problem A2A solves is coordination, not capability. Organizations are already deploying plenty of capable agents: one handles pricing, another summarizes support cases, another monitors inventory. Each one tends to speak its own language and live inside its own ecosystem. Getting them to collaborate has traditionally required brittle, custom point-to-point integrations that don’t scale. The agent2agent protocol replaces that glue code with a shared communication layer, so a pricing agent built on one framework can hand off work to a fulfillment agent built on another without bespoke wiring.
A useful way to think about it is that A2A is a common language, a universal translator for agent ecosystems. It breaks down the silos that keep autonomous agents from working together, regardless of who built them or how.
Agent2Agent protocol vs. Model Context Protocol (MCP)
A2A is frequently mentioned alongside Anthropic’s Model Context Protocol (MCP), and the two are complementary rather than competing. MCP standardizes how a single model or agent reaches outward to tools, APIs, and data sources. A2A standardizes how agents work sideways, talking to one another as peers.
A simple commerce example shows how they coexist. A retailer’s inventory agent might use MCP to query the databases that hold product and stock data. When that agent detects a low-stock item, it notifies an internal order agent, which then uses A2A to reach an external supplier’s agent and place a replenishment order. MCP connects an agent to its tools; A2A connects agents to each other. Most real-world systems will use both.
How the Agent2Agent protocol works
A2A follows a client-server model. A client agent formulates and delegates a request, and a remote agent (the A2A server) receives it, does the work, and returns results. Crucially, the remote agent’s internal logic stays opaque. The protocol defines how agents communicate, not how they reason. That opacity is deliberate, because it lets agents collaborate without exposing proprietary models, internal memory, or intellectual property.
The protocol defines a small set of structured building blocks:
- Agent card. A machine-readable JSON file that works like a digital résumé or business card. It advertises an agent’s name, capabilities, endpoint URL, supported data types, and authentication requirements, allowing other agents to discover it and decide whether it’s the right fit for a task.
- Task. The central unit of work. Each task has a unique ID and moves through a defined lifecycle (submitted, working, input-required, completed, failed), which lets agents maintain context across multiple exchanges instead of starting fresh each time.
- Message. A single turn in a conversation between agents, carrying instructions, context, questions, or status updates.
- Artifact. The tangible output of a completed task, such as a document, an order confirmation, a shipment record, or any other deliverable.
- Part. A piece of content inside a message or artifact, whether plain text, a file, or structured JSON data.
These elements support a predictable three-step interaction flow:
- Discovery. The client agent looks up available remote agents and reads their agent cards to find one capable of the task, selecting by advertised skill rather than hard-coded integration.
- Authentication and authorization. Before any sensitive work begins, the remote agent verifies the client using enterprise-grade schemes such as API keys, OAuth 2.0, and OpenID Connect.
- Communication and execution. The agents exchange structured messages within the scope of a task over HTTPS, using JSON-RPC 2.0. Quick tasks return immediately; long-running ones use server-sent events or webhooks to stream updates over hours or days, with humans in the loop where needed.
Because A2A is built on familiar web standards, including HTTP, JSON-RPC, and server-sent events, it slots into existing enterprise infrastructure without a rip-and-replace. And because it’s an open, vendor-neutral standard, businesses can build long-term strategies around it without locking into one provider’s communication model.
From agent-driven commerce to true agent-to-agent commerce
A2A is a general-purpose protocol, but its implications for commerce are profound. To see why, it helps to map the broader landscape of agent-driven buying, which is unfolding across three overlapping models.
Business to Agent (B2A) is about making your digital presence legible to autonomous agents. Just as businesses once optimized for search engine crawlers, they now need to optimize for shopping agents by exposing clean, structured product, pricing, and availability data through well-defined APIs so agents can understand and recommend their products.
Agent to Consumer (A2C) puts an AI agent in the shopper’s corner. Tell your agent you need trail-running shoes for wet conditions under a set budget, and it researches options, compares reviews and prices, and surfaces the best choices, potentially negotiating on your behalf.
Agent to Agent (A2A) is the frontier where the buyer’s agent and the seller’s agent transact directly. A procurement agent needing a specific component contacts a supplier’s agent, negotiates price, quantity, and delivery, and executes the order, with no human placing the purchase order. The Agent2Agent protocol is what makes this model technically real instead of theoretical, by giving both sides a shared, secure way to find each other and do business.
For a deeper look at all three models, see our overview of agentic commerce. The rest of this article focuses on the agent-to-agent layer, because that’s where the protocol changes the mechanics of buying and selling most dramatically.
Agent-to-agent commerce use cases
The clearest near-term value of agent to agent commerce shows up in workflows that are already multi-step, rules-heavy, and slowed down by manual handoffs.
Supply chain and replenishment
This is the canonical example, and it appears in nearly every A2A explainer for good reason. An inventory-monitoring agent detects that stock has dipped below a threshold and opens a task. It coordinates with an internal order agent to generate a replenishment request, which then communicates with an external supplier’s agent to place the order and retrieve shipment details. Tracking information returns as an artifact within the same task, making the entire sequence, from detection to delivery, traceable and auditable. For commerce operations, this is the difference between reacting to stockouts and quietly preventing them. Kibo’s inventory visibility and order promising capabilities supply exactly the real-time, accurate signals these agents need to act on.
B2B procurement and negotiation
B2B buying is full of negotiated pricing, approval chains, and contract terms, the kind of structured complexity agents handle well. A buyer’s procurement agent can request a quote from a supplier’s sales agent, which evaluates dynamic pricing rules. If a discount exceeds preset limits, a compliance agent joins the same task to validate terms before anything is committed. Every step preserves context within one structured workflow even though multiple agents participate. This is a natural fit for Kibo’s B2B commerce solution, where complex catalogs, account-specific pricing, and approval rules already live.
Dynamic pricing and promotions
When a shopping agent arrives ready to compare and buy, the seller’s agent needs to respond with pricing and promotions that reflect real-time rules, eligibility, and inventory. Coordinating quote generation, discount validation, and promotion logic across agents keeps offers accurate and consistent. Kibo’s catalog, pricing, and promotions capabilities give selling agents the structured, rules-based foundation to negotiate confidently rather than improvise.
Checkout and order execution
Once terms are agreed, the transaction has to actually complete. An agent-initiated purchase still needs a reliable cart, payment, and order pathway. Exposing cart and checkout through clean APIs lets agents finalize purchases programmatically, while order management orchestrates fulfillment across locations and channels behind the scenes.
Customer service and post-purchase
After the sale, a triage agent handling an issue can call a knowledge agent to search documentation and a status agent to check for active incidents, consolidating structured results into one clear recommendation. The same coordination that powers buying also powers support, returns, and exchanges, turning fragmented systems into a unified response.
How to make your commerce platform agent-ready
The businesses that benefit from agent to agent commerce won’t be the ones that wait for it to fully arrive. They’ll be the ones whose data and transactions are already legible to agents when those agents show up. A few priorities matter most.
Expose clean, structured data. Agents read APIs and structured formats, not marketing pages. Product details, pricing, availability, and business rules need to be machine-readable and accurate. Kibo’s API-first, headless commerce platform is built around exactly this kind of composable, accessible data layer.
Make discovery and search work for machines. Agents looking for the right product need to find it the way a person searching in natural language would. AI vector search helps surface relevant products based on intent and meaning rather than exact keyword matches, the same semantic understanding agents rely on.
Keep inventory and fulfillment data real-time. An agent that places an order against stale stock data creates a broken promise. Accurate inventory visibility and reliable order promising are what let agents transact with confidence.
Build on open standards. Because A2A and MCP are built on HTTP, JSON-RPC, and other established standards, a composable architecture adapts to them far more easily than a monolith. Kibo’s agentic commerce capabilities, including support for agent-facing interfaces and an MCP server, are designed to plug into this emerging ecosystem rather than fight it.
The bottom line: interoperability is becoming table stakes
The Agent2Agent protocol signals a real shift in how commerce will be conducted. As agents become standard across sales, service, and operations, the ability for them to collaborate across systems and vendors stops being a differentiator and becomes infrastructure, the quiet plumbing that everything else depends on. A2A’s stewardship under the Linux Foundation reinforces that it’s meant to be a foundation, not a feature.
For commerce leaders, the takeaway is practical. You don’t need to build autonomous agents tomorrow, but you do need a platform whose data, search, inventory, and transactions are structured, accurate, and open enough for agents to use. Get that foundation right and you’ll be visible to the buyers’ agents already browsing the web, ready to transact when the seller’s side of the conversation matures, and positioned to automate the multi-step workflows that drain time and margin today.
The agents are arriving, and they’re learning to do business with each other. The question for your business isn’t whether to participate in agent to agent commerce. It’s whether your platform is ready to speak the language when they knock.
Want to see what an agent-ready commerce stack looks like in practice? Talk to a Kibo expert about preparing your business for the agentic era.
