✨ Awesome A2A (Agent2Agent Protocol) ✨

A curated list of awesome resources, implementations, tools, and examples related to the Agent2Agent (A2A) Protocol for AI agent interoperability.

Deutsch | English | Español | français | 日本語 | 한국어 | Português | Русский | 中文

The Agent2Agent (A2A) Protocol is revolutionizing how AI agents communicate and collaborate - enabling seamless interoperability across different frameworks, vendors, and platforms. This repository collects the best resources to help developers build A2A-compatible agents.

• 🤔 What is A2A? (Briefly)
• 💡 Key Principles
• ⚙️ How Does A2A Work? (High Level)
• 🚀 Getting Started with A2A
• 🏛️ Official Resources
• 📜 Specification & Core Concepts
• ⚙️ Implementations & Libraries
  • Official Samples
  • Framework Integrations (Official Samples)
  • Community Implementations
    • SDKs & Libraries (by language)
    • Frameworks
    • Platforms & Integrated Solutions
• 🛠️ 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: a2aproject.github.io/A2A | ⭐ Official GitHub: github.com/a2aproject/A2A | 🌐 Multilingual Docs (EN/ZH/JA): agent2agent.ren

• 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.

1. Discovery: Agents publish an Agent Card (JSON) describing capabilities, endpoint, and auth needs.
2. Communication: A Client agent sends a Task request (containing a Message with Parts) to a Remote Agent (Server) using HTTP/JSON-RPC 2.0.
3. Execution & Response: The Server processes the task, updating its status. It responds with the final status and any generated Artifacts (results, also containing Parts).
4. Updates: For long tasks, the Server can optionally stream TaskStatusUpdateEvent or TaskArtifactUpdateEvent via Server-Sent Events (SSE) or use Push Notifications.

For details, see the Official Technical Documentation.

New to A2A? Here's a suggested path:

1. Understand the Basics: Read the sections above (What is A2A?, Key Principles, How it Works). Check the 📰 Announcement Blog Post.
2. Explore Core Concepts: Dive into the 📖 Official Technical Documentation, focusing on Agent Card, Task, Message, Part, and Artifact.
3. See it in Action: Watch the 🎥 Official Demo Video and explore the code for the 🌐 Multi-Agent Web App Demo.
4. Run the Samples: Clone the Official Samples Repo and follow its instructions to run a client (like the CLI) and a sample agent (e.g., LangGraph or Genkit agent).
5. Review the Code: Look at the common (Python) or server/client (JS/TS) libraries in the official samples to see how A2A communication is implemented.
6. 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.

Quick Start First-time users: try TypeScript Movie Recommendation Agent, Python Hello World, or Go Go Reference Impl — minimal dependencies and the simplest startup commands.

These show how agents built with specific frameworks can expose an A2A interface.

• Go
  • 🌟 a2a-go by @a2aproject - Official Go SDK for the A2A Protocol with high-level server (a2asrv) and client (a2aclient) APIs, multi-transport support (gRPC, REST, JSON-RPC), extensible architecture, and a CLI tool for agent discovery and messaging.
  • 🌟 trpc-a2a-go by @trpc-group - Go A2A implementation by the tRPC team featuring full client/server support, in-memory task management, streaming responses, session management, multiple auth methods (JWT, API Key, OAuth2), and comprehensive examples.
  • 🌟 a2a-go by @a2aserver - A Go library for building A2A servers, with example implementations.
  • 🌟 a2a-go by @yeeaiclub - Agent-to-Agent Protocol Implementation for Go, fully supports all methods of the A2A protocol, referring to the official Python SDK implementation.
