// PROTOCOL_EXPLAINER
A2A
Agent2Agent Protocol
Open protocol enabling AI agents to discover, communicate, and collaborate with each other.
The Agent2Agent (A2A) Protocol is an open standard developed by Google that enables AI agents built on different frameworks to communicate and collaborate. Where MCP standardizes agent-to-tool connections, A2A standardizes agent-to-agent interactions. Released in April 2025, it defines how agents discover each other via Agent Cards, negotiate tasks, exchange messages, and stream results. A2A is framework-agnostic — agents built with Google ADK, CrewAI, LangChain, or AutoGen can all interoperate.
// FIGURE_01 — A2A architecture overview: Google · 2025 · HTTP with JSON-RPC 2.0, Server-Sent Events (SSE) for streaming, Agent Card discovery at /.well-known/agent.json
01What is the Agent2Agent Protocol?
A2A is an open protocol that solves the agent interoperability problem. Today, AI agents are built in silos — a CrewAI agent can't easily talk to a LangChain agent, and neither can delegate tasks to a Google ADK agent. A2A provides a common language. Any agent that implements the A2A specification can discover other A2A agents, send them tasks, receive results, and stream intermediate updates. The protocol is built on HTTP, JSON-RPC 2.0, and Server-Sent Events (SSE) — standard web technologies that require no special infrastructure.
02How A2A Works: Client and Remote Agents
A2A defines two roles. A Client Agent is the agent that initiates a task — it has a goal and needs help. A Remote Agent is the agent that receives the task — it has capabilities the client needs. The client discovers remote agents via their Agent Card, a JSON document hosted at a well-known URL (.well-known/agent.json) that describes the agent's capabilities, skills, authentication requirements, and endpoints. Once discovered, the client sends a task via JSON-RPC. The remote agent processes it and returns results either synchronously or via streaming updates through SSE.
03Agent Cards: Capability Discovery
The Agent Card is A2A's discovery mechanism. It's a JSON document that every A2A-compatible agent serves at /.well-known/agent.json. The card includes the agent's name, description, version, a list of skills (what the agent can do), the URL for sending tasks, authentication requirements, and whether the agent supports streaming. Client agents fetch Agent Cards to decide which remote agent has the right capabilities for a given task. This is analogous to how MCP servers list their tools — but for agent-to-agent discovery.
04Tasks, Messages, and Artifacts
A2A models collaboration as Tasks. A client agent creates a task with an initial message. The remote agent processes the task, potentially exchanging multiple messages back and forth. Tasks can be synchronous (immediate response) or long-running (with streaming updates via SSE). When complete, the task produces Artifacts — the deliverables the client requested. This task lifecycle maps naturally to real-world agent collaboration: one agent asks another to do something, they exchange messages to clarify, and the result is delivered as an artifact.
05A2A and MCP: A Layered Architecture
A2A and MCP are complementary, not competing. MCP operates at the context layer — connecting agents to tools and data. A2A operates at the collaboration layer — connecting agents to each other. A typical multi-agent system uses both: each agent uses MCP to access its own tools and data sources, and A2A to communicate with other agents. For example, a research agent might use MCP to query a database, then use A2A to delegate analysis to a specialized analytics agent, which in turn uses MCP to access visualization tools.
06Adoption and Ecosystem
A2A launched with support from over 50 partners including Google, Salesforce, SAP, ServiceNow, and Atlassian. Major agent frameworks have added A2A compatibility: Google's Agent Development Kit (ADK), CrewAI, LangChain, and AutoGen all support the protocol. The specification is open-source and community-driven, with Google contributing the reference implementation. Adoption is growing fastest in enterprise environments where multi-agent orchestration across different vendor platforms is a real need.
// KEY_CONCEPTS
Core Concepts
Agent Card
JSON document at /.well-known/agent.json describing an agent's capabilities, skills, and endpoints. The discovery mechanism.
Client Agent
The agent that initiates a task. It discovers remote agents, sends tasks, and processes results.
Remote Agent
The agent that receives and processes tasks. It serves an Agent Card and handles incoming JSON-RPC requests.
Task
A unit of work sent from client to remote agent. Has a lifecycle: created, in-progress, completed, failed.
Artifact
The deliverable produced by a completed task. Can be text, structured data, files, or other formats.
Streaming
Long-running tasks can stream intermediate updates to the client via Server-Sent Events (SSE).
// ARCHITECTURE
How It Works
Client Agent
Initiates a task. Discovers remote agents via Agent Cards, sends JSON-RPC requests, processes results.
Agent Card
Served at /.well-known/agent.json. Describes capabilities, skills, endpoints, auth requirements.
Remote Agent
Receives tasks, processes them using its own tools and MCP connections, returns artifacts.
Transport
HTTP + JSON-RPC 2.0 for requests/responses. SSE for streaming updates on long-running tasks.
// TRANSPORT_LAYERS
- HTTP with JSON-RPC 2.0
- Server-Sent Events (SSE) for streaming
- Agent Card discovery at /.well-known/agent.json
// USE_CASES
When to Use A2A
Multi-agent orchestration — a coordinator agent delegates subtasks to specialized agents
Agent marketplaces — agents discover and hire each other based on Agent Card capabilities
Cross-framework collaboration — CrewAI agents work with LangChain agents seamlessly
Enterprise workflows — agents from different vendors (Google, Salesforce, SAP) collaborate
Distributed task execution — long-running tasks stream progress updates to the requesting agent
// SUPPORTED_AGENTS
Agents Using A2A
// PROTOCOL_COMPARISON
A2A vs Other Protocols
| Aspect | MCP | A2ACURRENT | ACP |
|---|---|---|---|
| Primary purpose | Agent-to-tool/data | Agent-to-agent collaboration | Agent-to-agent via REST |
| Discovery | Server lists tools/resources at connection | Agent Card at /.well-known/agent.json | OpenAPI spec at agent endpoint |
| Message format | JSON-RPC 2.0 | JSON-RPC 2.0 over HTTP | HTTP REST / JSON |
| Streaming | SSE via Streamable HTTP | SSE for task updates | Polling or webhooks |
| Governance | Anthropic | Google (50+ partners) | Cisco / BeeAI |
| Best for | Connecting agents to tools and data | Multi-agent collaboration across frameworks | Web-native, REST-first agent communication |
// FAQ
Frequently Asked Questions
// WRITTEN_BY
Laurent Yew
Founder
Laurent Yew is the founder of AgentResourceDB, where he leads the platform's vision of building a unified, trust-first discovery layer for the AI agent ecosystem. With over a decade of experience scaling AI and SaaS products, Laurent has dedicated his career to making complex developer infrastructure accessible, transparent, and reliable. He writes about agent registries, protocol interoperability, and the future of agent-to-agent collaboration, drawing from hands-on work building evaluation frameworks that help developers cut through the noise of 100,000+ agents. Through AgentResourceDB, he is committed to establishing the trust standards the industry needs as AI agents move from experimentation to production.
// EXPLORE_MORE
Discover Agents by Category
Browse A2A-compatible agents across 15 categories — from coding and research to security and DevOps.
BROWSE_CATEGORIES