Key takeaways
- A2A is the de facto industry standard for agent-to-agent interoperability, backed by Google with 150+ supporting organizations
- Agent Cards provide JSON-based capability discovery — agents publish what they can do without exposing internals
- Supports synchronous, streaming (SSE), and async push notification patterns over JSON-RPC 2.0 / HTTP(S)
- Complementary to MCP — A2A handles agent-to-agent coordination while MCP handles agent-to-tool access
FAQ
What is A2A?
A2A (Agent2Agent) is an open protocol by Google enabling AI agents built on different frameworks to discover each other's capabilities, negotiate interaction modalities, and collaborate on tasks without exposing internal state or tools.
How does A2A differ from MCP?
MCP connects agents to tools and data sources. A2A connects agents to other agents. They are complementary — an agent can use MCP to access tools and A2A to collaborate with other agents.
What companies support A2A?
Over 150 organizations including Google, Salesforce, SAP, Atlassian, MongoDB, LangChain, and CrewAI.
Is A2A open source?
Yes, A2A is Apache 2.0 licensed with SDKs for Python, Go, JavaScript, Java, and .NET.
Executive Summary
A2A (Agent2Agent) is Google's open protocol for enabling communication between opaque AI agents — agents that don't share internal state, memory, or tools. Launched in April 2025, it has rapidly become the leading standard for agent interoperability, with 150+ supporting organizations and SDKs in five languages. [1]
The protocol's core insight: agents should interact as peers, not as tools. A2A treats each agent as an opaque service that advertises capabilities via Agent Cards, accepts tasks, and returns results — without requiring the caller to know anything about the agent's internal architecture.
| Attribute | Value |
|---|---|
| Organization | A2A Project (initiated by Google) |
| Launched | April 2025 |
| Current Version | 0.3 (July 2025) |
| License | Apache 2.0 |
| GitHub Stars | 22K |
Product Overview
A2A defines how agents discover, communicate, and collaborate over standard web infrastructure. [2]
Key Capabilities
| Capability | Description |
|---|---|
| Agent Cards | JSON documents describing an agent's capabilities, authentication requirements, and connection info |
| Task Management | Defined lifecycle states for long-running tasks with progress tracking |
| Flexible Communication | Synchronous request/response, streaming (SSE), and async push notifications |
| Rich Data Exchange | Text, files, structured JSON, and negotiated UI modalities |
| Enterprise Security | Authentication, authorization, and signed security cards (v0.3) |
Protocol Stack
| Layer | Detail |
|---|---|
| Transport | HTTP(S), gRPC (v0.3+) |
| Wire Format | JSON-RPC 2.0 |
| Discovery | Agent Cards (JSON, well-known URL) |
| Authentication | OAuth 2.0, API keys, signed cards |
| SDKs | Python, Go, JavaScript, Java, .NET |
How It Works
Client Agent Server Agent
│ │
│── GET /.well-known/agent.json ────►│ (Discovery)
│◄── Agent Card ────────────────────│
│ │
│── tasks/send ────────────────────►│ (Create task)
│◄── Task (submitted/working) ──────│
│ │
│── tasks/get ─────────────────────►│ (Poll or SSE)
│◄── Task (completed + artifacts) ──│
Technical Architecture
A2A is designed as a thin coordination layer, not a framework. [2]
| Aspect | Detail |
|---|---|
| Protocol Type | Open standard (specification + SDKs) |
| State Model | Task-based with defined lifecycle (submitted → working → completed/failed/canceled) |
| Discovery | Agent Cards at /.well-known/agent.json or registry |
| Communication | Stateless HTTP or stateful streaming/push |
| Security | OAuth 2.0, signed Agent Cards, enterprise auth delegation |
| Opacity | Agents never expose internal state, memory, or tools |
v0.3 Additions (July 2025)
- gRPC support for high-performance agent communication
- Signed security cards for enterprise trust verification
- Extended Python SDK with richer type support
- Agentspace integration for Google Cloud agent marketplace [3]
Strengths
- Industry momentum — 150+ supporting organizations; the closest thing to a standard the space has
- Google backing — Resources, credibility, and cloud integration (Agentspace, Vertex AI)
- Framework-agnostic — Works with any agent framework (LangGraph, CrewAI, AutoGen, custom)
- Multi-language SDKs — Python, Go, JS, Java, .NET covers most enterprise stacks
- Complementary to MCP — Clear separation of concerns; doesn't compete with tool protocols
- Enterprise security — OAuth, signed cards, and auth delegation from day one
- DeepLearning.AI course — Structured learning path accelerates adoption
Cautions
- Still pre-1.0 — Version 0.3 means breaking changes are still possible
- Google-centric governance — Despite "open" branding, Google drives the roadmap
- Stateless bias — Task-based model is simpler but less suited to long-lived multi-party transactions
- No built-in trust/reputation — Agents can discover each other but there's no protocol-level trust scoring
- Discovery is basic — Agent Cards are static JSON; no dynamic marketplace or semantic matching
- Enterprise adoption unclear — 150+ "supporting" organizations doesn't mean 150+ production deployments
- Competing protocols emerging — ACP, ANP, and Summoner offer different trade-offs
Pricing & Licensing
| Tier | Price | Includes |
|---|---|---|
| Open Source | Free | Full protocol spec, all SDKs (Apache 2.0) |
| Google Cloud | Cloud pricing | Agentspace integration, Vertex AI Agent Engine |
Competitive Positioning
| Protocol/Framework | A2A Differentiator |
|---|---|
| MCP | MCP is agent-to-tool; A2A is agent-to-agent. Complementary, not competing |
| ACP (IBM/BeeAI) | ACP is REST-based, conversation-focused; A2A uses JSON-RPC with richer task lifecycle |
| ANP | ANP aims for decentralized identity (W3C DID); A2A uses standard OAuth/enterprise auth |
| Summoner (SPLT) | Summoner provides durable signed state for cross-org transactions; A2A is simpler but less stateful |
| CrewAI/AutoGen | Frameworks, not protocols; both can implement A2A for external communication |
Ideal Customer Profile
Best fit:
- Enterprises building multi-vendor agent ecosystems
- Teams integrating agents from different frameworks
- Google Cloud customers wanting Agentspace integration
- Organizations needing industry-standard agent interoperability
Poor fit:
- Single-agent applications
- Teams needing deep cross-organizational trust and state management
- Decentralized/permissionless agent networks
- Teams that need production-hardened protocol (still pre-1.0)
Viability Assessment
| Factor | Assessment |
|---|---|
| Financial Health | Strong — Google-backed |
| Market Position | Leading — Most adopted agent-to-agent protocol |
| Innovation Pace | Active — v0.3 in July 2025, ongoing development |
| Community/Ecosystem | Growing — 22K stars, 150+ organizations, DeepLearning.AI course |
| Long-term Outlook | Favorable — Strong network effects, but needs 1.0 to lock in adoption |
Bottom Line
A2A is the front-runner for agent-to-agent interoperability. Its combination of Google backing, multi-language SDKs, and broad industry support gives it the strongest network effects of any protocol in the space. The task-based model is pragmatic — simple enough to adopt, flexible enough for most use cases.
Recommended for: Any team building multi-agent systems that need to interoperate across frameworks or organizations.
Not recommended for: Teams needing durable cross-organizational state management (look at Summoner) or decentralized identity (look at ANP).
Outlook: A2A will likely become the HTTP of agent communication — good enough for most use cases, with specialized protocols (Summoner, ANP) filling gaps for advanced scenarios. The path to 1.0 will determine whether it truly standardizes or fragments.
Research by Ry Walker Research • methodology