• Rust
  • 🌟 a2a-rs by @a2aproject - Official Rust SDK for the A2A Protocol. Workspace-based implementation with core types, async client/server, gRPC/SLIMRPC bindings, SSE streaming, protobuf interop, and a CLI tool.
  • 🌟 ra2a by @qntx - Comprehensive Rust SDK for A2A v1.0 with all 12 JSON-RPC methods, gRPC/SSE streaming, pluggable storage (PostgreSQL/MySQL/SQLite), OAuth 2.0/mTLS security, OpenTelemetry tracing, and composable Axum handlers.
  • 🌟 a2a-rs by @EmilLindfors - An idiomatic Rust implementation following hexagonal architecture principles.
  • 🌟 Agentic by @jeremychone - A Rust crate providing essential building blocks for agentic applications, with an ergonomic API for MCP and A2A support. (Work in Progress)
  • 🌟 jamjet-a2a by @jamjet-labs - Standalone Rust SDK for A2A v1.0 with client, server, coordinator routing, and MCP bridge. TCK conformant (75/76 mandatory). Two crates: jamjet-a2a-types (pure types, zero I/O) + jamjet-a2a (full SDK with feature flags).
  • 🌟 a2a-rust by @tomtom215 - Pure Rust SDK for A2A v1.0 with quad transport (JSON-RPC/REST/WebSocket/gRPC), SSE streaming, agent card signing (JWS/ES256), pluggable stores (SQLite/PostgreSQL), multi-tenancy, and TCK conformance. Published on crates.io as a2a-protocol-sdk.
  • 🌟 awaken by @awakenworks - A Rust agent runtime that serves AI SDK, CopilotKit, A2A, and MCP from the same backend, featuring type-safe state, streaming LLM failure recovery, and plugin extensibility. Published on crates.io.
  • 🌟 turul-a2a by @aussierobots - Proto-first Rust SDK for A2A v1.0 with ergonomic server/client crates, pluggable storage (SQLite/PostgreSQL/DynamoDB), multi-transport support (HTTP/JSON-RPC/SSE/gRPC/AWS Lambda), JWT/API-key auth, and interoperability-tested against the official Go SDK. Published on crates.io.
• Python
  • 🌟 a2a-python by @a2aproject - Official Python SDK for running agentic applications as A2A servers following the Agent2Agent Protocol.
  • 🌟 a2a_min by @pcingola - A minimalistic Python SDK for A2A communication.
  • 🌟 python-a2a by @themanojdesai - An easy-to-use Python library for implementing the A2A protocol.
  • 🌟 fasta2a by @pydantic - Framework-agnostic Python A2A server library that lets developers expose agents through ASGI with pluggable storage, broker, and worker components.
  • 🌟 A2AServer by @johnson7788 - A Python server framework implementing Google's A2A protocol with MCP integration.
  • 🌟 adk-modular-architecture by @k-jarzyna - A Python project demonstrating a modular architecture for ADK (Agent Development Kit) based agents, with A2A protocol considerations.
  • 🌟 codex-a2a by @liujuanjuan1984 - Full A2A Protocol implementation for Codex CLI, providing a stateful, production-oriented agent service with standardized transport and lifecycle mapping.
  • 🌟 opencode-a2a by @Intelligent-Internet - Full A2A Protocol implementation for OpenCode, providing a stateful A2A service with production-friendly deployment, auth, and session continuity.
  • 🌟 a2a-adapter by @hybroai - Python SDK that converts agents from n8n, LangGraph, CrewAI, LangChain, Claude Code, Codex, Ollama, and more into A2A-compatible servers with auto-generated AgentCards and streaming support. Published on PyPI.
• Ruby
  • 🌟 a2a by @wilsonsilva - Ruby gem implementing A2A protocol data structures with serialization, validation, and case transformation support. Published on RubyGems.
• C++
  • 🌟 agent-protocol by @openJiuwen-ai - C++ SDK for the Agent2Agent (A2A) Protocol (and MCP), providing implementations of agent communication protocols for C++ environments.
  • 🌟 a2a-cpp by @MisterVVP - C++20 SDK for the Agent2Agent (A2A) Protocol with client/server APIs, discovery, REST/JSON-RPC/gRPC transports, streaming, authentication hooks, and CMake/vcpkg/Conan build integration.
• C#/.NET
  • 🌟 a2a-dotnet by @a2aproject - Official C#/.NET SDK for the A2A Protocol.
  • 🌟 a2adotnet by @azixaka - A C#/.NET implementation of the A2A protocol.
  • 🌟 a2a-net by @neuroglia-io - .NET implementation of the Agent2Agent (A2A) protocol to enable secure, interoperable communication between autonomous agents across frameworks and vendors.
