awesome-a2a
Agent2Agent (A2A) – awesome A2A agents, tools, servers & clients, all in one place.
https://github.com/ai-boost/awesome-a2a
Last synced: 3 days ago
JSON representation
-
💬 Community
- google/A2A GitHub Issues - For reporting bugs or suggesting protocol improvements.
- Private Feedback Form - Google form for private feedback.
- google/A2A GitHub Discussions - For general questions, ideas, and community discussions about the A2A protocol.
- google/A2A GitHub Issues - For reporting bugs or suggesting protocol improvements.
- google/A2A GitHub Discussions - For general questions, ideas, and community discussions about the A2A protocol.
- google/A2A GitHub Discussions - For general questions, ideas, and community discussions about the A2A protocol.
- A2A GitHub Issues - For reporting bugs or suggesting protocol improvements.
-
🎬 Demos & Examples
- Official Demo Video (Section Link) - Link to the video embedded in the official repository's README.
- 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.**
- Agent2Agent (A2A) Samples - a2a](https://github.com/google-a2a) [](https://github.com/google-a2a/a2a-samples) - Official repository containing code samples and demos which use the Agent2Agent (A2A) Protocol.
- 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.**
- Agent2Agent (A2A) Samples - samples?style=social)](https://github.com/a2aproject/a2a-samples) - Official repository containing code samples and demos which use the Agent2Agent (A2A) Protocol.
- Official Demo Video (Section Link) - Link to the video embedded in the official repository's README.
- 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.**
- Agentic Frameworks on AWS - samples](https://github.com/aws-samples) [](https://github.com/aws-samples/sample-agentic-frameworks-on-aws) - Examples and reference architectures for building autonomous agents using popular frameworks on AWS, including an end-to-end serverless multi-agent system using the A2A Protocol. MIT-0.
- CoffeeShop Agent - agent?style=social)](https://github.com/thangchung/coffeeshop-agent) - A .NET Aspire demo application showcasing the Microsoft Agent Framework, MCP, A2A (via the official `a2a-dotnet` SDK), and AG-UI protocols in a multi-agent coffee shop simulation.
- Agentic Apps - apps?style=social)](https://github.com/agntcy/agentic-apps) - Collection of experimental and reference agent applications built on the A2A protocol and SDK, including multi-agent tourist scheduling, a network of assistants, AI-powered observability root-cause analysis, and multicluster remediation demos. Apache 2.0.
- A2A Mastra Demo - A demonstration of Agent-to-Agent (A2A) communication using the Mastra framework and Amazon Bedrock, featuring a hybrid Express gateway plus Mastra Dev Server architecture, workflow orchestration, real-time visualization, MCP integration, and Docker Compose deployment. MIT licensed.
- Strands Agent with AgentCore - samples](https://github.com/aws-samples) [](https://github.com/aws-samples/sample-strands-agent-with-agentcore) - Reference architecture for agentic AI chatbots with Strands Agents and Amazon Bedrock AgentCore, featuring multi-agent orchestration, MCP tools, A2A delegation to remote worker agents, and multimodal/voice interaction. MIT licensed.
-
🚀 Getting Started with A2A
- Official Demo Video - Agent Web App Demo](https://github.com/a2aproject/A2A/tree/v0.2.1/demo).
-
⚙️ Implementations & Libraries
- Link
- Link
- Link
- Link
- Link
- Link
- Link
- Link
- Link
- Link
- trpc-a2a-go - group](https://github.com/trpc-group) [](https://github.com/trpc-group/trpc-a2a-go) - 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 - go?style=social)](https://github.com/a2aserver/a2a-go) - A Go library for building A2A servers, with example implementations.
- a2a-rs - rs?style=social)](https://github.com/EmilLindfors/a2a-rs) - An idiomatic Rust implementation following hexagonal architecture principles.
- a2a_min - A minimalistic Python SDK for A2A communication.
- a2adotnet - A C#/.NET implementation of the A2A protocol.
- nestjs-a2a - a2a?style=social)](https://github.com/thestupd/nestjs-a2a) - A module for integrating the A2A protocol into NestJS applications.
- python-a2a - a2a?style=social)](https://github.com/themanojdesai/python-a2a) - An easy-to-use Python library for implementing the A2A protocol.
- Cognisphere - An AI agent development framework built on Google's ADK, facilitating agent creation potentially for A2A networks.
- Grasp - A Self-hosted Browser Using Agent with built-in MCP and A2A support.
- swissknife - 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.
- Agentic - agentic?style=social)](https://github.com/jeremychone/rust-agentic) - A Rust crate providing essential building blocks for agentic applications, with an ergonomic API for MCP and A2A support. (Work in Progress)
- a2ajava - Java A2A server/client implementation using Spring Boot with annotations. Supports WebSockets, MCP integration, and includes enterprise/Kubernetes deployment tutorials.
- Elkar - ai](https://github.com/elkar-ai) [](https://github.com/elkar-ai/elkar-a2a) - 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.
- https://github.com/google-a2a/a2a-samples/tree/main/samples/js
- https://github.com/google-a2a/a2a-samples/tree/main/samples/js/src/agents/movie-agent
- https://github.com/google-a2a/a2a-samples/tree/main/samples/js/client
- https://github.com/google-a2a/a2a-samples/tree/main/samples/js/server
- https://github.com/google-a2a/a2a-samples/tree/main/samples/java/client
- https://github.com/google-a2a/a2a-samples/tree/main/samples/java/model
- https://github.com/google-a2a/a2a-samples/tree/main/samples/java/server
- https://github.com/google-a2a/a2a-samples/tree/main/samples
- https://github.com/google-a2a/a2a-samples/tree/main/samples/host\_agent
- https://github.com/google-a2a/a2a-samples/tree/main/samples/weather\_agent
- https://github.com/google-a2a/a2a-samples/tree/main/samples/a2a-mcp-without-framework
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/agents
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/a2a\_telemetry
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/agents/ag2
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/agents/analytics
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/agents/autogen
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/azureaifoundry\_sdk
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/birthday\_planner\_adk
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/calendar\_agent
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/agents/crewai
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/google\_adk
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/headless\_agent\_auth
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/agents/helloworld
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/agents/langgraph
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/llama\_index\_file\_chat
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/agents/marvin
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/agents/mindsdb
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/agents/semantickernel
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/travel\_planner\_agent
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/veo\_video\_gen
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/hosts
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/hosts/multiagent
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/common
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/common/server
- https://github.com/google-a2a/a2a-samples/tree/main/samples/python/common/utils
- https://github.com/google-a2a/a2a-samples/tree/main/samples/go
- Link
- Link
- Link
- Link
- a2a-python - python?style=social)](https://github.com/google/a2a-python) - **Official** Python SDK for running agentic applications as A2A servers following the Agent2Agent Protocol.
- A2AServer - A Python server framework implementing Google's A2A protocol with MCP integration.
- a2a-net - io](https://github.com/neuroglia-io) [](https://github.com/neuroglia-io/a2a-net) - .NET implementation of the Agent2Agent (A2A) protocol to enable secure, interoperable communication between autonomous agents across frameworks and vendors.
- Artinet SDK - artinet-project](https://github.com/the-artinet-project) [](https://github.com/the-artinet-project/artinet-sdk) - TypeScript (Node.js) A2A compliant server/client simplifying interoperable AI agent creation, focusing on DX and production-readiness.
- a2a4j - A2A4J is a comprehensive Java implementation of the Agent2Agent Protocol, including server, client, examples, and a starter — ready to use out of the box.
- n8n-nodes-agent2agent - nodes-agent2agent?style=social)](https://github.com/pjawz/n8n-nodes-agent2agent) - Adds nodes to n8n for interacting with AI agents using Google's Agent2Agent (A2A) protocol.
- a2a-python - python?style=social)](https://github.com/a2aproject/a2a-python) - **Official** Python SDK for running agentic applications as A2A servers following the Agent2Agent Protocol.
- adk-modular-architecture - jarzyna](https://github.com/k-jarzyna) [](https://github.com/k-jarzyna/adk-modular-architecture) - A Python project demonstrating a modular architecture for ADK (Agent Development Kit) based agents, with A2A protocol considerations.
- google-calendar-agent - gateway](https://github.com/inference-gateway) [](https://github.com/inference-gateway/google-calendar-agent) - A standalone A2A agent that can manage a user's Google Calendar, compatible with any OpenAI-compatible API for its LLM.
- A2AApp - 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.
- a2a-go - go?style=social)](https://github.com/yeeaiclub/a2a-go) - Agent-to-Agent Protocol Implementation for Go, fully supports all methods of the A2A protocol, referring to the official Python SDK implementation.
- AgentUp - 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. Built by engineers who've created open-source solutions powering mission-critical systems at Google, GitHub, Nvidia, Red Hat, Shopify and more.
- https://github.com/a2aproject/a2a-samples/tree/main/samples/js
- https://github.com/a2aproject/a2a-samples/tree/main/samples/js/src/agents/movie-agent
- https://github.com/a2aproject/a2a-samples/tree/main/samples/java/custom_java_impl/client
- https://github.com/a2aproject/a2a-samples/tree/main/samples/java/custom_java_impl/model
- https://github.com/a2aproject/a2a-samples/tree/main/samples/java/custom_java_impl/server
- Link
- https://github.com/a2aproject/a2a-samples/tree/main/samples/java/agents/magic_8_ball_security
- https://github.com/a2aproject/a2a-samples/tree/main/samples/java/agents/content_writer
- https://github.com/a2aproject/a2a-samples/tree/main/samples/java/agents/content_editor
- https://github.com/a2aproject/a2a-samples/tree/main/samples/java/agents/weather_mcp
- https://github.com/a2aproject/a2a-samples/tree/main/samples/dotnet/BasicA2ADemo
- https://github.com/a2aproject/a2a-samples/tree/main/samples/dotnet/A2ACliDemo
- Link
- https://github.com/a2aproject/a2a-samples/tree/main/samples/python/hosts/cli
- https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/helloworld
- Link
- Link
- Link
- Link
- Link
- https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/birthday_planner_adk
- Link
- https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/a2a_mcp
- https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/a2a-mcp-without-framework
- https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/travel_planner_agent
- https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/headless_agent_auth
- https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/analytics
- https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/a2a_telemetry
- https://github.com/a2aproject/a2a-samples/tree/main/samples/python/hosts/a2a_multiagent_host
- https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/github-agent
- https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/veo_video_gen
- Link
- https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/marvin
- https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/mindsdb
- https://github.com/a2aproject/a2a-samples/tree/main/samples/go
- Link
- a2a-js - js?style=social)](https://github.com/a2aproject/a2a-js) - **Official** JavaScript SDK for the Agent2Agent (A2A) Protocol.
- a2a-java - java?style=social)](https://github.com/a2aproject/a2a-java) - **Official** Java SDK for the Agent2Agent (A2A) Protocol.
- AG2 (AutoGen) - 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).
- a2a-go - go?style=social)](https://github.com/a2aproject/a2a-go) - **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.
- ra2a - 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.
- jamjet-a2a - labs](https://github.com/jamjet-labs) [](https://github.com/jamjet-labs/jamjet-a2a) - 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).* **Python**
- fasta2a - Framework-agnostic Python A2A server library that lets developers expose agents through ASGI with pluggable storage, broker, and worker components.
- codex-a2a - a2a?style=social)](https://github.com/liujuanjuan1984/codex-a2a) - Full A2A Protocol implementation for Codex CLI, providing a stateful, production-oriented agent service with standardized transport and lifecycle mapping.
- opencode-a2a - Internet](https://github.com/Intelligent-Internet) [](https://github.com/Intelligent-Internet/opencode-a2a) - Full A2A Protocol implementation for OpenCode, providing a stateful A2A service with production-friendly deployment, auth, and session continuity.
- a2a - Ruby gem implementing A2A protocol data structures with serialization, validation, and case transformation support. Published on RubyGems.
- a2a-dotnet - dotnet?style=social)](https://github.com/a2aproject/a2a-dotnet) - **Official** C#/.NET SDK for the A2A Protocol.
- spring-ai-a2a - ai-community](https://github.com/spring-ai-community) [](https://github.com/spring-ai-community/spring-ai-a2a) - 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.
- a2a-4k - 4k](https://github.com/a2a-4k) [](https://github.com/a2a-4k/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.
- a2a-swift - Apps](https://github.com/Victory-Apps) [](https://github.com/Victory-Apps/a2a-swift) - 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.
- a2a-elixir - elixir?style=social)](https://github.com/actioncard/a2a-elixir) - 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 - 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.
- AgentUp - further](https://github.com/always-further) [](https://github.com/always-further/AgentUp) - 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.
- 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 - client-hub?style=social)](https://github.com/liujuanjuan1984/a2a-client-hub) - 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.
- a2a-rust - 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 - 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 - a2a?style=social)](https://github.com/aussierobots/turul-a2a) - 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.
- a2a-adapter - adapter?style=social)](https://github.com/hybroai/a2a-adapter) - 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.
- agent-protocol - ai](https://github.com/openJiuwen-ai) [](https://github.com/openJiuwen-ai/agent-protocol) - C++ SDK for the Agent2Agent (A2A) Protocol (and MCP), providing implementations of agent communication protocols for C++ environments.
- a2a-ai-provider - ai-provider?style=social)](https://github.com/DracoBlue/a2a-ai-provider) - Community A2A provider for the Vercel AI SDK, enabling drop-in interoperability with A2A agents via `generateText` and `streamText`.
- a2a-mesh - mesh?style=social)](https://github.com/oaslananka/a2a-mesh) - 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-php - php?style=social)](https://github.com/andreibesleaga/a2a-php) - 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.
- a2a - 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.
- ANT AI - idsia](https://github.com/idea-idsia) [](https://github.com/idea-idsia/ant-ai) - 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`.
- google-maps-a2a - maps-a2a?style=social)](https://github.com/pab1it0/google-maps-a2a) - 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.
- routa - Workspace-first multi-agent coordination platform for AI development, with shared Specs, Kanban orchestration, and MCP/ACP/A2A support across web and desktop.
- OpenClaw A2A Gateway - a2a-gateway?style=social)](https://github.com/win4r/openclaw-a2a-gateway) - 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 - community-ai-tools](https://github.com/redhat-community-ai-tools) [](https://github.com/redhat-community-ai-tools/UnifAI) - 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 - 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 - 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 - 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 - context-forge?style=social)](https://github.com/IBM/mcp-context-forge) - 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.
- agent-sdk-go - sdk-go?style=social)](https://github.com/agenticenv/agent-sdk-go) - 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.
- a2a-rs - rs?style=social)](https://github.com/a2aproject/a2a-rs) - **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.
- a2a-cpp - cpp?style=social)](https://github.com/MisterVVP/a2a-cpp) - 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.
- a2a-reference-ts - reference-ts?style=social)](https://github.com/reaatech/a2a-reference-ts) - 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/*`.
- Agenspy - 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`.
- ProtoLink - 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 - gateway](https://github.com/inference-gateway) [](https://github.com/inference-gateway/adk) - 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 - 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 - ai](https://github.com/Mangaba-ai) [](https://github.com/Mangaba-ai/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`.
- Agentic Kernel - kernel?style=social)](https://github.com/Qredence/agentic-kernel) - 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 - agents-ts?style=social)](https://github.com/tylerjrbuell/reactive-agents-ts) - 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 - 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 - 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 - group](https://github.com/trpc-group) [](https://github.com/trpc-group/trpc-agent-go) - 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.
- Atmosphere - 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.
- Aser - 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`.
- RustyHand - 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 - 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 - ai](https://github.com/agentscope-ai) [](https://github.com/agentscope-ai/agentscope-runtime) - 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 - ops](https://github.com/bug-ops) [](https://github.com/bug-ops/zeph) - 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 - agent?style=social)](https://github.com/memenow/persona-agent) - 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 - ai](https://github.com/rsclaw-ai) [](https://github.com/rsclaw-ai/rsclaw) - 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.
- llm.rb - 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.
- ADK Go - go?style=social)](https://github.com/google/adk-go) - 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.
- inference-gateway/rust-adk - gateway](https://github.com/inference-gateway) [](https://github.com/inference-gateway/rust-adk) - 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.
- Harness - ai](https://github.com/mastersof-ai) [](https://github.com/mastersof-ai/harness) - 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) - 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.
- bitterbot-desktop - AI](https://github.com/Bitterbot-AI) [](https://github.com/Bitterbot-AI/bitterbot-desktop) - 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.
- Agent Scrum - scrum?style=social)](https://github.com/TensorOpsAI/agent-scrum) - 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) - 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 - sandbox?style=social)](https://github.com/jmagly/agentic-sandbox) - 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 - Squad?style=social)](https://github.com/ArtemisAI/SWE-Squad) - 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.
Programming Languages
Categories
Sub Categories
Keywords
a2a
62
mcp
50
ai-agents
42
a2a-protocol
40
ai
28
agents
24
agentic-ai
20
llm
20
python
19
multi-agent
16
agent2agent
15
agent
14
ai-agent
12
a2a-server
12
agent-framework
12
mcp-server
10
typescript
10
agent-to-agent
10
a2a-client
10
multi-agent-systems
8
generative-ai
8
rust
8
cli
7
protocol
7
langgraph
7
sdk
7
openai
7
ollama
6
go
6
adk
6
agent-protocol
6
model-context-protocol
6
crewai
6
open-source
6
kubernetes
5
rag
5
agent-orchestration
5
self-hosted
5
anthropic
5
autonomous-agents
5
java
5
claude-code
5
gemini
4
openclaw
4
skills
4
mcp-client
4
a2a-agent
4
golang
4
a2a-mcp
4
claude
4