A2A Protocol Explained: How Google’s Agent Standard Works

A2A, short for Agent2Agent, is an open communication protocol that lets independent AI agents — built by different companies, on different frameworks — find each other, share what they can do, and hand off work, without needing custom integration code for every pair of agents. Google created A2A and introduced it in April 2025, then donated it to the Linux Foundation two months later for neutral, vendor-independent governance. As of October 2026, A2A sits alongside the Model Context Protocol (MCP) inside the Linux Foundation's Agentic AI Foundation, with a first stable 1.0 specification and backing from more than 150 organizations.

What is the A2A protocol?

A2A defines a common way for one AI agent to talk to another AI agent as a peer, rather than as a tool. An agent that wants help from a specialist agent — say, a travel-booking agent that needs a payments agent to close out a purchase — can use A2A to discover what that other agent is capable of, send it a task, track its progress, and receive results back, all over standard web protocols. Crucially, the two agents don't need to share source code, memory, or internal tools; A2A treats each agent as an "opaque" black box that exposes only a defined, machine-readable interface.

This is a different problem from the one solved by MCP, Anthropic's protocol for connecting a single AI model to external tools, files and data sources. Google's own announcement describes A2A as a protocol that "complements Anthropic's Model Context Protocol (MCP)." MCP gets one agent the context and tools it needs to act; A2A lets that agent then work with other, separately built agents. The two protocols are frequently deployed together, and both are now part of the same Linux Foundation governance umbrella. For a deeper look at the tool side of that equation, see Pandromeda's explainer on MCP.

Why Google built A2A

According to the original Google Developers Blog post announcing the protocol, Google built A2A after running into real friction while helping enterprise customers deploy large multi-agent systems: agents built on different frameworks and by different vendors had no shared way to discover one another or coordinate work. The post, co-authored by Google Cloud's Rao Surapaneni, Miku Jha, Michael Vakoc and Todd Segal, lays out five design principles the team said guided the protocol:

• Embrace agentic capabilities — support agents collaborating in their natural, unstructured modes, not just as function calls
• Build on existing standards — reuse HTTP, Server-Sent Events and JSON-RPC rather than invent new wire formats
• Secure by default — support enterprise-grade authentication and authorization out of the box
• Support for long-running tasks — tasks can take seconds, minutes or days, including steps that need a human in the loop
• Modality agnostic — agents can exchange text, audio, video, forms and other media, not just chat text

At launch, A2A had the backing of more than 50 technology and consulting partners, including Atlassian, Box, Cohere, Intuit, LangChain, MongoDB, PayPal, Salesforce, SAP, ServiceNow, UKG and Workday, alongside systems integrators such as Accenture, Capgemini, Deloitte, KPMG and PwC, per Google's announcement. Salesforce has separately said it proposed the Agent Card concept that Google ultimately adopted into the specification, though that account comes from Salesforce rather than Google's own post.

Agent Cards and Tasks: the two core building blocks

A2A's technical design rests on two main concepts, both defined in the official specification at a2a-protocol.org.

Agent Cards. An Agent Card is a JSON metadata document that describes an agent's identity, the skills it offers, where to reach it, and how to authenticate with it. A client agent fetches another agent's card — conventionally published at the well-known path /.well-known/agent-card.json on the serving agent's domain — to learn what that agent can do before ever sending it work. This is the discovery mechanism that lets agents find appropriate collaborators without a human wiring up the integration by hand.

Tasks. A Task is a stateful unit of work that one agent initiates on another, identified by a unique ID and tracked through a defined lifecycle. The specification lists task states including submitted, working, input-required, auth-required, completed, failed, canceled and rejected — with completed, failed, canceled and rejected treated as terminal states. Because tasks carry state across the exchange, A2A supports both quick synchronous requests and work that runs for minutes, hours or longer, including steps where an agent has to pause and ask a human or another agent for more input.

How agents actually talk: HTTP, JSON-RPC and streaming

True to its "build on existing standards" principle, A2A does not invent a new network protocol. Per the official specification, communication happens over HTTP(S), with JSON-RPC 2.0 as the primary payload format for requests and responses; the 1.0 specification also formally defines gRPC and HTTP+JSON/REST as alternative protocol bindings, so implementers aren't locked to one wire format. For work that produces results incrementally — a long research task streaming back partial findings, for instance — A2A uses Server-Sent Events (SSE) to keep a long-lived HTTP connection open and push updates as they happen. For agents that may be offline or slow to respond, A2A also supports asynchronous push notifications delivered over plain HTTP POST. None of this requires custom infrastructure beyond what most web services already run.

Who's behind A2A: from a Google project to a Linux Foundation project

A2A's governance has moved twice since its April 2025 debut, and each step is documented in a primary-source announcement.

April 2025 — Google launches A2A. Google released the protocol as open source at Google Cloud Next, positioning it as complementary to MCP and opening it to partner contributions from day one.

June 2025 — donated to the Linux Foundation. At the Open Source Summit North America in Denver, the Linux Foundation announced it would host the Agent2Agent Protocol Project, with Google Cloud, AWS, Cisco (via its Outshift unit), Microsoft, Salesforce, SAP and ServiceNow named as founding members and more than 100 companies already supporting the project. Linux Foundation executive director Jim Zemlin said the foundation was "happy to be the new home of the Agent2Agent Protocol project," framing the move as a way to guarantee long-term neutrality and vendor-independent governance rather than leaving the standard under any single company's control.