• JavaScript/TypeScript
  • 🌟 a2a-js by @a2aproject - Official JavaScript SDK for the Agent2Agent (A2A) Protocol.
  • 🌟 a2a-ai-provider by @DracoBlue - Community A2A provider for the Vercel AI SDK, enabling drop-in interoperability with A2A agents via generateText and streamText.
  • 🌟 nestjs-a2a by @thestupd - A module for integrating the A2A protocol into NestJS applications.
  • 🌟 Artinet SDK by @the-artinet-project - TypeScript (Node.js) A2A compliant server/client simplifying interoperable AI agent creation, focusing on DX and production-readiness.
  • 🌟 a2a-mesh by @oaslananka - Production-ready TypeScript runtime for Google's A2A Protocol with multi-framework adapters, registry control plane, JWT/API-key auth, OpenTelemetry observability, CLI scaffolding, and testing toolkit. Published on npm.
  • 🌟 a2a-reference-ts by @reaatech - Production-ready TypeScript reference implementation of Google's A2A protocol with server framework (Express/Hono adapters), client SDK, bidirectional A2A ↔ MCP bridge, canonical Zod schemas, pluggable auth (OAuth2/JWT/API key), Redis/Postgres persistence, SSE streaming, and OpenTelemetry observability. Published on npm as @reaatech/*.
• PHP
  • 🌟 a2a-php by @andreibesleaga - PHP implementation of the A2A Protocol with a fully compliant reference server, strict JSON-RPC validation, task management, SSE streaming, push notifications, and 100% official TCK pass rate.
• Java
  • 🌟 a2a-java by @a2aproject - Official Java SDK for the Agent2Agent (A2A) Protocol.
  • 🌟 a2ajava by @vishalmysore - Java A2A server/client implementation using Spring Boot with annotations. Supports WebSockets, MCP integration, and includes enterprise/Kubernetes deployment tutorials.
  • 🌟 a2a4j by @a2ap - A2A4J is a comprehensive Java implementation of the Agent2Agent Protocol, including server, client, examples, and a starter — ready to use out of the box.
  • 🌟 spring-ai-a2a by @spring-ai-community - Spring Boot and Spring AI integration for building AI agent servers using the A2A Protocol. Features auto-configuration, full @Tool support, and multi-agent orchestration examples.
• Kotlin
  • 🌟 a2a-4k by @a2a-4k - Kotlin implementation of the A2A protocol with client/server modules, Ktor-based server support, Redis-backed task storage, streaming support, and examples for Arc and LangChain4j integrations.
• Swift
  • 🌟 a2a-swift by @Victory-Apps - A Swift SDK for A2A with full v1.0 data model, JSON-RPC routing, SSE streaming with reconnection, Vapor integration, and testing utilities. Supports macOS, Linux, iOS, tvOS, watchOS.
• Elixir
  • 🌟 a2a-elixir by @actioncard - Elixir implementation of the A2A protocol with behaviour-based GenServer agents, multi-turn conversations, SSE streaming, HTTP serving via Plug, skill-based agent registry, pluggable storage, and Telemetry integration.
  • 🌟 a2a_ex by @lukaszsamson - Elixir client and server library for A2A with REST/JSON-RPC transports, SSE streaming utilities, Plug integration, typed structs, task store abstractions, and protocol compatibility modes.
• Dart
  • 🌟 a2a by @shamblett - Dart/Flutter SDK for the A2A protocol, modelled after the official a2a-js SDK. Provides an A2AClient with JSON-RPC, SSE streaming, push notification configuration, agent card retrieval, plus a CLI client and server-side support. Published on pub.dev as a2a by verified publisher darticulate.com; runs on Android, iOS, Linux, macOS, and Windows.

Developer-first frameworks specifically designed for building A2A-compliant agents.

