Google's A2A Protocol: The TCP/IP for AI Agents? 26k Stars & Linux Foundation Backing

What Is A2A?

A2A (Agent-to-Agent) is not a runnable agent framework but a protocol specification plus multi-language SDKs . Its official definition: an open protocol for communication and collaboration between opaque agentic applications. "Opaque" means each agent's internal state, memory, private logic, and tool implementations need not be exposed for collaboration to occur.

The article uses a vivid analogy: if MCP is the USB interface for an agent, A2A is the TCP/IP between agents.

A2A and MCP: Complementary, Not Competitive

MCP governs how a single agent connects to tools — databases, file systems, external APIs. A2A governs how agents connect to each other — how one agent delegates work to another, how they discover, negotiate, and collaborate. The two protocols are complementary: MCP extends an agent's reach; A2A enables a group of agents to form a team. The official DeepLearning.AI course includes a dedicated lesson on how A2A supplements MCP.

How the Protocol Works

A2A's mechanism consists of three core pieces:

Agent Cards for discovery. Each agent publishes a card describing its capabilities, connection details, and supported interaction modes. Other agents read the card to understand the peer's boundaries without prior hard-coding.

JSON-RPC 2.0 over HTTP(S). The transport layer uses standard JSON-RPC 2.0 over HTTP/HTTPS, avoiding proprietary protocols and lowering the adoption barrier.

Three interaction modes. Synchronous request/response for quick Q&A streaming SSE for long-running tasks that emit incremental results; asynchronous push notifications for background tasks that complete later. These three modes cover the full spectrum from instant answers to week-long jobs.

Another key design point is rich data exchange : A2A transports not only chat text but also files and structured JSON, allowing agents to exchange formatted reports rather than plain text.

Why A2A Stands Out

Google initiation + Linux Foundation governance. Donation to a neutral foundation means the protocol is no longer a single company's property. Apache-2.0 license and community-driven evolution give it the neutrality essential for a standard.

Six official SDKs. Python, Go, JavaScript, Java, .NET, and Rust all have official SDKs, covering most enterprise tech stacks.

Protection of opacity. Unlike tool-calling approaches, A2A allows agents to collaborate without exposing internal state, memory, or tools . For enterprises, this means cross-team and cross-vendor collaboration can keep proprietary data and logic private.

Installation and Setup

The path to adoption is straightforward:

# Python SDK (recommended)
pip install a2a-sdk

# Go / JS / Java / .NET / Rust each have corresponding SDK
go get github.com/a2aproject/a2a-go
npm install @a2a-js/sdk

Developers expose agents built with frameworks like Google ADK, LangGraph, or BeeAI as A2A servers, then use the client to connect. The full specification, tutorials, and the a2a-samples example repository are available at https://a2a-protocol.org.

Open Questions and Caveats

Not plug-and-play. The protocol, spec, and SDKs provide the language, not a finished application. You must build the server/client yourself and design the division of labor between agents. The implementation effort is non-trivial.

Main repository is a thin shell. The primary repo contains little code (mostly Shell scripts for the specification); the real SDKs live in six separate sub-repositories. Getting started requires reading specs and examples across repos, making the learning curve steeper than a single pip install.

Protocol still evolving. The roadmap includes formal authorization in AgentCard, a new QuerySkill method for dynamic skill discovery, in-task UX negotiation, streaming reliability improvements, and more — indicating rapid iteration. Today's best practices may be superseded tomorrow.

278 open issues. High activity is positive for a standard project, but also signals that many edge cases remain unpolished.

Final Thoughts

A2A's greatest significance is strategic positioning. While most projects focus on stronger individual agents or better orchestration frameworks, A2A targets the foundational, hardest layer: the protocol. Once it becomes a de facto standard, higher-level frameworks, tools, and orchestrators will have to align with it. Google's donation to the Linux Foundation is a deliberate move to trade exclusive control for neutrality and credibility — a play to become the TCP/IP of multi-agent systems.

The author's practical advice: if you are an engineer building multi-agent systems, learn A2A now because it is a strong candidate for the universal language of agent collaboration; if you only need to make a single agent more capable, focus on MCP first. Don't rewrite your architecture just because of the Google and Linux Foundation badges — protocol choice should follow the application you intend to build.

GitHub repository card: https://opengraph.githubassets.com/1/a2aproject/A2A