April 2026 — one-year milestone. A follow-up Linux Foundation press release reported A2A had grown to more than 150 supporting organizations (up from roughly 50 a year earlier), that its core GitHub repository had passed 22,000 stars, and that official SDKs now shipped in five languages: Python, JavaScript, Java, Go and .NET. The release also marked the arrival of A2A 1.0 as the protocol's first stable specification, and pointed to production integrations including Microsoft Azure AI Foundry and Copilot Studio, and Amazon Bedrock AgentCore Runtime on AWS.

August 2026 — joins the Agentic AI Foundation. Most recently, A2A became a hosted project of the Agentic AI Foundation (AAIF), a Linux Foundation initiative launched in December 2025 that also hosts MCP, Block's Goose and OpenAI's AGENTS.md. AAIF said it had grown from fewer than 40 member organizations to more than 250 since launch. AAIF CTO Manik Surtani said A2A "represents an important step toward an open, interoperable future for AI agents," while Google Cloud's Rao Surapaneni said the protocol "enables agents to easily discover, delegate, and collaborate across frameworks and siloed platforms." The move keeps A2A's own maintainers, specification process and release cadence intact — it changes where the project is formally housed, not how it's run day to day.

Technical direction is set by an A2A Technical Steering Committee that, per the project's own documentation on GitHub, includes representatives from AWS, Cisco, Google, IBM Research, Microsoft, Salesforce, SAP and ServiceNow. The project is licensed under the Apache License 2.0, and its governance rules are published in the repository's GOVERNANCE.md and MAINTAINERS.md files.

The current spec: version 1.0.0

The A2A specification published at a2a-protocol.org currently lists 1.0.0 as the latest released version, following earlier 0.1.0, 0.2.6 and 0.3.0 releases. The spec describes itself as identified by a Major.Minor version number, with patch releases not affecting compatibility — meaning 1.0.1 or 1.0.2 would be safe drop-in updates, while a future 1.1 or 2.0 could introduce breaking changes. A normative protobuf definition (spec/a2a.proto) in the GitHub repository is the source of truth for the protocol's data structures, and official SDKs are generated from it rather than hand-written, to keep implementations in different languages consistent. The 1.0 release also added signed Agent Cards for cryptographic identity verification and expanded support for enterprise multi-tenancy, according to the Linux Foundation's one-year update.

A2A vs. MCP: how the two protocols fit together

A2A and MCP are often mentioned in the same breath because they solve adjacent problems in the same agentic stack, not because they compete. The table below summarizes how they differ, based on the two protocols' own documentation.

In practice, the two are designed to be used together. A single agent might use MCP to pull data from a company database or call an internal API, and then use A2A to hand off a sub-task to a specialized partner agent run by a different vendor entirely. For broader background on what makes something an "agent" in the first place, see how AI agents actually work.

Who's adopting A2A

Per the Linux Foundation's April 2026 update, A2A's backers now span cloud providers, enterprise software vendors and systems integrators, including AWS, Cisco, Google, IBM, Microsoft, Salesforce, SAP and ServiceNow, with reported production use in sectors such as supply chain, financial services, insurance and IT operations. On the cloud-platform side, the release points to A2A support built into Microsoft Azure AI Foundry and Copilot Studio, and into Amazon Bedrock AgentCore Runtime; Google has described "deep integration" of A2A across its own platforms without naming every specific product. Popular open-source agent frameworks including LangGraph and CrewAI are also cited as supporting A2A-based task delegation and multi-agent coordination, according to the same release.

It's worth flagging that adoption figures — the number of supporting organizations, GitHub star counts, and named production deployments — come from the Linux Foundation and Google's own announcements rather than independent audits, so they should be read as the project's self-reported traction rather than third-party-verified usage data.

Open questions and limitations

A2A is still a young standard. Its own specification repository lists ongoing work on areas such as task lifecycle and UX, streaming reliability, and push-notification mechanisms, which suggests parts of the protocol are still being hardened based on real-world implementation experience rather than fully settled. Because A2A treats remote agents as opaque black boxes by design, debugging a failed multi-agent workflow can be harder than debugging a single model call — if a remote agent errors out, the calling agent typically only sees whatever the Agent Card and task status report, not the internals of what went wrong. And because the ecosystem is new, tooling for things like cross-vendor testing, observability and a shared agent registry is still described as a roadmap item in the Linux Foundation's own materials rather than a finished capability.

What's next for A2A

With a 1.0 specification shipped and governance now consolidated under the Agentic AI Foundation alongside MCP, the next phase for A2A looks less about the core wire protocol and more about the surrounding ecosystem. The Linux Foundation's own roadmap, published with its one-year update, points to an interoperability specification connecting A2A to other emerging standards, consolidated registry efforts to make it easier to find and trust Agent Cards at scale, expanded conformance testing and tooling, and published security and deployment best practices for enterprises running agents in production. A related effort, the Agent Payments Protocol (AP2), is also being developed under the same governance umbrella to let agents handle payments, with more than 60 organizations reportedly backing it as of April 2026. Expect A2A's roadmap to keep tracking closely with MCP's now that both live inside the same foundation — the practical test for both protocols will be whether "agent talks to agent across vendors" and "agent talks to its tools" keep working as reliably in production as they do in Google's and the Linux Foundation's own demos.

Written byTheo Park

Theo Park runs the AI desk at Pandromeda. He follows model launches from the frontier labs and the open-weight community, tracks the assistants and developer tools built on them, and explains what each release changes on pricing, capability and safety. His reporting leans on primary sources: model cards, technical reports, API documentation and the companies' own announcements.

More from Theo ParkAll AI coverage