A2A (Agent2Agent Protocol) — Communication Standard for Multi-Agent Systems
A2A stands for Agent2Agent Protocol — an open standard that lets independent AI agents talk to each other, regardless of which vendor or framework built them. Google introduced A2A in April 2025, and governance has sat with the Linux Foundation since June 2025. The core idea: once several agents inside a company need to work together — a procurement agent here, a logistics agent there, both built by different teams or vendors — they need a shared language to delegate tasks, exchange results, and discover each other, without anyone hand-wiring a custom bridge for every agent pairing.
How A2A works technically
An A2A-capable agent publishes an Agent Card — a JSON document that describes what the agent can do, which skills it offers, and which endpoint it can be reached at. Another agent reads that card, finds the matching skill, and sends it a task over that endpoint.
The actual communication runs over JSON-RPC 2.0 on HTTP(S). A task moves through a fixed lifecycle with clearly defined states: submitted → working → input-required → completed (or failed / canceled / rejected). For long-running tasks, A2A supports synchronous requests, streaming via Server-Sent Events, and asynchronous callback URLs — so the calling agent doesn’t have to block while waiting for a response.
Important for real-world use: A2A treats every agent as a black box. The calling agent never sees the internal reasoning, memory, or tools of the called agent — only the Agent Card on the outside and the task results. That’s a deliberate design choice, so companies can connect agents to each other without exposing internal logic or trade secrets.
A2A vs. MCP — the distinction
A2A is often confused with MCP because both promise “interoperability for AI.” The difference is the direction of the connection:
- MCP connects vertically — a single agent with its tools, data sources, and APIs (Anthropic, since November 2024).
- A2A connects horizontally — one agent with another, independent agent (Google, since April 2025).
Rule of thumb
MCP answers the question “How does my agent reach tools and data?” A2A answers the question “How does my agent talk to someone else’s agent?” Production multi-agent systems typically use both at once — MCP inside each individual agent, A2A between the agents.
Since December 2025, both protocols have also sat under the same governance roof: the Agentic AI Foundation (AAIF) was formed under the Linux Foundation, with Anthropic, Google, OpenAI, Microsoft, AWS, and Block as founding members. MCP and A2A are maintained there as complementary, non-competing pieces of the same interoperability stack.
Use cases in multi-agent systems
A2A is worth it wherever agents need to collaborate across team, company, or vendor boundaries, rather than staying inside a single multi-agent orchestration framework:
- Supply-chain coordination. A manufacturer’s ordering agent talks directly to a carrier’s logistics agent — both run by different companies, with no shared codebase.
- Financial services and insurance. Specialized agents for risk assessment, fraud detection, and customer communication delegate subtasks to each other, often across cloud boundaries (Google Cloud, Microsoft Azure, and AWS now all support A2A natively).
- IT operations. A monitoring agent detects an anomaly and delegates root-cause analysis to a specialized diagnostics agent from another vendor, instead of rebuilding that logic itself.
- Agent marketplaces. Agents can discover each other and query capabilities via the Agent Card — a foundation for ecosystems where companies buy specialized third-party agents instead of building their own.
As of September 2026: governance and adoption
Google fully handed A2A over to the Linux Foundation in June 2025 — the specification and SDKs have sat under neutral, vendor-independent governance ever since. At its one-year mark in April 2026, the project reported more than 150 supporting organizations, native integration across all three major cloud platforms (Google Cloud, Microsoft Azure, AWS), and early production use in supply chain, financial services, insurance, and IT operations. The spec reached version 1.0 status around that anniversary. The newly formed Agentic AI Foundation reportedly counted around 190 member organizations as of May 2026. These figures reflect the date of the cited source and may shift further as the ecosystem keeps growing.
FAQ
Is A2A a replacement for MCP? No. They solve different problems: MCP connects an agent to its own tools and data sources, A2A connects an agent to another, independent agent. Production multi-agent systems typically use both together.
Who is behind A2A? Google introduced A2A in April 2025 and handed the specification over to the Linux Foundation in June 2025. Since December 2025, governance has sat alongside MCP under the newly formed Agentic AI Foundation, with Anthropic, Google, OpenAI, Microsoft, AWS, and Block as founding members.
Does an agent need a specific programming language or framework to use A2A? No. A2A is deliberately framework-agnostic: communication runs over JSON-RPC 2.0 on HTTP(S), regardless of whether the agent was built with LangGraph, a proprietary stack, or something entirely custom. The only requirement is that the agent publishes a valid Agent Card and correctly implements the task lifecycle states.
What is an Agent Card? A JSON document that an A2A-capable agent publishes, describing which skills it offers, which input and output formats it supports, and which endpoint it can be reached at. Other agents use the Agent Card to find matching agents and delegate tasks to them.
Can a calling agent see how the other agent works internally? No, and that’s by design. A2A treats every agent as a black box — only the Agent Card and the results of completed tasks are visible, not the internal reasoning, memory, or tools of the called agent.