AI Rank
← Open Source
ai-boost

awesome-a2a

Agent2Agent (A2A) – awesome A2A agents, tools, servers & clients, all in one place.

ListsTool collections
Open on GitHub
Momentum
+0stars in 24 hours0.0%
694
Stars
176
Forks
+2
This week
12
Contributors
Created 2025-04-10 · Updated 2026-10-06 · #14601 today
Top developers
ai-boostadcenturyliujuanjuan1984
README

✨ Awesome A2A (Agent2Agent Protocol) ✨

Awesome A2A Banner - Abstract network or connection graphic

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






[Deutsch](https://zdoc.app/de/ai-boost/awesome-a2a) |
[English](https://zdoc.app/en/ai-boost/awesome-a2a) |
[Español](https://zdoc.app/es/ai-boost/awesome-a2a) |
[français](https://zdoc.app/fr/ai-boost/awesome-a2a) |
[日本語](https://zdoc.app/ja/ai-boost/awesome-a2a) |
[한국어](https://zdoc.app/ko/ai-boost/awesome-a2a) |
[Português](https://zdoc.app/pt/ai-boost/awesome-a2a) |
[Русский](https://zdoc.app/ru/ai-boost/awesome-a2a) |
[中文](https://zdoc.app/zh/ai-boost/awesome-a2a)





[![Awesome](https://awesome.re/badge.svg)](https://awesome.re)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/license/MIT)
[![GitHub stars](https://img.shields.io/github/stars/ai-boost/awesome-a2a.svg?style=social&label=Star)](https://github.com/ai-boost/awesome-a2a)
[![GitHub forks](https://img.shields.io/github/forks/ai-boost/awesome-a2a.svg?style=social&label=Fork)](https://github.com/ai-boost/awesome-a2a)

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.

Contents

🤔 What is A2A? (Briefly)

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

💡 Key Principles

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

⚙️ How Does A2A Work? (High Level)

  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.

🚀 Getting Started with A2A

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.

🏛️ Official Resources

📜 Specification & Core Concepts

(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.
  • 🧩 A2A Extensions (Topic) - Official documentation of A2A v1.0's first-class extension mechanism: agents declare extensions in the Agent Card, clients opt in via the A2A-Extensions header, and extensions can add new data, requirements, RPC methods, and task state machines without altering core structures. Official extensions live under https://a2a-protocol.org/extensions/; includes reference examples (timestamp, traceability, secure passport, AGP routing).
  • 🔐 OID4VP In-Task Authorization Extension - Official experimental extension for using OpenID for Verifiable Presentations (OID4VP) to perform Just-In-Time (JIT) in-task authorization, allowing server agents to request verifiable presentations from clients during task execution. Includes a sample implementation and an A2A + OID4VP integration demo.
  • 🔌 SLIMRPC Custom Protocol Binding - Official experimental custom protocol binding for A2A over SLIM (Secure Low-Latency Interactive Messaging), providing a secure, low-latency transport option for agent-to-agent communication.

⚙️ Implementations & Libraries

Official Samples

These demonstrate basic A2A client/server communication.

Language Sample Name One-line Description GitHub URL
🔷 TypeScript Genkit SDK Core TS SDK + CLI, builds shared code for front- and backend https://github.com/a2aproject/a2a-samples/tree/main/samples/js
Movie Recommendation Agent Movie-recommendation conversational agent built with Genkit https://github.com/a2aproject/a2a-samples/tree/main/samples/js/src/agents/movie-agent
TypeScript Client Pure-frontend call example written in TS https://github.com/a2aproject/a2a-samples/tree/main/samples/js/client
Node Express Server A2A HTTP service implemented with Node/Express https://github.com/a2aproject/a2a-samples/tree/main/samples/js/server
☕ Java Custom Client Java client with streaming listener https://github.com/a2aproject/a2a-samples/tree/main/samples/java/custom_java_impl/client
Data Models Complete set of POJO data models https://github.com/a2aproject/a2a-samples/tree/main/samples/java/custom_java_impl/model
Custom Server Spring Boot A2A server implementation https://github.com/a2aproject/a2a-samples/tree/main/samples/java/custom_java_impl/server
Dice Agent (Multi-Transport) Agent supporting multiple transport protocols https://github.com/a2aproject/a2a-samples/tree/main/samples/java/agents/dice_agent_multi_transport
Magic 8-Ball (Security) Security-focused agent with OAuth2 https://github.com/a2aproject/a2a-samples/tree/main/samples/java/agents/magic_8_ball_security
Content Writer Agent Content generation agent https://github.com/a2aproject/a2a-samples/tree/main/samples/java/agents/content_writer
Content Editor Agent Content editing agent https://github.com/a2aproject/a2a-samples/tree/main/samples/java/agents/content_editor
Weather MCP Agent Weather agent with MCP integration https://github.com/a2aproject/a2a-samples/tree/main/samples/java/agents/weather_mcp
💠 .NET Basic A2A Demo Echo and Calculator server examples https://github.com/a2aproject/a2a-samples/tree/main/samples/dotnet/BasicA2ADemo
CLI Demo Command-line client and server demo https://github.com/a2aproject/a2a-samples/tree/main/samples/dotnet/A2ACliDemo
Semantic Kernel Demo Integration with Semantic Kernel https://github.com/a2aproject/a2a-samples/tree/main/samples/dotnet/A2ASemanticKernelDemo
🐍 Python CLI Host Command-line interface for interacting with A2A agents https://github.com/a2aproject/a2a-samples/tree/main/samples/python/hosts/cli
Hello World Recommended first-run "Hello World" scaffold https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/helloworld
LangGraph Agent Uses LangGraph to orchestrate multi-turn dialogue https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/langgraph
CrewAI Agent Demonstrates multi-role collaboration with CrewAI https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/crewai
Semantic Kernel Agent Orchestrates tools with Semantic Kernel https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/semantickernel
AG2 Agent Minimal AG2 mutual-call example https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/ag2
ADK Expense Reimbursement Multi-turn expense reimbursement with forms https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/adk_expense_reimbursement
Birthday Planner (ADK) Multi-step birthday-party planner with ADK https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/birthday_planner_adk
Azure AI Foundry Agent Example using Azure AI Foundry SDK https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/azureaifoundry_sdk
A2A MCP Integration Multi-agent collaboration with MCP servers https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/a2a_mcp
MCP without Framework Bare-metal MCP integration without frameworks https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/a2a-mcp-without-framework
Travel Planner Agent One-stop travel-planning agent https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/travel_planner_agent
Headless OAuth2 OAuth2 flow for headless agents https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/headless_agent_auth
Analytics Workflow Multi-agent orchestration for data-analytics https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/analytics
A2A Telemetry Collects and displays agent telemetry data https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/a2a_telemetry
Multiagent Host Comprehensive multi-agent orchestration example https://github.com/a2aproject/a2a-samples/tree/main/samples/python/hosts/a2a_multiagent_host
GitHub Agent Agent with GitHub toolset integration https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/github-agent
Veo Video Generator Generates video via Veo API https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/veo_video_gen
LlamaIndex File Chat Q&A retrieval over local files https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/llama_index_file_chat
Marvin Agent Builds domain agents with Marvin https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/marvin
MindsDB Agent Calls MindsDB for prediction and querying https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/mindsdb
🐹 Go Go Reference Impl Full A2A server + client implemented in Go https://github.com/a2aproject/a2a-samples/tree/main/samples/go

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.

Framework Integrations (Official Samples)

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 Multi-turn dialogue orchestration Tools, Streaming, Multi-turn Link
🐍 Python CrewAI Multi-role collaboration Non-textual Artifacts (Files) Link
🐍 Python Google ADK Expense reimbursement Multi-turn, Forms (DataPart) Link
🐍 Python Semantic Kernel Tool orchestration Tools, Multi-turn Link
🐍 Python AG2 Mutual agent calls Agent-to-Agent communication Link
🐍 Python Azure AI Foundry Azure AI integration Cloud deployment, Tools Link
🐍 Python LlamaIndex File Q&A retrieval RAG, Document processing Link
🚀 JS/TS Genkit Movie info / Code generation Tools, Artifacts (Files), Async Link
☕ Java Spring Boot Multi-transport agent HTTP/gRPC, Security Link
💠 .NET Semantic Kernel .NET AI integration Tools, .NET ecosystem Link

Community Implementations

SDKs & Libraries (by language)
  • Go
    • 🌟 a2a-go by @a2aproject Stars - 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 Stars - 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 Stars - A Go library for building A2A servers, with example implementations.
    • 🌟 a2a-go by @yeeaiclub Stars - Agent-to-Agent Protocol Implementation for Go, fully supports all methods of the A2A protocol, referring to the official Python SDK implementation.
    • 🌟 agent-sdk-go by @agenticenv Stars - Production-grade Go SDK for durable AI agents built on Temporal workflows. Features first-class A2A server/client, MCP, AG-UI streaming, sub-agents, human-in-the-loop, and OpenTelemetry. Survives crashes and deploys automatically.
  • Rust
    • 🌟 a2a-rs by @a2aproject Stars - 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 Stars - 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 Stars - An idiomatic Rust implementation following hexagonal architecture principles.
    • 🌟 Agentic by @jeremychone Stars - 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 Stars - 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 Stars - 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 Stars - 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 Stars - Official Python SDK for running agentic applications as A2A servers following the Agent2Agent Protocol.
    • 🌟 a2a_min by @pcingola Stars - A minimalistic Python SDK for A2A communication.
    • 🌟 python-a2a by @themanojdesai Stars - An easy-to-use Python library for implementing the A2A protocol.
    • 🌟 fasta2a by @datalayer Stars - Framework-agnostic Python A2A server library that lets developers expose agents through ASGI with pluggable storage, broker, and worker components.
    • 🌟 A2AServer by @johnson7788 Stars - A Python server framework implementing Google's A2A protocol with MCP integration.
    • 🌟 adk-modular-architecture by @k-jarzyna Stars - A Python project demonstrating a modular architecture for ADK (Agent Development Kit) based agents, with A2A protocol considerations.
    • 🌟 codex-a2a by @liujuanjuan1984 Stars - 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 Stars - Full A2A Protocol implementation for OpenCode, providing a stateful A2A service with production-friendly deployment, auth, and session continuity.
    • 🌟 a2a-adapter by @hybroai Stars - 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.
    • 🌟 distributed_a2a by @Barra-Technologies Stars - A Python library for building and orchestrating A2A agents with a registry service, router agent, routing client, and MCP management. MIT licensed and published on PyPI as distributed-a2a.
  • Ruby
    • 🌟 a2a by @wilsonsilva Stars - Ruby gem implementing A2A protocol data structures with serialization, validation, and case transformation support. Published on RubyGems.
    • 🌟 llm.rb by @llmrb Stars - Ruby's most capable AI runtime with A2A support via LLM::A2A, letting agents consume remote A2A agent skills as local tools over REST/JSON-RPC. Licensed under 0BSD.
    • 🌟 agent2agent by @general-intelligence-systems Stars - Full-featured Ruby SDK for A2A with server and client implementations, JSON-RPC 2.0 and HTTP+JSON/REST bindings, SSE streaming, SQLite persistence, push notifications, 47 protocol types, and extensive guides. Built on Falcon + Async for fiber-based concurrency. Published on RubyGems as agent2agent. Apache 2.0.
  • C++
    • 🌟 agent-protocol by @openJiuwen-ai Stars - C++ SDK for the Agent2Agent (A2A) Protocol (and MCP), providing implementations of agent communication protocols for C++ environments.
    • 🌟 a2a-cpp by @MisterVVP Stars - 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.
  • Common Lisp
    • 🌟 mcp-lisp by @jsulmont Stars - Common Lisp SDK for MCP and A2A protocols with server, client, agent, and behavioral spec engine. Implements partial A2A v1.0 support (agent card discovery, messaging, skills, and task lifecycle). Features 438 unit tests, REPL agent with multi-provider LLM support, and agent swarm capabilities. Dual-licensed under MIT OR Apache-2.0.
  • C#/.NET
    • 🌟 a2a-dotnet by @a2aproject Stars - Official C#/.NET SDK for the A2A Protocol.
    • 🌟 a2adotnet by @azixaka Stars - A C#/.NET implementation of the A2A protocol.
    • 🌟 a2a-net by @neuroglia-io Stars - .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 Stars - Official JavaScript SDK for the Agent2Agent (A2A) Protocol.
    • 🌟 a2a-ai-provider by @DracoBlue Stars - Community A2A provider for the Vercel AI SDK, enabling drop-in interoperability with A2A agents via generateText and streamText.
    • 🌟 nestjs-a2a by @thestupd Stars - A module for integrating the A2A protocol into NestJS applications.
    • 🌟 Artinet SDK by @the-artinet-project Stars - TypeScript (Node.js) A2A compliant server/client simplifying interoperable AI agent creation, focusing on DX and production-readiness.
    • 🌟 a2a-mesh by @oaslananka Stars - 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-warp by @oaslananka Stars - Independent TypeScript runtime and toolkit for the A2A protocol, with server/client SDKs, registry, adapters for OpenAI/Anthropic/LangChain/Google ADK/LlamaIndex/CrewAI, CLI, MCP bridge, WebSocket/gRPC transports, and conformance tooling. Published on npm as @oaslananka/a2a-warp. Apache 2.0.
    • 🌟 a2a-reference-ts by @reaatech Stars - 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/*.
    • 🌟 agent-to-agent-ts by @A2A-tools Stars - Practical TypeScript A2A implementation with gRPC-first transport, AgentCard discovery, task lifecycle management, JSON Schema validation, HTTP/WebSocket helpers, and a bundled CLI. Node 22+.
  • PHP
    • 🌟 a2a-php by @andreibesleaga Stars - 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 Stars - Official Java SDK for the Agent2Agent (A2A) Protocol.
    • 🌟 a2a-jakarta by @wildfly-extras Stars - Jakarta EE integration for the A2A Java SDK, implementing A2A Protocol Specification 1.0 on WildFly, Tomcat, Jetty, and OpenLiberty. Apache 2.0.
    • 🌟 a2ajava by @vishalmysore Stars - Java A2A server/client implementation using Spring Boot with annotations. Supports WebSockets, MCP integration, and includes enterprise/Kubernetes deployment tutorials.
    • 🌟 a2a4j by @a2ap Stars - 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 Stars - 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.
    • 🌟 rocketmq-a2a by @apache Stars - Apache RocketMQ transport integration for the A2A Protocol. Provides RocketMQTransport for asynchronous client messaging and RocketMQA2AServerRoutes for Quarkus server-side routing, with samples for Google ADK, AgentScope, and LangGraph. Apache 2.0.
  • Kotlin
    • 🌟 a2a-4k by @a2a-4k Stars - 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 Stars - 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 Stars - 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 Stars - 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.
  • Erlang
    • 🌟 barrel_a2a by @barrel-platform Stars - Erlang/OTP SDK for A2A v1.0: protocol objects with accessor modules, a server exposing agents over both HTTP bindings (HTTP/1.1 + HTTP/2 on one port) with SSE streaming, push notifications, auth hooks, card signing, extensions, and multi-tenancy, plus a client with card discovery/caching, signature verification, and streaming/blocking sends. Validates messages against the official a2a.json JSON Schema with pluggable task storage (in-memory/DETS). Apache 2.0.
  • Dart
    • 🌟 a2a by @shamblett Stars - 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.
  • Ballerina
    • 🌟 module-ballerina-a2a by @ballerina-platform Stars - Official Ballerina library module implementing the A2A v1.0 protocol client over the HTTP+JSON binding. Provides Agent Card discovery, message send, SSE streaming, webhook (push notification) registration, and per-skill authentication against the security schemes an agent declares. Published on Ballerina Central as ballerina/a2a. Apache 2.0.
Frameworks

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

  • 🚀 A2A Lite by @xvierd Stars - The simplest way to build agents for Google's A2A Protocol. A decorator-based, multi-language (Python, TypeScript, Java) wrapper around the official A2A SDKs with built-in LLM integrations, AgentNetwork delegation, CLI tools, and an in-process test client. MIT licensed and published on PyPI/npm/Maven as a2a-lite.
  • 🚀 aixyz by @AgentlyHQ Stars - A Next.js-like framework for bundling AI agents into deployable services with native A2A, MCP, x402 payments, and ERC-8004 identity. Features create-aixyz-app scaffolding, built-in Agent Card and JSON-RPC endpoints, and a CLI for configuration and deployment. MIT licensed and published on npm as aixyz.
  • 🚀 ADK Python by @google Stars - Google's official open-source, code-first Python toolkit for building, evaluating, and deploying sophisticated AI agents. The original ADK implementation, with native A2A protocol support, MCP integration, multi-agent orchestration, graph-based workflows, human-in-the-loop, and seamless Gemini / Vertex AI interoperability. Apache 2.0 and published on PyPI as google-adk.
  • 🚀 ADK Go by @google Stars - Google's official open-source, code-first Go toolkit for building, evaluating, and deploying sophisticated AI agents with native A2A protocol support, MCP integration, multi-agent orchestration, and seamless Vertex AI / Gemini interoperability. Apache 2.0.
  • 🚀 ADK Java by @google Stars - Google's official open-source, code-first Java toolkit for building, evaluating, and deploying sophisticated AI agents. Version 1.0.0 introduces native A2A protocol integration for remote agent-to-agent communication, Google Maps grounding, human-in-the-loop workflows, and robust session management. Apache 2.0.
  • 🚀 ADK Kotlin by @google Stars - Google's official open-source, code-first Kotlin toolkit for building, evaluating, and deploying sophisticated AI agents, with a dedicated a2a module for Agent2Agent protocol support, on-device models via LiteRT-LM, Firebase/ML Kit Android integrations, and published Maven Central artifacts. Apache 2.0.
  • 🚀 AgentUp by @nolabs-ai Stars - 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.
  • 🚀 Agenspy by @SuperagenticAI Stars - A protocol-first AI agent framework built on top of DSPy, designed to create sophisticated, production-ready AI agents with native support for MCP and Agent2Agent protocols. Features comprehensive CLI, Python & JavaScript MCP servers, and automatic connection management. MIT licensed and published on PyPI as agenspy.
  • 🚀 ANT AI by @idea-idsia Stars - 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.
  • 🚀 any-agent by @mozilla-ai Stars - A single interface to use and evaluate different agent frameworks, with first-class A2A serving and multi-agent support. Wraps TinyAgent, Google ADK, LangChain, LlamaIndex, OpenAI Agents, Smolagents, and Agno. Apache 2.0.
  • 🚀 ProtoLink by @nMaroulis Stars - 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 Stars - 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.
  • 🚀 inference-gateway/rust-adk by @inference-gateway Stars - A Rust-based Agent Development Kit for building A2A-compatible agents with full protocol compliance, featuring A2AServer/A2AClient/AgentBuilder APIs, health monitoring, LLM client integration, push notifications, OIDC/OAuth2 auth, TLS/mTLS, and comprehensive task lifecycle management. Published on crates.io as inference-gateway-adk. Apache 2.0.
  • 🚀 Hyperterse by @hyperterse Stars - 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 Stars - 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.
  • 🚀 Agentic Kernel by @Qredence Stars - A flexible foundation AI system for creating A2A-compatible autonomous AI agents that can collaborate, reason, and execute complex tasks. Built on Google's A2A standard and the ADK framework, featuring a modular multi-agent architecture, sophisticated workflow engine, dynamic planning with an Orchestrator Agent, and a Chainlit-based interactive UI. MIT licensed and published on PyPI as agentic-kernel.
  • 🚀 Reactive Agents by @tylerjrbuell Stars - A composable TypeScript AI agent framework with end-to-end Effect-TS type safety, a deterministic 12-phase execution engine, 5 reasoning strategies (ReAct, Reflexion, Plan-Execute, Tree-of-Thought, Adaptive), persistent 4-tier memory, production guardrails, cost routing, and native A2A protocol support (Agent Cards, JSON-RPC 2.0 server/client, SSE streaming). 5,000+ tests, 35 packages. MIT licensed and published on npm as @reactive-agents/*.
  • 🚀 Swarm by @fcn06 Stars - A Rust framework for building and orchestrating intelligent multi-agent systems through open standards (A2A and MCP). Features a Planner Agent that produces static or dynamically generated workflows, an Executor Agent that carries them out with a built-in LLM-as-a-Judge evaluation loop for self-correction, an Agent Factory for programmatic agent instantiation at runtime, specialized Domain Agents, and an MCP Runtime that bridges agents to external tools. Workspace-organized crates built on a2a-rs and rmcp. Apache 2.0.
  • 🚀 LLM Tornado by @lofcz Stars - A .NET provider-agnostic SDK for building, orchestrating, and deploying AI agents and workflows with first-class A2A protocol support via the dedicated LlmTornado.A2A package (AgentCard discovery, message send, SSE streaming, task lifecycle) and a companion LlmTornado.A2A.AgentServer for exposing Tornado agents as A2A servers. Features 30+ built-in LLM/vector DB connectors (OpenAI, Anthropic, Google, Cohere, xAI, Mistral, vLLM, Ollama, etc.), graph-based agent orchestration (Orchestrator/Runner/Advancer with handoffs and parallel execution), MCP integration, Anthropic Skills, multimodal I/O, and Microsoft.Extensions.AI interop. 100,000+ NuGet installs, 500+ tests. MIT licensed (license-stable commitment) and published on NuGet as LlmTornado.*.
  • 🚀 trpc-agent-go by @trpc-group Stars - A powerful Go framework for building intelligent agent systems with first-class A2A interoperability. Features A2A server (one-click exposure of any agent as an A2A service with auto-generated AgentCards), A2AAgent client proxy for calling remote A2A agents, automatic bidirectional message protocol conversion, streaming and non-streaming modes, multi-agent orchestration (chain/parallel/graph-based workflows), persistent memory, prompt caching, and built-in telemetry. Published on pkg.go.dev. Apache 2.0.
  • 🚀 Gocrewwai by @Ecook14 Stars - A high-performance, strictly-typed agentic orchestration framework for Go. Inspired by CrewAI, LangChain, and LangGraph, with native A2A protocol support, durable flow persistence, MCP integration, recursive self-correction, and human-in-the-loop workflows. MIT licensed.
  • 🚀 Covonaut by @covoyage Stars - A production-ready agent framework for Go with zero external dependencies (82k+ lines of pure Go). Its dedicated a2a package exposes any agent as an A2A 1.0 server (Agent Card discovery, all 11 JSON-RPC methods, SSE streaming, push notifications, multimodal parts) and includes a typed client for calling remote A2A agents, with seamless handoff integration into the local multi-agent system. MIT licensed.
  • 🚀 Atmosphere by @Atmosphere Stars - JVM runtime for streaming, governable AI agents with first-class A2A, MCP, and AG-UI protocol support. Declare behavior with @Agent and deliver over WebSocket, SSE, gRPC, and WebTransport/HTTP3. Features runtime adapters for Spring AI, LangChain4j, Google ADK, and Quarkus, plus policy admission, human-in-the-loop approvals, and durable sessions. Apache 2.0.
  • 🚀 Harness by @mastersof-ai Stars - An agent runtime with full system prompt control, defining agents in markdown and running them through a terminal TUI or multi-user web UI. Features bidirectional A2A protocol support — expose agents via auto-generated Agent Cards and call remote A2A agents with built-in discovery and invocation tools. Includes persistent memory, sandboxed execution, sub-agents, and MCP integration. MIT licensed.
  • 🚀 ReachAI (Enterprise Agent Framework) by @w8123 Stars - A developer-first enterprise AI capability framework for Java/Spring Boot. Register business APIs as governed AI capabilities via @AiCapability annotations, orchestrate agents in a visual studio with GraphSpec runtime, and expose them through Gateway, MCP, and A2A protocols with full RunOps and traceability. MIT licensed.
  • 🚀 tinyagent by @mozilla-ai Stars - A minimal Python agent framework with first-class tracing, callbacks, MCP tool support (stdio/SSE/streamable HTTP), and optional A2A/MCP serving. Built on any-llm and extracted from any-agent. Apache 2.0.
  • 🚀 Solace Agent Mesh by @SolaceLabs Stars - An event-driven framework for building and orchestrating multi-agent AI systems, enabling agents to discover and delegate tasks via the A2A protocol over Solace event messaging. Apache 2.0.
  • 🚀 Kagenti ADK by @kagenti Stars - A developer toolkit that turns agents built with any framework into self-hostable, A2A-compliant services. Includes a CLI, Python SDK, TypeScript client SDK, and a runtime with LLM proxy, MCP connectors, vector search, auth, and observability. Apache 2.0.
  • 🚀 orxhestra by @NicolaiLassen Stars - Multi-agent orchestration framework for Python — turn any agent setup into a CLI or server. Compose multi-agent AI systems with async event streaming, agent hierarchies, and built-in support for MCP and A2A protocols (spec-compliant v1.0 server with JSON-RPC 2.0, agent card discovery, streaming, push notifications, and Ed25519 signing). Published on PyPI as orxhestra. Apache 2.0.
  • 🚀 BeeAI Framework by @i-am-bee Stars - Build production-ready multi-agent systems in Python or TypeScript, with a Serve module that exposes agents via A2A and MCP. Apache 2.0.
  • 🚀 ADK Rust by @zavora-ai Stars - A production-ready, model-agnostic Rust Agent Development Kit with native A2A v1.0.0 support (A2aServer::quick_start), 39+ crates, MCP integration, RAG, memory, guardrails, realtime voice agents, and multi-provider LLM support. Apache 2.0 and published on crates.io as adk-rust.
  • 🚀 Microsoft Agent Framework by @microsoft Stars - An open, multi-language framework for building production-grade AI agents and multi-agent workflows in .NET and Python, with first-class A2A hosting and consumption support (AgentCard discovery, SSE streaming, background tasks, A2AAgent/A2ACardResolver), graph-based orchestration, durability, observability, and human-in-the-loop. MIT licensed.
  • 🚀 Microsoft Agent Framework for Go by @microsoft Stars - The Go implementation of Microsoft Agent Framework (MAF) for building production-grade AI agents and multi-agent workflows with first-class A2A protocol support, MCP integration, graph-based orchestration, OpenTelemetry observability, and Microsoft Foundry agents. MIT licensed.
  • 🚀 Agno by @agno-agi Stars - A lightweight library for building agentic AI systems. AgentOS exposes agents, teams, and workflows as A2A-compatible services with A2AClient and RemoteAgent for calling remote A2A agents, and also supports AG-UI. Apache 2.0 and published on PyPI as agno.
  • 🚀 YoMo by @yomorun Stars - Open-source serverless LLM function-calling framework for building scalable, geo-distributed AI agents with A2A protocol support. Apache 2.0.
  • 🚀 fast-agent by @evalstate Stars - A flexible Python framework for building and evaluating LLM agents with first-class A2A protocol support, MCP/ACP integration, agent skills, and an interactive TUI. Apache 2.0 and published on PyPI as fast-agent-mcp.
  • 🚀 Evolver by @EvoMap Stars - A GEP-powered self-evolution engine for AI agents. Turns ad hoc prompt tweaks into auditable Genes and Capsules, with A2A protocol support for connecting to the EvoMap hub to share and sync evolution assets. Published on npm as @evomap/evolver. GPL-3.0.
  • 🚀 Forge by @initializ Stars - An open, secure, portable AI agent runtime for the enterprise. Write a SKILL.md, compile it into a hardened agent, and deploy it anywhere containers run — including as an A2A endpoint with a spec-conformant Agent Card at /.well-known/agent-card.json. Features egress controls, encrypted secrets, Ed25519 build signing, audit logging, MCP client, channel connectors, cron scheduling, and Kubernetes deployment. Apache 2.0.
  • 🚀 Lucid Agents by @daydreamsai Stars - The TypeScript runtime for machine commerce. Turns typed functions into discoverable services that agents and applications can call, pay for, stream, or run as tasks, with a dedicated @lucid-agents/a2a package for Agent Card-shaped discovery, client calls, and token-protected asynchronous tasks. MIT licensed and published on npm as @lucid-agents/*.
Platforms & Integrated Solutions
  • 🌟 AG2 (AutoGen) by @ag2ai Stars - 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).
  • 🌟 AURA by @mezmo Stars - An agentic harness that turns LLM models into reliable, autonomous services for real SRE work. Provides guardrails, API servers, state management, authentication, streaming, error handling, MCP tool integrations, multi-agent orchestration, vector search, and native A2A protocol endpoints for cross-agent interoperability. Apache 2.0.
  • 🌟 Agentlas OS by @agentlas-ai Stars - Local-first Agent OS that keeps specialist agents in a hub and spins up a temporary orchestrator per task, with A2A Agent Card import/export and caller-gated inter-agent boundaries. Apache 2.0.
  • 🌟 Skales by @skalesapp Stars - Private AI desktop agent for Windows, macOS, Linux, Android & iOS. Set a goal and let it work autonomously in the background, with Teams (pair two desktops, agents + humans), Agent2Agent protocol support, Workflows, Codework, multi-agent orgs, desktop + browser automation, and 15+ AI providers. BSL 1.1 licensed.
  • 🌟 Bindu by @GetBindu Stars - Open-source identity, communication, and payments layer for AI agents. Wrap any handler with bindufy() to add DID identity, A2A protocol (message/send, tasks/get, message/stream), mTLS/OAuth2 security, and USDC/x402 payments. Framework-agnostic with Python, TypeScript, and Kotlin SDKs. Apache 2.0.
  • 🌟 Agent Stack by @i-am-bee Stars - Open infrastructure for turning AI agents into running services in minutes. Built on the Agent2Agent (A2A) Protocol so all agents are automatically exposed as A2A-compatible services. Features a self-hostable runtime, 15+ LLM providers, vector storage and RAG, S3-compatible file storage, MCP integrations, secrets management, Web UI, Python SDK, and Helm charts. Apache 2.0, hosted by the Linux Foundation AI & Data program.
  • 🌟 bitterbot-desktop by @Bitterbot-AI Stars - A local-first personal AI with biological memory, a dream engine, and a P2P skills economy. Features native A2A Protocol v1.0.0 support for external agent discovery at /.well-known/agent.json and task delegation via JSON-RPC with SSE streaming. MIT licensed.
  • 🌟 Aser by @AmeNetwork Stars - 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 Stars - 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 Stars - An A2A network implementation for hosting, registering, discovering, and interacting with agents. Includes agent discovery mechanisms.
  • 🌟 Cognisphere by @IhateCreatingUserNames2 Stars - An AI agent development framework built on Google's ADK, facilitating agent creation potentially for A2A networks.
  • 🌐 Grasp by @adcentury Stars - A Self-hosted Browser Using Agent with built-in MCP and A2A support.
  • 🌟 swissknife by @daltonnyx Stars - 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 Stars - Adds nodes to n8n for interacting with AI agents using Google's Agent2Agent (A2A) protocol.
  • 🌟 google-calendar-agent by @inference-gateway Stars - 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 Stars - 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 Stars - 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 Stars - 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 Stars - 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 Stars - 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 Stars - 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 Stars - 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 Stars - 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 Stars - 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 Stars - 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 Stars - 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 Stars - 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 Stars - 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 Stars - 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.
  • 🌟 AgentScope Runtime by @agentscope-ai Stars - Production-grade runtime framework for agent applications with native A2A protocol support — A2A protocol adapter, Nacos-based A2A agent registry, and Agent-as-a-Service (AaaS) deployers that automatically expose A2A endpoints with SSE streaming. Features secure tool sandboxing (Python/Shell/GUI/Browser/Filesystem/Mobile), framework-agnostic adapters (AgentScope, Agno, AutoGen, LangGraph, Microsoft Agent Framework), full-stack observability, and multi-target deployment (local, Kubernetes, Knative, OpenKruise, Function Compute, serverless). Apache 2.0 licensed and published on PyPI as agentscope-runtime.
  • 🌟 Zeph by @bug-ops Stars - Memory-first Rust AI agent runtime for long-running work with a dedicated zeph-a2a crate implementing the A2A protocol (JSON-RPC 2.0, agent discovery via /.well-known/agent.json, SSE streaming, bearer auth, and Invocation-Bound Capability Tokens). Features temporal graph memory, self-learning skills, multi-model cascade routing (Ollama / Claude / Gemini / OpenAI / GGUF / TEE), sub-agents, MCP + ACP integration, sandboxed tools, CLI, and TUI. Published on crates.io as zeph (with zeph-a2a as a feature-gated standalone crate). MIT licensed.
  • 🌟 persona-agent by @memenow Stars - A Python-based API server for creating AI persona agents using Google A2A protocol and Model Context Protocol (MCP) tools integration. Each persona is exposed as an independent A2A ASGI sub-app with discoverable agent cards and a JSON-RPC endpoint, plus a REST API for persona management, file upload, and direct chat. Supports OpenAI-compatible LLMs, YAML/JSON persona definitions, and stdio MCP servers. Apache 2.0 licensed.
  • 🌟 rsclaw by @rsclaw-ai Stars - A Rust AI agent engine with three-layer persistent memory, 15 LLM providers, 13 messaging channels, and full Google A2A protocol v1.0 support (streaming, push notifications, task persistence, cancellation, INPUT_REQUIRED interrupts). Ships as a single ~15MB binary. Dual-licensed MIT/Apache-2.0 and published on crates.io.
  • 🌟 Agent Scrum by @TensorOpsAI Stars - Multi-agent simulation platform where AI agents self-organize on a Kanban board — built with LangGraph, Google A2A, and MCP. Features a full A2A implementation (tasks/send, tasks/get, tasks/cancel, Agent Cards, WebSocket streaming), domain-specific board templates, 14 MCP tools, and both simulation and real LLM modes. MIT licensed.
  • 🌟 AX (Agent eXecutor) by @google Stars - Google's open-source distributed agent runtime with native A2A protocol support. Coordinates agentic loops with durable event-log execution and automatic recovery, integrating A2A agents via multi-transport (gRPC, JSON-RPC, HTTP+JSON REST), AgentCard discovery, and SSE streaming. Apache 2.0.
  • 🌟 Agentic Sandbox by @jmagly Stars - Self-hostable runtime for persistent autonomous coding agents with KVM-isolated VMs (or rootless containers), A2A-protocol executor with signed AgentCard discovery, web dashboard, CLI, and gRPC/WebSocket/HTTP interfaces. Runs on your hardware; no hosted control plane. AGPL-3.0.
  • 🌟 SWE Squad by @ArtemisAI Stars - Autonomous software engineering agent platform with a persistent LLM session, 16 custom tools, and a native A2A protocol implementation for inter-agent communication. Features multi-engine delegation, React WebUI, semantic memory, and 6,800+ tests. MIT licensed.
  • 🌟 NullClaw by @nullclaw Stars - The smallest fully autonomous AI assistant infrastructure written in Zig. One 678 KB static binary with 5,300+ tests, 50+ LLM providers, 19 channels, 35+ tools, and native Google A2A protocol v0.3.0 support (Agent Card discovery, JSON-RPC 2.0 endpoint, SSE streaming, bearer auth). MIT licensed.
  • 🌟 Aloha by @ec-jrc Stars - Aloha (AI Logical Orchestrator Hub for Agents) is a centralized hub to manage and interconnect data, tools and agents leveraging the MCP and A2A protocols. Features out-of-the-box MCP server management with multi-auth strategies, A2A agent registration and streaming task execution, proxy servers with identity propagation, and browser-based agentic loop development. EUPL-1.2 licensed.
  • 🌟 Coworker by @Array-Ventures Stars - Open-source AI agent platform built with Mastra featuring MCP UI, app builder, skills marketplace, A2A protocol support for agent discovery and communication, scheduled tasks, Google Workspace integration, WhatsApp bridge, and multi-provider chat. Self-hostable with Docker and Railway. MIT licensed.
  • 🌟 a2awebagent by @vishalmysore Stars - An A2A agent for AI-driven web automation, test execution, and evidence capture using Selenium. Enables agents to control browsers, validate UI flows, and record structured results through the A2A protocol. MIT licensed.
  • 🌟 SAP Joule A2A Agent Toolkit by @SAP-samples Stars - Build, deploy, and connect AI agents to SAP Joule via the A2A protocol on BTP Cloud Foundry. Supports TypeScript (Express or CAP) and Python agents with LangGraph and SAP GenAI Hub, featuring automated scaffolding, Cloud Foundry deployment, and Joule capability integration. Apache 2.0.
  • 🌟 AgentArea by @agentarea Stars - A cloud-native platform for building agentic networks with governance, isolation, and approval controls. Features VPC-inspired agent isolation, granular tool permissions with approval workflows, event-driven orchestration, MCP server hosting, and A2A protocol support for interoperability with external agent systems. Apache 2.0.
  • 🌟 Evo AI by @evolution-foundation Stars - An open-source platform for creating and managing AI agents with native Google A2A protocol support. Features 7 agent types (including a dedicated A2A Agent), Google ADK and LangGraph integration, MCP server configuration, encrypted API key management, JWT authentication, and a Next.js-based web UI. Built with FastAPI and PostgreSQL. Apache 2.0 licensed.
  • 🌟 OpenAgents by @openagents-org Stars - Open-source multi-agent network platform with native A2A and MCP protocol support. Features a Workspace, Launcher, and Network SDK for building agent networks that can discover, connect, and collaborate across frameworks. Apache 2.0 licensed.
  • 🌟 AI-SNS by @ai-sns Stars - Decentralized social network for AI agents built on the A2A protocol and federated XMPP, featuring real-time 3D visualization on Google Maps, local-first execution, and cross-framework agent collaboration. MIT licensed.
  • 🌟 LangChain Data Agent by @eosho Stars - A natural language to SQL (NL2SQL) platform built on LangGraph and Azure OpenAI, featuring multi-database support, intent-based routing, SQL validation, data visualization, and native A2A protocol interoperability. MIT licensed.
  • 🌟 Agentgateway by @agentgateway Stars - Open-source, Linux Foundation AI gateway/proxy for LLM, MCP, and A2A traffic. Rewrites Agent Cards, proxies A2A tasks, and applies unified auth (JWT/mTLS/OAuth), RBAC, AI guardrails, rate limiting, and OpenTelemetry observability. Deploy standalone, via Docker, or on Kubernetes with Helm. Apache 2.0.
  • 🌟 Echo Agent by @fuyuxiang Stars - A self-hosted, long-running AI agent with cross-session cognitive memory, self-evolving skills, unified multi-channel entry points, and native A2A JSON-RPC/MCP client and server support. MIT licensed.
  • 🌟 MultiGen by @lingyuanli Stars - A general-purpose AI agent system for fully private deployment, featuring Planner + ReAct multi-agent architecture, sandboxed Docker execution, multimodal generation, and native A2A/MCP interoperability. MIT licensed.
  • 🌟 MintHCM by @minthcm Stars - Open-source human capital management (HCM) system rebuilt agent-native for the agentic era: MCP/WebMCP for connecting HR data and processes to any agent, A2A for orchestrating multi-agent workflows across systems, A2UI/AG-UI human-agent collaboration interfaces, and a built-in AI agent ready to use out of the box. Full data ownership, no vendor lock-in. AGPL v3.
  • 🌟 C2S Agent by @C2SAgent Stars - A lightweight AI agent construction platform with configurable online agents, MCP services, and single-port multi-A2A service support. MIT licensed.
  • 🌟 OmniRoute by @diegosouzapw Stars - Free open-source AI gateway that unifies 160+ LLM providers behind one endpoint, with built-in MCP server, smart auto-fallback, token compression, guardrails, and native Google A2A protocol support (6 skills, JSON-RPC 2.0). MIT licensed.
  • 🌟 Busbar by @GetBusbar Stars - Self-hosted execution boundary for AI systems, written in Rust. Sits between applications and the destinations they reach to govern model requests (six native LLM wire protocols), MCP tool calls, and A2A agent delegation — with provider credentials kept at the boundary, virtual keys, group budgets, weighted routing, circuit breaking, failover, mTLS, audit webhooks, and an A2A agent-trust plane (verification, pinning, egress control, target-bound credentials). Apache 2.0.
  • 🌟 OpenFang by @RightNow-AI Stars - Open-source Agent Operating System built in Rust (137K LOC, 14 crates, 1,700+ tests) with autonomous Hands, 53 built-in tools, MCP/A2A bridge, 40 channel adapters, WASM sandbox, knowledge graphs, and a Tauri desktop app. Dual-licensed under MIT/Apache-2.0.
  • 🌟 Proximo by @john-broadway Stars - The Proxmox MCP you can hand the keys — VE + Backup Server + Mail Gateway + Datacenter Manager on one audited trust core (plan · prove · undo · diagnose). Features 352 tools, least-privilege defaults, hash-chained audit ledger, snapshot rollback, and an experimental A2A face. Apache 2.0.
  • 🌟 Agentic MCP Gateway & Registry by @agentic-community Stars - Enterprise-ready unified control plane for MCP servers, AI agents, reusable skills, and custom entities. Features A2A agent discovery, authentication, access control, semantic search, federation, and peer-to-peer agent communication. Apache 2.0.
  • 🌟 Kagenti by @kagenti Stars - A framework-neutral, cloud-native platform for deploying and orchestrating multi-agent AI systems on Kubernetes with native A2A and MCP protocol support, SPIFFE-based zero-trust identity, dynamic AgentCard discovery and verification, and built-in observability. Apache 2.0.
  • 🌟 Agent Kernel by @yaalalabs Stars - The Operating System for scalable, compliant enterprise AI agents. Run, orchestrate, and deploy production agents across frameworks (OpenAI Agents SDK, LangGraph, CrewAI, Google ADK) and clouds with built-in guardrails, observability, channels, and native A2A/MCP support. Apache 2.0 and published on PyPI as agentkernel.
  • 🌟 Noorle - Managed AI agent runtime with built-in A2A protocol support — agents expose Agent Cards and communicate via message/send, message/stream, tasks, and WebSocket transport, with A2A-based discovery and delegation alongside MCP gateways. (A2A reference docs)
  • 🌟 join.cloud by @kushneryk Stars - Join.cloud lets AI agents work together in real-time rooms. Agents join a room, exchange messages, commit files to shared storage, and optionally review each other's work — all through standard protocols (MCP and A2A). GNU Affero General Public License v3.0.
  • 🌟 JoySafeter by @jd-opensource Stars - Enterprise AI-native platform for building, orchestrating, and running security agents at scale. Features visual orchestration of autonomous agent teams, 200+ security tools via MCP, native A2A protocol support, cognitive memory, sandboxed execution, and end-to-end tracing for AI-driven Security Operations (AISecOps). Apache 2.0.
  • 🌟 Janus by @agentium-lab Stars - A2A-native durable agent broker for enterprise agent networks — reliable, secure, auditable agent-to-agent task handoff with policy, budget, routing, and full traceability. Features durable mailboxes, lease recovery, intent routing, A2A/ACP/MCP gateways, and a live capability catalog. Apache 2.0.
  • 🌟 Government Agent Platform (gov_AP) by @lack-jpg Stars - An enterprise-grade multi-agent collaboration and governance platform for government service scenarios ("one-stop handling of a matter"), built on LangGraph + MCP + A2A + RAG + AgentOps. Features an A2A cross-domain coordination layer with HMAC-SHA256-signed callbacks, replay protection, durable task persistence (Postgres task store with checkpoint suspend/resume), agent lifecycle governance and evaluation, a Streamlit operations UI, and full Docker Compose deployment (11 services).
  • 🌟 Octagon A2A Agents by @OctagonAI Stars - A2A interface to Octagon's hosted financial research agents, letting any autonomous agent delegate market intelligence over the Agent2Agent protocol. Exposes two discoverable skills — multi-source research across SEC filings, earnings calls, financials, stock & crypto data, private markets, and news; and Kalshi prediction-market research comparing model probability against live market prices. Serves A2A v1.0 and v0.3 on one URL with streaming, task lifecycle, cancellation, and caller-supplied (caller-billed) credentials. MIT licensed.
  • 🌟 Loom for AWS by @awslabs Stars - An enterprise-grade platform for building, deploying, and operating AI agents on Amazon Bedrock AgentCore Runtime and AWS Strands Agents. Provides a unified management UI with Cognito-based authentication, scope-based authorization, and full lifecycle management for agents, memory stores, MCP servers, and A2A integrations — including registering remote A2A agents by base URL with automatic Agent Card fetching, OAuth2 bearer token injection via AgentCore Identity (m2m and on-behalf-of RFC 8693 delegation), per-persona skill-level access control, SSE streaming and JSON response handling, and AWS Agent Registry governance gating. Apache 2.0.
  • 🌟 SAM (Sovereign Agent Mesh) by @google Stars - Google's open-source zero-trust P2P mesh for autonomous AI agents (Apache 2.0, no vendor telemetry). Lightweight sam-node agents self-organize over libp2p with Ed25519 cryptographic identity, self-healing discovery, cryptographically attested jurisdiction/data-sovereignty label gates, and Helm/Kubernetes deployment. Uses A2A as the mesh's southbound agent-to-agent wire: agents register as type: a2a services reachable through mesh paths, with caller nodes regenerating Agent Cards so stock a2a-sdk clients work unmodified (discovery, message/send, contextId round-tripping) — plus a sam-a2a-bridge MCP server and a bundled chat-a2a example built on the official a2a-go SDK.
  • 🌟 AtOM (Agentic Orchestration & Messaging) by @npci Stars - Open-source, production-grade platform from NPCI (National Payments Corporation of India) for end-to-end specification change management powered by AI agents. Each stage of the lifecycle — deep research, design documents, XSD schemas, partner distribution, code generation against a real repository, and certification — is an AI agent, with an evaluation gate between stages. Partner distribution runs over the A2A protocol with a negotiation loop and per-partner implementation status, and certification drives wire-level test cases through simulators in an A2A conversation with each partner's certification agent. The A2A boundary is protected by eight independent security layers (TLS, JWT, HMAC envelopes, mTLS, CIDR allow-lists, rate limits, audit trail, key lifecycle). FastAPI + React + Postgres/pgvector + Celery, with Docker Compose deployment. MIT licensed.

🛠️ Tools & Utilities

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 Stars - 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 Stars - Community-driven, open-source directory of live, hosted A2A agents with web UI, REST API, Python client, MCP server, and health conformance checking.
    • ⚙️ DNS-AID Core by @dns-aid Stars - DNS-based Agent Identification and Discovery reference implementation (IETF BANDAID draft). Lets agents publish and discover each other via DNS instead of centralized registries, with first-class support for A2A and MCP. Includes CLI and Python SDK, an MCP server, OpenTelemetry integration, and pluggable DNS backends (Route 53, Cloudflare, NS1). Apache 2.0.
    • ⚙️ LAD-A2A by @franzvill Stars - An open protocol for discovering A2A-capable AI agents on local networks — the discovery & trust bootstrap layer beneath A2A. Uses mDNS/DNS-SD, well-known endpoints, signed AgentCards, and DIDs, with explicit user consent before standard A2A communication begins. Apache 2.0.
    • ⚙️ A2ARegistry by @OyadotAI Stars - Centralized registry service for discovering and managing A2A agents, with lexical and semantic search, OAuth 2.0, cross-registry federation, Redis caching, and Docker/Kubernetes deployment. Apache 2.0.
    • ⚙️ A2A Directory by @sing1ee Stars - A curated, multilingual directory of A2A AgentCards, servers, clients, official samples, community implementations, and practical guides (A2A vs MCP, TypeScript/Python getting started, sample methods, etc.). MIT licensed.
    • ⚙️ HOL Registry Broker Skills by @hashgraph-online Stars - AI agent skills for the Universal Agentic Registry. Search live agent inventory, chat with any agent, register your own — consumable by Claude, Codex, Cursor, OpenClaw, and any AI coding assistant. Apache 2.0.
    • ⚙️ Neuronto ARD Index by @neuronto Stars - Federated search index for Agentic Resource Discovery (ARD) — one query fans out across every public ARD registry (reciprocal rank fusion), plus a verified MCP tool index read from each server's own tools/list, hybrid lexical + semantic retrieval, and ARD-Bench. Complements A2A Agent Card discovery with web-scale, spec-aligned search. Apache 2.0; live API at neuronto.com.
  • A2A Validation Tool
    • ⚙️ a2a-inspector by @a2aproject Stars - Official validation tools for A2A agents, including compliance checking and debugging utilities.
    • ⚙️ a2a-tck by @a2aproject Stars - Official Technology Compatibility Kit (TCK) for the A2A Protocol. A pytest-based conformance suite that validates A2A implementations across gRPC, JSON-RPC, and HTTP+JSON transports, with RFC 2119 MUST/SHOULD/MAY level filtering and automated HTML/JSON report generation. Apache 2.0.
    • ⚙️ a2a-itk by @a2aproject Stars - Official Integration Testing Kit (ITK) for verifying cross-SDK compatibility across A2A SDK implementations. Uses graph-based multi-hop traversal across JSON-RPC, gRPC, and HTTP-JSON/REST transports, with standard, streaming, push notification, and task-resubscription verification modes; includes a web dashboard and CI/CD gating support.
    • ⚙️ A2A Validation Tool by @llmx-de Stars - Cross-platform desktop app for testing & validating A2A protocol implementations, with features like multi-agent connection and session management.
    • ⚙️ a2a-compliance by @UltraSkye Stars - 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 Stars - 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.
    • 🔒 sigstore-a2a by @sigstore Stars - Python library and CLI for keyless signing of A2A AgentCards using Sigstore and SLSA provenance attestations. Enables verifiable supply-chain identity for A2A agents via CI/CD OIDC credentials. Apache 2.0.
    • 🔒 foxbook by @cloakmaster Stars - 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 Stars - 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.
    • 🔒 Busbar by @GetBusbar Stars - Self-hosted execution boundary for AI systems (single static Rust binary, sub-100µs hot path) that sits between applications/agents and the models, MCP tools, and A2A agents they call. Verifies, governs, routes, and records every model request, tool call, and agent delegation before it reaches approved destinations — policy enforcement, budgets, credential boundary, resilience, and audit evidence in one enforcement point, with six native model wire protocols (OpenAI, OpenAI Responses, Anthropic, Gemini, Cohere, Bedrock Converse) on both ingress and egress. Apache 2.0.
    • 🔒 AgentScan by @7anX Stars - AI protocol scanner for discovering exposed MCP servers, A2A Agent Cards, and open LLM APIs in one command. Identifies agent cards, skills, unauthenticated JSON-RPC reachability, and private address leaks. MIT licensed.
    • 🔒 A2ASecBench by @SaFo-Lab Stars - Protocol-aware security benchmark for agent-to-agent multi-agent systems, evaluating attacks such as spoofing, cloaking, and request forgery. Includes frozen test cases, pluggable SUTs, local executable environments, and LLM-backed evaluation. From SaFo Lab, accepted at ICLR 2026. MIT licensed.
    • 🔒 AgentHound by @adithyan-ak [![Stars](https://img.shields.io/github/stars/adit