1. Project Overview
A2A (Agent2Agent) is an open, vendor-neutral protocol that lets AI agents built on different frameworks, by different teams and companies, discover each other and communicate directly โ solving the problem that agents built with LangGraph, CrewAI, Semantic Kernel, or any other stack otherwise have no common way to talk to one another.
2. Background & Positioning
As AI agents have proliferated, each framework and vendor has tended to build its own closed way for agents to interact, creating silos: an agent built on one platform generally cannot delegate work to, or receive results from, an agent built on another. A2A was created to break down these silos by giving agents a shared, open protocol for collaboration โ allowing them to exchange information and coordinate on tasks "as agents" (autonomous peers with their own state, memory, and reasoning) rather than being reduced to simple tools invoked through a fixed API.
The project's core mission, as stated in its documentation, is to enable complex, multi-agent collaboration and promote open standards for how agents interoperate. Agents can work together without needing to share internal memory, proprietary logic, or specific tool implementations โ each agent exposes only what it chooses to expose through a standardized "Agent Card," and the rest of its internals stay opaque.
A2A is deliberately complementary to, not competing with, the Model Context Protocol (MCP). MCP standardizes how a single agent connects to tools, data sources, and APIs. A2A standardizes how independent agents discover each other and communicate across organizational and framework boundaries. A system built with both uses MCP to give an individual agent its tools, and A2A to let that agent collaborate with other agents.
The protocol is governed as a Linux Foundation project, with a Technical Steering Committee drawing members from AWS, Cisco, Google, IBM Research, Microsoft, Salesforce, SAP, and ServiceNow, reflecting its intent to be a genuinely cross-industry standard rather than a single vendor's product.
3. Feature Categories
๐ Protocol Specification
The formal definition of A2A's message formats, transports, and behaviors, maintained under /specification in the repository.
- JSON-RPC 2.0 over HTTP(S) as the wire format
- Agent Card schema for capability discovery
- Task lifecycle and state-transition rules
- Streaming and push-notification message formats
- A tiered extension-promotion process for adding new capabilities over time
Purpose: give implementers a single, versioned source of truth so that independent A2A implementations remain interoperable.
๐งฐ Language SDKs
Official client and server libraries so developers don't have to implement the wire protocol by hand.
- Python SDK (
a2a-sdk) - JavaScript/TypeScript SDK (
@a2a-js/sdk) - Go SDK (
a2a-go) - Java SDK
- .NET / C# SDK
- Rust SDK
Purpose: let teams adopt A2A in whatever language their agent stack already uses, without hand-rolling protocol handling.
๐ Documentation & Guides
Conceptual and reference material published at the project's documentation site, covering core concepts, task lifecycle, agent discovery, enterprise features, streaming, and multi-tenancy.
- Getting-started guides per SDK
- Core concepts (Agent Card, Task, Message, Artifact)
- Enterprise-readiness guidance (auth, observability)
- Protocol extension mechanism
Purpose: help both protocol implementers and application developers understand and correctly apply A2A concepts.
๐งช Samples & Reference Implementations
Example agents and client/server pairs maintained in the companion a2a-samples repository, demonstrating real interoperability scenarios across frameworks.
Purpose: give adopters working, runnable reference code instead of starting from the spec alone.
4. Key Highlights
- Standardized agent-to-agent messaging โ communication runs over JSON-RPC 2.0 on HTTP(S), a widely supported, well-understood transport, rather than a bespoke protocol.
- Agent Cards for discovery โ each agent publishes a machine-readable card describing its capabilities, so other agents (or orchestrators) can find and correctly invoke it without out-of-band coordination.
- Multiple interaction modes โ supports simple synchronous request/response, Server-Sent Events (SSE) for streaming long-running responses, and asynchronous push notifications for tasks that outlive a single connection.
- Rich content exchange โ messages can carry plain text, files, and structured JSON payloads, not just chat-style strings.
- Opacity by design โ agents collaborate on tasks without exposing internal memory, tools, or proprietary logic, which matters when the agents involved belong to different organizations.
- Multi-language, multi-vendor governance โ official SDKs span six languages, and the protocol itself is steered by a cross-company Technical Steering Committee under the Linux Foundation, reducing single-vendor lock-in risk.
5. Use Cases by Role
- General developers: build an agent in your framework of choice and expose it via an Agent Card so it can be discovered and called by other agents or orchestration layers, without writing custom integration code per counterpart.
- Platform / integration engineers: use A2A as the interoperability layer between in-house agents and third-party or partner agents, keeping each side's internal implementation private while still enabling delegation of sub-tasks.
- Project managers / technical leads evaluating multi-agent architectures: use A2A's task lifecycle and streaming model to plan how long-running, multi-step agent workflows will be coordinated and monitored across teams or vendors.
6. Getting Started
Find what you need โ start with the protocol documentation site and the specification directory in the repository to understand core concepts (Agent Card, Task, Message) before choosing an SDK:
https://a2a-protocol.org/latest/
Install / integrate โ pick the SDK matching your stack:
pip install a2a-sdk # Python
npm install @a2a-js/sdk # JavaScript / TypeScript
go get github.com/a2aproject/a2a-go # Go
Then explore runnable examples in the companion samples repository:
https://github.com/a2aproject/a2a-samples
Contribute โ file issues, join discussions, or open a pull request against the specification or an SDK, following the project's CONTRIBUTING.md:
https://github.com/a2aproject/A2A/blob/main/CONTRIBUTING.md
7. Project Structure
A2A/
โโโ specification/ # formal A2A protocol specification (source of truth)
โโโ docs/ # documentation site content and guides
โโโ scripts/ # utility and maintenance scripts
โโโ CONTRIBUTING.md # contribution guidelines
โโโ LICENSE # Apache-2.0 license
โโโ README.md
Key directories: specification/ defines the versioned protocol contract that all SDKs and implementations must follow; docs/ powers the public documentation site at a2a-protocol.org. Language SDKs and sample agents are maintained in separate companion repositories (e.g., a2a-python, a2a-js, a2a-samples) under the same a2aproject GitHub organization.
8. Related Ecosystem
- Model Context Protocol (MCP) โ the complementary standard for connecting a single agent to its tools and data sources; A2A and MCP are commonly used together in the same system.
- Agent frameworks โ LangGraph, CrewAI, Semantic Kernel, and similar frameworks are the kinds of systems A2A is designed to let interoperate.
- Linux Foundation โ hosts and governs the project, with a multi-company Technical Steering Committee.
- DeepLearning.AI โ has published an educational course covering the A2A protocol.
a2a-samplesโ companion repository of runnable example agents and clients across supported languages.
9. License
โ
Free to use, modify, and distribute, including in commercial products, under the Apache License 2.0.
โ
Patent grant included, as with all Apache-2.0 licensed projects.
โ
Contributions accepted via GitHub Issues, Discussions, and pull requests.
โ No warranty is provided; the software is distributed "as is."
โน๏ธ Redistributed or modified versions must retain the original copyright, license, and any NOTICE file attributions as required by Apache-2.0.
10. FAQ
Q: How is A2A different from MCP?
A: MCP standardizes how one agent connects to its own tools and data sources. A2A standardizes how independent agents discover and communicate with each other. Many systems use both together.
Q: Do all agents need to be built with the same framework to use A2A?
A: No โ that is the core problem A2A solves. Agents built on different frameworks (LangGraph, CrewAI, Semantic Kernel, custom stacks, etc.) can interoperate as long as each exposes an A2A-compliant Agent Card and endpoint.
Q: What transport does A2A use?
A: JSON-RPC 2.0 over HTTP(S), with support for Server-Sent Events (SSE) for streaming and asynchronous push notifications for long-running tasks.
Q: Which languages have official SDKs?
A: Python, JavaScript/TypeScript, Go, Java, .NET/C#, and Rust.
Q: Where can I see a working example before integrating A2A into my own agent?
A: The a2a-samples repository (https://github.com/a2aproject/a2a-samples) contains runnable reference agents and clients.
11. Quick Links
- Repository: https://github.com/a2aproject/A2A
- Official documentation: https://a2a-protocol.org/latest/
- Contributing guide: https://github.com/a2aproject/A2A/blob/main/CONTRIBUTING.md
- Samples repository: https://github.com/a2aproject/a2a-samples
12. Summary
A2A gives AI agents a common, open language for discovering and collaborating with one another across frameworks, vendors, and organizations, closing a gap that framework-specific tooling cannot address on its own. It is best suited for teams building multi-agent systems that must interoperate with agents they don't control โ internal platform teams, integration engineers, and anyone designing agent architectures that span more than one vendor or stack.