• 🚀 AgentUp by @always-further - A developer-first, open-source AI agent framework designed to make agents portable, scalable, and secure. Features configuration-driven architecture, built-in OAuth2/JWT/API key authentication, automatic A2A discovery, asynchronous task management, and support for both A2A and MCP protocols.
• 🚀 ANT AI by @idea-idsia - A lightweight Python framework from IDSIA for building tool-driven AI agents and multi-agent systems with first-class A2A protocol support (dedicated a2a module with client, server, executor, session, and translator). Features graph-based workflow orchestration, MCP tool integration, lifecycle hooks for guardrails, LLM-agnostic core, and built-in observability via Langfuse. MIT licensed and published on PyPI as ant-ai.
• 🚀 ProtoLink by @nMaroulis - A lightweight Python framework that implements and extends Google's A2A specification at the wire level, providing a unified agent runtime with built-in client/server, swappable transports (HTTP/WebSocket/gRPC/in-memory), native LLM and MCP tool integration, OAuth2/API-key auth, structured deterministic flows (Pipeline/Parallel/Router/Graph), and Langfuse/LangSmith telemetry. MIT licensed and published on PyPI as protolink.
• 🚀 inference-gateway/adk by @inference-gateway - A Go-based Agent Development Kit for building A2A-compatible agents with full protocol compliance, multi-LLM provider support (OpenAI, Ollama, Groq, Cohere), real-time streaming, OIDC/OAuth2 auth, push notifications, lifecycle callbacks for guardrails/caching/logging, file artifacts with filesystem and MinIO backends, task pausing and resumption, pluggable storage (in-memory/Redis), TLS, OpenTelemetry observability, and 14+ working examples. MIT licensed.
• 🚀 Hyperterse by @hyperterse - A Go agentic server framework that ships declarative A2A agents (built on the official a2aproject/a2a-go SDK with per-agent JSON-RPC endpoints at /agent/{name}, agent cards, messaging, tasks, and streaming) alongside a full MCP server (tools/resources/prompts/completion to MCP spec 2025-11-25) from a single config-driven runtime. Features filesystem-based tool/agent/prompt discovery, database adapters (PostgreSQL/MySQL/SQLite/libSQL/MongoDB/Redis) exposed as typed MCP tools, optional TypeScript handlers for custom logic, multi-LLM providers (OpenAI-compatible + Gemini/Vertex), per-tool API-key auth plugins, in-memory caching, and OpenTelemetry tracing/metrics. Apache 2.0.
• 🚀 Mangaba AI by @Mangaba-ai - A professional Python multi-agent orchestration framework with native A2A and MCP protocol support, ReAct reasoning, function calling, RAG, persistent memory, advanced vector stores, and resilient multi-provider LLM interoperability. MIT licensed and published on PyPI as mangaba.

