Every major tech company now ships AI agents. None of them speak the same language.
By early 2025, enterprises had stumbled into an uncomfortable situation: Salesforce agents handling CRM, ServiceNow agents managing IT tickets, SAP agents running supply chain operations. The integration strategy? Custom code. Lots of it. Every agent-to-agent connection required bespoke engineering, and the math gets ugly fast. Five agent vendors means ten pairwise integrations. Ten vendors means 45. Google's Agent2Agent (A2A) protocol is the first serious attempt to fix this, giving autonomous systems a shared way to discover each other, negotiate tasks, and collaborate without exposing their internals.
Think of it as DNS plus HTTP for AI agents. Just as the web needed standard protocols before it could become the web, multi-agent systems need something like A2A before they can scale beyond proof-of-concept demos.
Google announced A2A in April 2025 with over 50 technology partners including Atlassian, Salesforce, SAP, and ServiceNow. That breadth of launch coalition tells you something: the industry wanted a standard badly enough to agree on one before it was even production-ready.
The Deliberately Boring Architecture
The protocol has three layers: discovery, authentication, and communication. Each one is, by design, unexciting.
Discovery works through Agent Cards. Every A2A-compatible agent publishes a JSON manifest describing what it can do, what inputs it accepts, and how to reach it. According to IBM's technical breakdown, these cards function like a combination of DNS records and API documentation. When Agent A wants to find something that can process expense reports, it queries available Agent Cards looking for that capability. No central registry required.
Authentication builds on what enterprises already have: OAuth 2.0, API keys, OpenID Connect. A protocol requiring novel authentication would be dead on arrival.
Communication uses JSON-RPC 2.0 over HTTPS, with three interaction models depending on how long the work takes. Quick tasks get synchronous responses. Longer operations use Server-Sent Events for streaming. Tasks that might run for hours or days use async push notifications.
Infrastructure-grade boring. Which is exactly right.
Watching a Task Move Through the System
A2A structures work around Task objects that move through defined states: submitted, working, input-needed, completed, failed, or cancelled. Each task can produce Artifacts (files, structured data, whatever the agent generates) and exchange Messages for context.
A concrete example: a travel booking agent receives a request to plan a conference trip. It creates a task, realizes it needs expense policy information, and discovers an HR policy agent via its Agent Card. The travel agent becomes a "client" and delegates a subtask to the HR agent (now acting as "server"). The HR agent returns the policy as an artifact, and the travel agent incorporates it into its booking decisions.
Notice what doesn't happen here. The travel agent never sees how the HR agent works internally. It just gets results.
Agents remain "opaque" during collaboration. Proprietary logic, training data, internal memory, and reasoning chains stay hidden.
This opacity principle might be A2A's most important design decision. IBM's documentation emphasizes it for good reason: enterprises have spent millions training agents on proprietary data. A protocol that required exposing internals would be a non-starter. The opacity guarantee means Salesforce agents can collaborate with SAP agents without either company revealing competitive advantages.
Our read: this is the feature that made the 50-partner launch coalition possible. Without it, every vendor would be building their own walled garden.
A2A and MCP: Different Problems, Same Ecosystem
There's been confusion about how A2A relates to Anthropic's Model Context Protocol. The short answer: they're complementary, not competitive.
MCP connects agents to tools and data sources. It's how an agent accesses a database, calls an API, or reads from a file system. A2A connects agents to other agents. It's how autonomous systems discover, negotiate with, and delegate to each other. One is the agent's hands; the other is its mouth and ears.
The Register's analysis from January 2026 confirms that these protocols have settled into their respective roles, with A2A dominating agent-to-agent communication and MCP handling tool integration. Enterprises deploying serious agent infrastructure will likely need both.
The Linux Foundation Changes Everything
The December 2025 formation of the Agentic AI Foundation under the Linux Foundation shifted A2A's trajectory in ways that matter for adoption. OpenAI donated AGENTS.md, Anthropic donated MCP, Block donated the Goose framework, and A2A merged with IBM's Agent Communication Protocol. Platinum members now include AWS, Microsoft, Bloomberg, Cloudflare, and Google.
Enterprises bet on standards, not vendor protocols. Linux Foundation stewardship signals that A2A is no longer just Google's project.
Still Missing
The protocol isn't finished. Current SDKs exist for Python, Go, JavaScript, Java, and .NET, but planned improvements include better authorization schemes and audio/video negotiation. The latest release (v0.3.0 from July 2025) has 139+ contributors, though production deployments remain early.
Security is an open question. The Register notes that MCP has had vulnerabilities exposing remote code execution risks. A2A's HTTP-based architecture inherits standard web security concerns, but agent-to-agent trust is genuinely harder than agent-to-tool trust. When agents can delegate work to other agents, the attack surface expands in ways we're still learning to map.
Competing protocols exist: UTCP for direct tool calling, ANP for peer-to-peer communication, NLIP from Ecma International for natural language interfaces. None have A2A's traction, but the space isn't fully settled.
Gartner projects that 40% of enterprise applications will feature AI agents by 2026, up from 5% in 2025. That explosion only works if agents can interoperate. A2A is not the only possible answer, but it's the answer that major vendors have agreed to support. The TCP/IP comparison is apt: just as the internet required agreement on packet routing before it could scale, multi-agent systems require agreement on task delegation before they become genuinely useful.
With Google, OpenAI, Anthropic, Microsoft, and AWS all backing the Linux Foundation's governance structure, the conditions for adoption are now in place. Whether it actually happens? That's measured in deployments, not announcements.