A curated list of awesome resources, implementations, tools, and examples related to the Google Agent2Agent (A2A) Protocol for AI agent interoperability.
- 🤔 What is A2A? (Briefly)
- 💡 Key Principles
- ⚙️ How Does A2A Work? (High Level)
- 🚀 Getting Started with A2A
- 🏛️ Official Resources
- 📜 Specification & Core Concepts
- ⚙️ Implementations & Libraries
- 🛠️ Tools & Utilities
- 📚 Tutorials & Articles
- 🎬 Demos & Examples
- 🔗 Related Protocols & Concepts
- 💬 Community
- Contributing
A2A (Agent2Agent) is an open protocol from Google and partners enabling different AI agents (from various vendors/frameworks) to communicate securely and collaborate on tasks. It aims to break down silos between isolated agent systems, allowing for more complex cross-application automation.
⭐ Official Website: google.github.io/A2A | ⭐ Official GitHub: github.com/google/A2A
- Simple: Uses existing standards (HTTP, JSON-RPC, SSE).
- Enterprise Ready: Focuses on Auth, Security, Privacy, Monitoring.
- Async First: Handles long-running tasks & human-in-the-loop.
- Modality Agnostic: Supports Text, Files, Forms, Streams, etc.
- Opaque Execution: Agents interact without sharing internal logic/tools.
- Discovery: Agents publish an
Agent Card(JSON) describing capabilities, endpoint, and auth needs. - Communication: A
Clientagent sends aTaskrequest (containing aMessagewithParts) to aRemote Agent (Server)using HTTP/JSON-RPC 2.0. - Execution & Response: The Server processes the task, updating its
status. It responds with the final status and any generatedArtifacts(results, also containingParts). - Updates: For long tasks, the Server can optionally stream
TaskStatusUpdateEventorTaskArtifactUpdateEventvia Server-Sent Events (SSE) or use Push Notifications.
For details, see the Official Technical Documentation.
New to A2A? Here's a suggested path:
- Understand the Basics: Read the sections above (What is A2A?, Key Principles, How it Works). Check the 📰 Announcement Blog Post.
- Explore Core Concepts: Dive into the 📖 Official Technical Documentation, focusing on
Agent Card,Task,Message,Part, andArtifact. - See it in Action: Watch the 🎥 Official Demo Video and explore the code for the 🌐 Multi-Agent Web App Demo.
- Run the Samples: Clone the Official Repo and follow the instructions in
/samplesto run a client (like the CLI) and a sample agent (e.g., LangGraph or Genkit agent). See the Official Samples tables below for links. - Review the Code: Look at the
common(Python) orserver/client(JS/TS) libraries in the official samples to see how A2A communication is implemented. - Try Building: Adapt a sample or use a library to create your own basic A2A agent or client.
- 📄 A2A Protocol Website - The main documentation site.
- 💻 google/A2A GitHub Repository - Source code for the spec, docs, and official samples.
- 📰 Google Developers Blog Post - Announcement blog post explaining the motivation and partners.
(See How Does A2A Work? above for summaries)
- 📖 A2A Technical Documentation - (Full Details) Detailed explanation of actors, transport, auth, core objects (Task, Artifact, Message, Part), Agent Card, etc.
- 📄 JSON Specification - The raw JSON schema definition for A2A structures.
- 💡 Key Principles (Docs) - Link to the principles section in the official docs.
- 🃏 Agent Card Specification (Docs) - Link to the Agent Card section in the official docs.
- 🗺️ Agent Discovery (Topic) - Discussion on how clients can find agent cards.
- 🔔 Push Notifications (Topic) - Details on the push notification mechanism.
- 🛡️ Enterprise Readiness (Topic) - Discussion on security, auth, privacy aspects.
These demonstrate basic A2A client/server communication.
| Language | Type | Framework | Description | Link |
|---|---|---|---|---|
| 🐍 Python | Common Library | - | Core HTTP, JSON-RPC, SSE handling | Link |
| 🐍 Python | Host (Client) | CLI | Command-line client example | Link |
| 🐍 Python | Host (Agent) | ADK | Orchestrator agent delegating to A2A agents | Link |
| 🚀 JS/TS | Server Library | Express | Core server implementation | Link |
| 🚀 JS/TS | Client Library | - | Client implementation | Link |
| 🚀 JS/TS | Host (Client) | CLI | Command-line client example | Link |
These show how agents built with specific frameworks can expose an A2A interface.
| Language | Agent Framework | Agent Description | Key A2A Features Demonstrated | Link |
|---|---|---|---|---|
| 🐍 Python | LangGraph | Currency conversion | Tools, Streaming, Multi-turn | Link |
| 🐍 Python | CrewAI | Image generation | Non-textual Artifacts (Files) | Link |
| 🐍 Python | Google ADK | Expense reimbursement | Multi-turn, Forms (DataPart) | Link |
| 🚀 JS/TS | Genkit | Movie info / Code generation | Tools, Artifacts (Files), Async | Link |
- 🌟 Your Framework/Language A2A Server/Client Library? - Add it here! See CONTRIBUTING.md.
- 🔍 Agent Discovery Services - [Link] - Description (e.g., implementation of an 'Agent Catalog').
- ✅ A2A Validation Tool - [Link] - Tool to check compliance of an A2A endpoint.
- 📊 Monitoring/Tracing Adapters - [Link] - Integrations for observability platforms.
- 📄 Official A2A Conceptual Overview (README) - High-level explanation in the official repo's README.
- 🚀 Getting Started Guide (Official README) - Links to docs, spec, samples in the official repo's README.
- ✍️ [Blog Post/Tutorial Title] - [Link] - Description.
- 🌐 Official Multi-Agent Web App (Python/Mesop) - Demonstrates the orchestrator agent interacting with multiple remote agents, rendering text, images, and forms. Requires running Python code.
- 🎥 Official Demo Video (Section Link) - Link to the video embedded in the official repository's README.
- 📦 Model Context Protocol (MCP) - Complementary protocol focused on providing tools/context to agents. (A2A and MCP Discussion).
- 📞 Function Calling / Tool Use Standards - [Link] - Relevant standards (e.g., OpenAI function calling).
- 🐞 google/A2A GitHub Issues - For reporting bugs or suggesting protocol improvements.
- 🔒 Private Feedback Form - Google form for private feedback.
Contributions are welcome! 🙌 Please read the contributing guidelines first. Let's build this list together!