• 🌟 AG2 (AutoGen) by @ag2ai - Open-source multi-agent framework with native A2A protocol support. Features A2aAgentServer for exposing AG2 agents as A2A services and A2aRemoteAgent for connecting to any A2A-compatible agent. Enables cross-framework interoperability (e.g., with Pydantic AI).
• 🌟 Aser by @AmeNetwork - A lightweight, modular Python AI agent framework with first-class Google A2A protocol support (server/client examples built on the official a2a-sdk), plus MCP, memory, RAG, and multi-agent orchestration. MIT licensed and published on PyPI as aser.
• 🌟 Elkar by @elkar-ai - An open-source task-management layer for AI agents — based on Google's Agent2Agent Protocol (A2A). Send, track, and orchestrate tasks across AI agents — effortlessly.
• 🌟 Aira by @IhateCreatingUserNames2 - An A2A network implementation for hosting, registering, discovering, and interacting with agents. Includes agent discovery mechanisms.
• 🌟 Cognisphere by @IhateCreatingUserNames2 - An AI agent development framework built on Google's ADK, facilitating agent creation potentially for A2A networks.
• 🌐 Grasp by @adcentury - A Self-hosted Browser Using Agent with built-in MCP and A2A support.
• 🌟 swissknife by @daltonnyx - A multi-agent chat application with MCP support, aiming to expose agents via the A2A protocol and connect to remote A2A agents as a client.
• 🌟 n8n-nodes-agent2agent by @pjawz - Adds nodes to n8n for interacting with AI agents using Google's Agent2Agent (A2A) protocol.
• 🌟 google-calendar-agent by @inference-gateway - A standalone A2A agent that can manage a user's Google Calendar, compatible with any OpenAI-compatible API for its LLM.
• 🌟 google-maps-a2a by @pab1it0 - An open-source A2A-compliant server that provides Google Maps capabilities — geocoding, reverse geocoding, directions, places search, and distance matrix — to other agents via the standardized protocol.
• 🌟 A2AApp by @tanaikech - An Agent2Agent (A2A) network built with Google Apps Script, enabling secure, decentralized AI communication and integration within Google Workspace as both an A2A server and client.
• 🌟 AgentAnycast by @AgentAnycast - A decentralized P2P runtime for the A2A protocol, powered by libp2p. Features end-to-end encryption (Noise_XX), automatic NAT traversal, skill-based anycast routing, MCP tool bridging, and framework adapters (CrewAI, LangGraph). Zero-config — agents communicate across any network without public IPs or VPNs. SDKs for Python and TypeScript.
• 🌟 a2a-client-hub by @liujuanjuan1984 - A self-hosted A2A client hub for teams and individuals to manage, invoke, and operate multiple A2A agents across web and mobile with unified session history and governance.
• 🌟 routa by @phodal - Workspace-first multi-agent coordination platform for AI development, with shared Specs, Kanban orchestration, and MCP/ACP/A2A support across web and desktop.
• 🌟 hermes-a2a by @iamagenius00 - A2A protocol plugin for Hermes Agent enabling peer-to-peer agent communication with instant wake, session injection, and persistent conversation storage.
• 🌟 OpenClaw A2A Gateway by @win4r - Production-ready OpenClaw plugin implementing the A2A protocol with bidirectional agent communication, adaptive bio-inspired routing, auto-discovery (DNS-SD/mDNS), and resilient multi-transport support (JSON-RPC, REST, gRPC).
• 🌟 UnifAI by @redhat-community-ai-tools - Production-grade multi-agent orchestration engine with A2A and MCP protocol support. Features a pluggable catalog of Agents, LLMs, tools, and retrievers, built-in RAG pipeline for enterprise knowledge retrieval, and a visual drag-and-drop blueprint builder. Execute locally with LangGraph or distributed with Temporal.
• 🌟 Hector by @verikod - An A2A-Native AI Agent Platform written in Go. One self-contained binary, one YAML config, production-ready defaults. Deploy on-premise, in air-gapped environments, or in any cloud with zero external dependencies and zero telemetry. A2A v0.3.0 compliant.
• 🌟 E.D.D.I by @labsai - Production-grade, config-driven multi-agent orchestration middleware for conversational AI (Java/Quarkus). Features native A2A and MCP protocol support, 12+ LLM providers, RAG, persistent memory, and enterprise compliance. Ships as a Red Hat-certified Docker image.
• 🌟 TrainPPTAgent by @johnson7788 - Template-based PPT generation system powered by A2A, ADK, and MCP. Features a Vue.js frontend, Python FastAPI backend, and GRPO reinforcement learning for optimized content generation.
• 🌟 ContextForge by @IBM - Open-source AI Gateway, registry, and proxy that federates MCP, A2A, and REST/gRPC services into a unified endpoint with centralized discovery, governance, and observability. Includes a dedicated Agent Gateway routing A2A protocol traffic alongside OpenAI/Anthropic agents, plus JWT/SSO/RBAC auth, OpenTelemetry tracing, plugin extensibility, sample A2A agents, and Helm/Kubernetes deployment. Apache 2.0, published on PyPI as mcp-contextforge-gateway and as a container on GHCR.
• 🌟 RustyHand by @ginkida - Open-source Agent OS in Rust (124K LOC, 1,577 tests, zero clippy warnings). One ~32MB binary with autonomous agents, 61 built-in tools, 26 LLM providers, 37 channel adapters (Telegram/Discord/Slack...), MCP server, and A2A protocol endpoints for cross-instance agent communication.
• 🌟 ISEK by @isekOS - Decentralized agent-to-agent network framework for cooperative AI societies, combining Google's A2A protocol with ERC-8004 smart contracts for on-chain agent identity, reputation, and trust. Provides local agent hosting, P2P relay via libp2p for NAT-traversed peer connections, an Agent Explorer for discovery, and a sample multi-agent ChatApp. Published on PyPI as isek and MIT licensed.

