A2A Protocol (Agent2Agent) is Google’s open standard for AI agents to discover, authenticate, and communicate with each other across organizational boundaries. Google announced A2A at Google Cloud Next in April 2025 with a launch coalition of more than fifty enterprise software companies. Then in 2025, Google donated A2A to the Linux Foundation, where it now sits alongside CNCF projects with broader vendor-neutral governance. By 2026, A2A counts 150+ contributing organizations. Importantly, A2A solves a different problem than Anthropic‘s Model Context Protocol — MCP connects an agent to tools and data; A2A connects one agent to another. In short, the two protocols are complementary, not competing.
What is the A2A Protocol?
A2A Protocol — short for Agent2Agent Protocol — is an open standard for AI agents to communicate, discover capabilities, and coordinate work across organizational boundaries. Specifically, A2A defines how an agent at company X can call an agent at company Y, authenticate the request, exchange structured task descriptions, and stream results back. By contrast, traditional API integrations require pre-negotiated contracts between specific systems. A2A’s promise is that any A2A-compatible agent can talk to any other.
Google announced A2A at Google Cloud Next in April 2025 with a launch coalition of more than fifty enterprise software companies. The launch coalition spanned SAP, ServiceNow, Salesforce, Workday, Atlassian, Box, Cohere, and dozens more — exactly the segments most likely to want their internal agents to interoperate. Then in 2025, Google donated A2A to the Linux Foundation under their AI Foundation, giving the protocol vendor-neutral governance similar to how Kubernetes and Prometheus operate.
📌 Quick definition. A2A Protocol is an open standard for agent-to-agent communication across organizational boundaries. It uses HTTP + JSON-RPC, supports streaming responses, and is governed by the Linux Foundation. The specification and reference implementations live at a2a-protocol.org. By 2026, A2A has 150+ contributing organizations.
How A2A Protocol works
The A2A Protocol’s core abstraction is the Agent Card — a JSON document at a well-known URL that describes what an agent can do. Specifically, an agent publishes an Agent Card at /.well-known/agent.json. Other agents fetch the card to discover the agent’s name, capabilities, supported authentication schemes, and endpoints. As a result, agent discovery works similarly to how OAuth’s well-known endpoints work for human authentication.
Tasks: the core unit of A2A work
When agent A wants agent B to do something, agent A POSTs a Task to agent B’s tasks endpoint. Specifically, a Task includes a description of what to do, optional inputs, and metadata about how to return results. Importantly, Tasks are stateful — agent B can update the Task’s status (working, completed, failed) and stream incremental results back. As a result, A2A naturally supports long-running operations that traditional REST APIs handle awkwardly.
Authentication and trust
A2A delegates authentication to existing standards. By default, agents authenticate to each other via OAuth 2.0 or HTTP Message Signatures (RFC 9421 — the same primitive the IETF Web Bot Auth working group uses). Importantly, each Agent Card declares which authentication schemes its endpoints accept. As a result, A2A doesn’t reinvent agent identity — it composes with the existing identity layer.
“Today’s enterprise software lives in silos. A2A lets the agents inside each silo talk to each other directly — without per-pair integration work.”
Industry framing, 2026
The A2A Protocol ecosystem in 2026
Adoption of the A2A Protocol grew rapidly through 2025 and 2026. Specifically, the original launch coalition of fifty became a Linux Foundation working group with over 150 contributing organizations by 2026. Notable participants include enterprise software vendors (SAP, ServiceNow, Salesforce, Workday, Atlassian, Box), cloud providers (Google Cloud, Microsoft Azure agent services, Amazon Bedrock), specialized agent companies (Cohere, MongoDB, Elastic), and dozens of integrators.
Notable absences as of 2026: Anthropic and OpenAI are not founding contributors. By contrast, both companies focus on the agent-to-tool layer (MCP and OpenAI’s own function-calling standards) rather than agent-to-agent coordination. Importantly, this is a positioning choice — neither lab has signaled hostility to A2A; both have remained focused on their own integration layers. As A2A matures, the question is whether the model labs join or stay adjacent.
A2A Protocol vs MCP vs other agent standards
A2A isn’t the only agent-related protocol in the field. By contrast, three other efforts operate at different layers of the stack. Specifically, Anthropic’s Model Context Protocol (MCP) connects an agent to its tools. Google’s AP2 handles payment authorization. IETF Web Bot Auth sits at the HTTP transport layer. In short, the four protocols are complementary, not competing.
⚠️ What is still missing. Three open questions remain in A2A v1. First, observability — when one agent dispatches to another, how does a tracing system follow the request? The spec doesn’t yet define a tracing context. Next, cost accounting — when agent A’s task runs on agent B’s infrastructure, who pays for it? Finally, multi-agent transaction semantics — what happens when a chain of agent calls partially fails? Expect Linux Foundation drafts on all three in late 2026.
| Standard | Layer | Question answered | Governance |
|---|---|---|---|
| A2A Protocol | Agent ↔ Agent | How do agents at different orgs talk? | Linux Foundation (donated 2025) |
| MCP | Agent ↔ Tool | How does an agent access data/tools? | Anthropic / open source |
| AP2 | Agent → Payment Rail | How does an agent pay? | FIDO Alliance (April 2026) |
| Web Bot Auth | HTTP transport | Who is this HTTP client? | IETF (chartered 2026) |
What this means for builders
First, if you operate an enterprise SaaS product with workflow features, plan to expose your agent layer via A2A. Specifically, ship an Agent Card at /.well-known/agent.json describing your agent’s capabilities. As a result, your customers’ agents at other vendors can discover and call your agent without per-pair integration work.
Next, if you build a multi-vendor agent orchestrator, A2A is your default way to call out to external agent services. By contrast, custom REST APIs require you to negotiate contracts with each vendor — A2A standardizes the contract once.
Finally, if you’re evaluating the agent infrastructure stack, treat A2A and MCP as complementary tools. In short, MCP gets you data and tools; A2A gets you other agents. Both belong in any serious agent runtime by 2026.
Builder’s take
A2A solves a different problem than the one I personally have at Cyntr — my agents talk to each other inside one runtime, not across organizations. But the Salesforce / ServiceNow / Workday adoption signal tells me enterprise workflow tools are about to need this. In short, if you build B2B SaaS that touches workflow, you’ll need an Agent Card by 2027 — the same way every product needed an API endpoint by 2015.
- The Linux Foundation governance is the right call. A2A is too important for Google’s strategic interests to sit in Google’s repo alone. Donating it preserves vendor neutrality the same way Kubernetes survived being a Google project.
- Notable absence: Anthropic and OpenAI. Both labs focus on the agent-to-tool layer (MCP and function calling). A2A’s success doesn’t require their adoption — but it does require enterprise customers to demand inter-vendor agent calls. Watch the Salesforce-ServiceNow cross-call pattern.
- Practical first step for B2B SaaS: ship an Agent Card at
/.well-known/agent.jsondescribing your existing API as an agent capability. That’s table stakes by Q1 2027 and a 2-day engineering effort today.
Common misconceptions about Agent2Agent
A2A gets misread in three predictable ways by people who skim the spec without building against it. Worth correcting before any architecture decision.
- A2A is not just for agent-to-agent calls. It also covers human-to-agent and agent-to-MCP-server interactions. The ‘agent-to-agent’ framing in the name oversells one use case.
- A2A does not require a central registry. Agent cards are served by the agent itself at a well-known path. There is no Google-controlled directory or registry your agent must register with — that was a deliberate design choice.
- A2A is not competing with MCP. MCP is about tools an agent can call; A2A is about discovery and communication between agents. Most production deployments use both.
Frequently asked questions
Google announced A2A at Google Cloud Next in April 2025 with a launch coalition of more than fifty enterprise software companies. Importantly, Google donated A2A to the Linux Foundation in 2025, where it now sits with broader vendor-neutral governance.
A2A connects one agent to another. By contrast, MCP connects an agent to tools and data. In short, MCP answers “how does my agent talk to a database,” while A2A answers “how does my agent talk to another organization’s agent.” The two protocols are complementary; many production agent runtimes ship both.
Yes. The specification, reference implementations, and SDKs all live at a2a-protocol.org under an open license. The Linux Foundation governs the protocol with vendor-neutral policies similar to how it governs Kubernetes and Prometheus.
An Agent Card is a JSON document published at /.well-known/agent.json on an agent’s domain. It describes the agent’s name, capabilities, supported authentication schemes, and endpoints. Other agents fetch the Agent Card to discover what an agent can do — similar to how OAuth’s well-known endpoints work for human authentication.
The Linux Foundation. Specifically, A2A sits within the LF AI Foundation. As of 2026, the protocol has more than 150 contributing organizations. Notably, founding contributors include SAP, ServiceNow, Salesforce, Workday, Atlassian, Box, and dozens of other enterprise software vendors.
Primary sources
- A2A Protocol — official specification site
- Google Cloud blog — A2A: A New Era of Agent Interoperability — April 2025
- A2A GitHub repository
- Linux Foundation — A2A under LF AI Foundation
Last updated: May 20, 2026. Related: Commerce, Identity Provenance.
