What It Does
The Agent2Agent (A2A) protocol is an open communication standard for AI agent interoperability, originally introduced by Google in April 2025 and now housed at the Linux Foundation. A2A enables AI agents built with different frameworks, by different vendors, to discover each other’s capabilities and exchange tasks, context, and results over standard HTTPS + JSON-RPC 2.0. It is complementary to MCP (Model Context Protocol): MCP connects agents to tools and data sources, while A2A connects agents to other agents.
The protocol provides four core capabilities: capability discovery via JSON “Agent Cards,” task management with defined lifecycle states, agent-to-agent collaboration through context and instruction sharing, and user experience negotiation that adapts to different UI capabilities.
Key Features
- Agent Cards: JSON descriptors advertising an agent’s capabilities, similar to OpenAPI specifications for REST APIs
- Task lifecycle management: defined states (submitted, working, input-needed, completed, failed, canceled) with state machine semantics
- HTTPS transport with JSON-RPC 2.0 message format for secure, standardized communication
- Security: supports API keys, OAuth 2.0, OpenID Connect Discovery, aligned with OpenAPI security schemes
- Streaming support: Server-Sent Events (SSE) for real-time task progress updates
- Push notifications: webhook-based notifications for long-running tasks
- Multi-modal: supports text, files, structured data, and forms in agent interactions
- Backed by 50+ technology partners: Atlassian, Box, Cohere, Intuit, LangChain, MongoDB, PayPal, Salesforce, SAP, ServiceNow, UKG, Workday
- Linux Foundation governance ensures vendor-neutral stewardship
Use Cases
- Multi-vendor agent orchestration: enabling agents from different providers (e.g., a Salesforce agent delegating to a ServiceNow agent) to collaborate
- Enterprise agent composition: building complex workflows from specialized agents without tight coupling
- Agent marketplace: enabling discovery and interaction between third-party agents
- Cross-framework interoperability: allowing LangGraph agents to communicate with CrewAI or Google ADK agents
Adoption Level Analysis
Small teams (<20 engineers): Fits if building multi-agent systems that need to interoperate with external agents. The protocol is simple (HTTPS + JSON-RPC) and the spec is well-documented. However, most small teams won’t need agent-to-agent communication.
Medium orgs (20-200 engineers): Good fit for organizations building agent platforms that need to integrate agents from multiple teams or vendors. The standardized discovery and task management reduce integration overhead.
Enterprise (200+ engineers): Strong fit. The backing of 50+ enterprise partners (Salesforce, SAP, ServiceNow) and Linux Foundation governance make A2A a safe bet for enterprise agent interoperability. The security model (OAuth 2.0, OIDC) aligns with enterprise requirements.
Alternatives
| Alternative | Key Difference | Prefer when… |
|---|---|---|
| Model Context Protocol (MCP) | Connects agents to tools/data sources, not agent-to-agent | You need tool integration, not agent-to-agent communication |
| Custom REST APIs | Direct integration without protocol overhead | You control both agents and don’t need multi-vendor interoperability |
| gRPC-based agent communication | Binary protocol with stronger typing | You need high-throughput, low-latency agent communication within a controlled environment |
Evidence & Sources
- Google Developers Blog: Announcing the Agent2Agent Protocol
- IBM: What Is Agent2Agent (A2A) Protocol?
- Linux Foundation A2A Project Launch
- A2A Protocol Official Site
- Google Cloud Blog: A2A Protocol Upgrade
Notes & Caveats
- Complementary to MCP, not competing: A2A handles agent-to-agent communication; MCP handles agent-to-tool/data communication. Both are needed for a complete agent interoperability stack.
- Still maturing: The protocol received upgrades in 2026 and is still evolving. Early adopters should expect spec changes.
- Google-originated: While now at the Linux Foundation, Google’s influence on the protocol direction is significant. Competitors (Microsoft, Amazon) have not publicly endorsed A2A, which could limit adoption in non-Google ecosystems.
- Implementation complexity: While the wire protocol is simple (HTTPS + JSON-RPC), implementing full Agent Card discovery, task lifecycle management, and streaming correctly requires careful engineering. Few production implementations exist outside of demo/tutorial contexts.
- No adoption metrics: Despite 50+ partner logos, there are no published metrics on actual A2A production traffic or the number of agents implementing the protocol.