This section aims to list standalone tools and utilities related to the A2A protocol. The ecosystem is still developing, and community contributions are welcome!

• Agent Discovery Services
  • Some platform-level implementations (like Aira) include agent registration and discovery mechanisms within their features.
  • ⚙️ A2A Agent Registry on AWS by @awslabs - Scalable serverless agent registry for A2A protocol AgentCards with semantic search (Amazon Bedrock, S3 Vectors), Python SDK, and React Web UI.
  • ⚙️ A2A Registry by @prassanna-ravishankar - Community-driven, open-source directory of live, hosted A2A agents with web UI, REST API, Python client, MCP server, and health conformance checking.
• A2A Validation Tool
  • ⚙️ a2a-inspector by @a2aproject - Official validation tools for A2A agents, including compliance checking and debugging utilities.
  • ⚙️ A2A Validation Tool by @llmx-de - Cross-platform desktop app for testing & validating A2A protocol implementations, with features like multi-agent connection and session management.
  • ⚙️ a2a-compliance by @UltraSkye - Automated compliance test kit + security audit for A2A endpoints (operator-side companion to the official a2a-tck). Validates agent cards, JSON-RPC 2.0 envelope, and the A2A method surface for both v0.3 and v1.0; runs SSRF / HTTPS / CORS / DNS-rebinding probes; emits JSON, JUnit, SARIF, and SVG-badge reports with snapshot regression gating. Ships as a pnpm monorepo (@a2a-compliance/cli, core, schemas, mcp server, Next.js dashboard) plus a GitHub Action, cosign-signed multi-arch container images (SBOM + SLSA provenance), Homebrew formula, and OpenTelemetry instrumentation. MIT licensed.
  • Community contributions welcome: Online or command-line validators for checking if Agent Card, Task/Artifact structures comply with A2A JSON Schema specifications, or IDE plugins, etc.
• Security
  • 🔒 a2a-scanner by @cisco-ai-defense - Security scanner for A2A agents combining YARA rules, spec validation, heuristic analysis, and LLM-powered detection. Provides CLI and REST API for CI/CD integration.
  • 🔒 foxbook by @cloakmaster - Verifiable agent identity for A2A and MCP. Cryptographic claims, append-only transparency log (RFC 9162), recovery-key revocation, and cross-language test vectors. Apache 2.0.
  • 🔒 a2a-governance by @ravyg - Runtime governance middleware for A2A agents in Go. Plugs into the official a2a-go SDK via interceptors with zero agent-code changes — adds a circuit-breaker state machine and seven built-in policies (value threshold, cumulative spend, velocity, anomaly detection, vendor trust, authority scope, time-based) plus pluggable state storage, human-escalation hooks, and AP2 risk-payload integration for payment mandates. Apache 2.0.
• Payments / Protocol Extensions
  • 💸 a2a-x402 by @google-agentic-commerce - Official A2A extension that brings cryptocurrency / HTTP 402-style payments to the Agent2Agent protocol, enabling agents to monetize their services through on-chain payments. Includes the v0.1 spec, Python (x402_a2a) and TypeScript libraries, partner-contributed schemes, and end-to-end examples. Apache 2.0.
• Monitoring/Tracing Adapters
  • Community contributions welcome: Adapters or libraries for integrating A2A task flow data into mainstream monitoring platforms like OpenTelemetry, Prometheus, Grafana, etc.
