Agent-to-Agent (A2A): the standard letting AI agents work together
What Google's A2A protocol is, how it pairs with MCP, and why multi-agent interoperability finally matters for operators building real stacks.
Most operators building with AI agents today hit the same wall: agents built on different frameworks, by different vendors, cannot natively hand work to each other. You end up with custom glue code for every pair, or you stay inside one vendor’s walled garden. The Agent-to-Agent (A2A) protocol is the industry’s answer to that problem — and it’s moving faster than most teams realize.
What A2A actually is
A2A is an open standard Google announced in April 2025 that enables AI agents built by different vendors to discover each other, delegate tasks, and coordinate work across enterprise systems. The mechanism is straightforward: agents advertise their capabilities using an “Agent Card” in JSON format, allowing a client agent to identify the best agent for a task and communicate with that remote agent.
Communication is oriented toward task completion. The “task” object is defined by the protocol and has a lifecycle — it can be completed immediately, or for long-running tasks, agents stay in sync on the latest status.
Under the hood, A2A uses HTTP, Server-Sent Events, and JSON-RPC 2.0 for transport. Nothing exotic. If you can deploy a web service, you can run an A2A-compatible agent.
Governance matters too. Google donated A2A to the Linux Foundation in June 2025, establishing the Agent2Agent Protocol Project under neutral governance. Initial Linux Foundation founding members included AWS, Cisco, Google, Microsoft, Salesforce, SAP, and ServiceNow.
The protocol counts 150+ organizational supporters as of mid-2025, according to IBM Think.
The problem it was built to solve
Before A2A, enterprise AI teams building multi-agent systems faced a fragmentation problem: agents from one vendor could not reliably hand off work to agents from another vendor using a shared, open standard. Teams could write custom API integrations between specific agents, but every new agent pair required a new bespoke connector. Each framework had its own internal messaging format and task model, with no common discovery mechanism.
While earlier agent orchestration frameworks like CrewAI and LangChain automate multi-agent workflows within their own ecosystems, the A2A protocol acts as a messaging tier that lets these agents “talk” to each other despite their distinct agentic architectures. That distinction is worth sitting with: A2A doesn’t replace your orchestration framework, it makes your orchestration framework interoperable with everyone else’s.
How A2A and MCP fit together
A2A and MCP are the two protocols that will define agentic infrastructure. They are not competitors.
MCP standardizes how a single AI agent connects to external tools and data sources — think of it as the USB-C port for AI, a universal interface that lets any agent plug into any tool.
A2A standardizes how multiple AI agents communicate with each other — it’s the coordination layer for how agents discover each other, delegate tasks, and pass work back and forth.
The cleanest mental model: a planner agent might reach out to other agents via A2A, which in turn uses MCP to fetch tools. One layer handles vertical integration (agent to tools), the other handles horizontal integration (agent to agent). Most modern, scalable agentic AI systems will ultimately leverage both protocols — MCP for reliable tool and context integration, and A2A for orchestrating teamwork across agents and distributed processes.
Anthropic introduced MCP in November 2024. It’s now housed by the Linux Foundation as well, following a similar governance trajectory to A2A.
Where framework support stands today
This is where operators need to pay attention, because support is uneven.
As of March 2026, /tools/crewai/ sits at 45,900+ GitHub stars, with native support for both MCP and A2A communication, powering over 12 million daily agent executions in production.
Google’s ADK has native support for the A2A protocol, enabling communication between agents from different frameworks — an ADK agent can discover and invoke an agent built with LangGraph or CrewAI through A2A’s standardized task interface.
/tools/langgraph-cloud/ is the more nuanced story. LangGraph doesn’t have built-in native A2A support — you build those integrations yourself.
LangGraph agent systems can be wrapped in APIs or A2A protocol structures for interoperability, but it requires engineering effort rather than a toggle. For teams on /compare/crewai-vs-langgraph-cloud/, this gap matters more with each quarter.
/tools/n8n/ and similar low-code platforms abstract this away from you entirely — if you’re using a no-code platform, both protocols are abstracted away from you. That’s fine for linear automation, but limits your options as workflows grow in complexity.
For teams looking at purpose-built agent platforms like /tools/relevance-ai/, the A2A question becomes: does the platform let you expose agents as A2A-compatible endpoints, or does it lock you into proprietary agent-to-agent handoffs? That’s a vendor question worth asking explicitly before you build.
The security surface you can’t ignore
A2A is not plug-and-play from a security standpoint. A2A uses agent cards to advertise capabilities and declare supported authentication schemes, but it does not mandate how those cards are verified for authenticity. The protocol delegates credential management entirely to implementers, meaning agent impersonation, card tampering, and replay attacks are real risks without additional controls.
A2A v1.0 shipped in early 2026 with Signed Agent Cards, adding cryptographic verification — but adoption of that feature is on you. If you’re deploying A2A agents that talk to external systems, mutual TLS, signed agent cards, and PKI-backed machine identities close authentication gaps that OAuth tokens alone cannot. Treat each agent endpoint like an API you’d expose externally, because functionally that’s what it is.
Why this matters for operators right now
The near-term stakes for operators are concrete. Gartner projects that 40% of enterprise apps will feature task-specific AI agents by 2026, up from less than 5% in 2025. Without a standardized agent-to-agent protocol, those agents remain isolated, working in silos, unable to leverage collective intelligence.
If you’re building on /tools/clay/ for data enrichment, a customer support agent on one platform, and a coding agent on another, A2A is the layer that eventually makes those agents collaborate without a human routing between them. Today that’s aspirational for most teams. But the standard is real, the governance is neutral, and the enterprise deployments are live at Microsoft, AWS, Salesforce, SAP, and ServiceNow.
The practical sequence: start with MCP for tool access, since it’s more mature, has better tooling, and covers the majority of use cases. Add A2A when you have a genuine multi-agent coordination need.
Bottom line: A2A is a real, Linux Foundation–governed protocol — not a Google product play — and it’s past early-adopter status. Operators who are serious about multi-agent systems should be demanding A2A support from vendors now, not waiting until it’s a retrofit problem. The MCP + A2A stack together is the closest thing the industry has to settled infrastructure for agentic work.