• Other Utilities
  • Community contributions welcome: e.g., A2A message construction helper tools, Agent Card generators, Mock A2A Server/Client, etc.
  • 🌟 autoa2a by NapthaAI - Easily convert agents and orchestrators from existing agent frameworks to A2A servers.
  • ⚙️ a2a-wrapper by @shashikanth-gs - TypeScript monorepo of A2A protocol wrappers that turn production AI backends (GitHub Copilot SDK, OpenCode, and more) into standalone, interoperable A2A agents. Drop a JSON config, get a spec-compliant A2A server with auto-generated AgentCards and session management.
  • ⚙️ Agentify by @koriyoshi2041 - CLI tool that transforms OpenAPI specs into 9 agent interface formats including A2A Agent Cards, MCP servers, AGENTS.md, CLAUDE.md, and more. (npx agentify-cli transform <openapi-spec>)
  • ⚙️ Handler by @alDuncanson - A2A Protocol client and developer toolkit featuring an interactive TUI, CLI commands, MCP server integration, agent card inspection, and a bundled reference agent.
  • ⚙️ a2a-editor by @open-resource-discovery - UI components for editing, viewing, and testing A2A agent cards and interactions, with installable packages and self-hosted local or Docker usage.
  • ⚙️ A2A MCP Server by @GongRzhe - Bridge server connecting MCP-compatible AI assistants (like Claude) with A2A agents, enabling seamless cross-protocol discovery, registration, and task management. Supports stdio, streamable-http, and SSE transports.
  • ⚙️ AI-Mocks by @mokksy - Kotlin/JVM mock-server toolkit (built on Ktor) for testing A2A integrations. Ships a dedicated ai-mocks-a2a module with a MockAgentServer, full A2A protocol coverage (11 endpoints), real Server-Sent Events streaming, plus shared mocks for OpenAI/Anthropic/Gemini/Ollama — useful for service virtualization, contract tests, and offline development. MIT licensed and published on Maven Central.
  • ⚙️ a2a-ui by @a2anet - A general-purpose web UI for the Agent2Agent (A2A) Protocol built with React, Next.js, and Material UI on top of the official a2a-js SDK. Add any A2A-compatible agent by URL, fetch its AgentCard, run multi-turn chat sessions with Context and Tasks, render markdown-supported Messages/Artifacts, and visualize streaming responses and tool-call traces — effectively an early "web browser" for A2A agents. Apache 2.0.

• 📄 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.
• 🌐 Agent2Agent Protocol Documentation Site - Community-driven, open-source documentation site for the A2A protocol. Built with React/TypeScript, supports English, Chinese, and Japanese. (Source Code)
• 📄 A Survey of AI Agent Protocols - Academic paper surveying existing LLM agent communication protocols (including the category A2A falls into), classifying them, analyzing performance, and discussing future challenges.
• 📚 A2A and MCP Tutorial by @Tsadoq - A tutorial on how to use Model Context Protocol by Anthropic and Agent2Agent Protocol by Google.
• 📚 AI Agent Protocols Deep Dive by @glaforge - A code-driven deep dive by Guillaume Laforge (Groovy creator, Google Developer Advocate) exploring the agent protocols and Java frameworks essential for LLM-based agents — practical walkthroughs and demos covering MCP, A2A, ACP, ADK, Arc, Quarkus, and LangChain4j, with a focus on interoperability. Apache 2.0.

• 🌐 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.
• 💻 Agent2Agent (A2A) Samples by @a2aproject - Official repository containing code samples and demos which use the Agent2Agent (A2A) Protocol.

• 📦 Model Context Protocol (MCP) - Complementary protocol focused on providing tools/context to agents. (A2A and MCP Discussion).
• 🔍 Lingua Universale by @rafapra3008 - Formal verification DSL for AI agent protocols using multiparty session types. Complementary to A2A: verify message sequence correctness at spec time..
• 📞 Function Calling / Tool Use Standards - Community contributions welcome: Discussion on patterns, best practices, or relevant standards for function calling/tool use in conjunction with A2A.

• 🐞 A2A GitHub Issues - For reporting bugs or suggesting protocol improvements.
• 💬 A2A GitHub Discussions - For general questions, ideas, and community discussions about the A2A protocol.
• 🔒 Private Feedback Form - Google form for private feedback.

Let's Make Awesome A2A More Useful, Together!

A2A is still pretty new, and good resources or practical tips can be scattered. We created this list to bring the good stuff together, making it easier for everyone to find, learn, and reference.

Keeping this list high-quality and up-to-date relies on the community:

• ⭐ Star it: If you find it useful, it's a great way to show support and makes it easy to find later.
• ➕ Share what you find: Found a great library, article, tool, or even a common pitfall? Add it via an Issue or PR – let's build this resource together.
• 📣 Spread the word: Let others know about this list if they're exploring or working with A2A.

Thanks for your interest and contributions!

Contributions are welcome! 🙌 Please read the contributing guidelines first. Let's build this list together!