The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
npx ecc-install --profile fullFair-code workflow automation platform with native AI capabilities. Combine visual building with custom code, self-host or cloud, 400+ integrations.
npx n8nAn open-source AI agent that brings the power of Gemini directly into your terminal.
npx @google/gemini-cliThe 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.
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
Agent Card (JSON) describing capabilities, endpoint, and auth needs.Client agent sends a Task request (containing a Message with Parts) to a Remote Agent (Server) using HTTP/JSON-RPC 2.0.status. It responds with the final status and any generated Artifacts (results, also containing Parts).TaskStatusUpdateEvent or TaskArtifactUpdateEvent via Server-Sent Events (SSE) or use Push Notifications.For details, see the Official Technical Documentation.
New to A2A? Here's a suggested path:
Agent Card, Task, Message, Part, and Artifact.common (Python) or server/ (JS/TS) libraries in the official samples to see how A2A communication is implemented.(See How Does A2A Work? above for summaries)
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 | |
Quick Start First-time users: try TypeScript
Movie Recommendation Agent, PythonHello World, or GoGo Reference Impl— minimal dependencies and the simplest startup commands.
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 |
- 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.
- 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.
- A Go library for building A2A servers, with example implementations.Developer-first frameworks specifically designed for building A2A-compliant agents.
- 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.
- 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.
- 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.
- 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).
- 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.
- 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.This section aims to list standalone tools and utilities related to the A2A protocol. The ecosystem is still developing, and community contributions are welcome!
- Scalable serverless agent registry for A2A protocol AgentCards with semantic search (Amazon Bedrock, S3 Vectors), Python SDK, and React Web UI.
- Community-driven, open-source directory of live, hosted A2A agents with web UI, REST API, Python client, MCP server, and health conformance checking.
- 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.
- A tutorial on how to use Model Context Protocol by Anthropic and Agent2Agent Protocol by Google.
- Official repository containing code samples and demos which use the Agent2Agent (A2A) Protocol.
- 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.
- Mailbox-native open protocol and SDKs (Go, Node.js, Python) for asynchronous agent-to-agent collaboration over email/SMTP and JMAP. Complements real-time A2A with durable, store-and-forward messaging and universal addressing.Let's Make Awesome A2A More Useful, Together!
A2A is still pretty new, and good resources or practical tips can be scattered. We created this list to bring the good stuff together, making it easier for everyone to find, learn, and reference.
Keeping this list high-quality and up-to-date relies on the community:
Thanks for your interest and contributions!
Contributions are welcome! 🙌 Please read the contributing guidelines first. Let's build this list together!
client| 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 |
| 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 |
- Agent-to-Agent Protocol Implementation for Go, fully supports all methods of the A2A protocol, referring to the official Python SDK implementation.
- 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.
- 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.
- 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.
- An idiomatic Rust implementation following hexagonal architecture principles.
- A Rust crate providing essential building blocks for agentic applications, with an ergonomic API for MCP and A2A support. (Work in Progress)
- 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-protocol-sdk.
- 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.
- 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.
- Official Python SDK for running agentic applications as A2A servers following the Agent2Agent Protocol.
- A minimalistic Python SDK for A2A communication.
- An easy-to-use Python library for implementing the A2A protocol.
- Framework-agnostic Python A2A server library that lets developers expose agents through ASGI with pluggable storage, broker, and worker components.
- A Python server framework implementing Google's A2A protocol with MCP integration.
- A Python project demonstrating a modular architecture for ADK (Agent Development Kit) based agents, with A2A protocol considerations.
- Full A2A Protocol implementation for Codex CLI, providing a stateful, production-oriented agent service with standardized transport and lifecycle mapping.
- Full A2A Protocol implementation for OpenCode, providing a stateful A2A service with production-friendly deployment, auth, and session continuity.
- 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.
- 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 gem implementing A2A protocol data structures with serialization, validation, and case transformation support. Published on RubyGems.
- 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.
- 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++ SDK for the Agent2Agent (A2A) Protocol (and MCP), providing implementations of agent communication protocols for C++ environments.
- 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 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.
- Official C#/.NET SDK for the A2A Protocol.
- A C#/.NET implementation of the A2A protocol.
- .NET implementation of the Agent2Agent (A2A) protocol to enable secure, interoperable communication between autonomous agents across frameworks and vendors.
- Official JavaScript SDK for the Agent2Agent (A2A) Protocol.
- Community A2A provider for the Vercel AI SDK, enabling drop-in interoperability with A2A agents via generateText and streamText.
- A module for integrating the A2A protocol into NestJS applications.
- TypeScript (Node.js) A2A compliant server/client simplifying interoperable AI agent creation, focusing on DX and production-readiness.
- 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.
- 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.
- 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/*.
- 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 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.
- Official Java SDK for the Agent2Agent (A2A) Protocol.
- Jakarta EE integration for the A2A Java SDK, implementing A2A Protocol Specification 1.0 on WildFly, Tomcat, Jetty, and OpenLiberty. Apache 2.0.
- Java A2A server/client implementation using Spring Boot with annotations. Supports WebSockets, MCP integration, and includes enterprise/Kubernetes deployment tutorials.
- 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 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.
- 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.
- 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 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.
- Elixir client and server library for A2A with REST/JSON-RPC transports, SSE streaming utilities, Plug integration, typed structs, task store abstractions, and protocol compatibility modes.
- Dart/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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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/*.
- 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.
- 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.*.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- Build production-ready multi-agent systems in Python or TypeScript, with a Serve module that exposes agents via A2A and MCP. Apache 2.0.
- 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.
- 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.
- 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.
- Open-source serverless LLM function-calling framework for building scalable, geo-distributed AI agents with A2A protocol support. Apache 2.0.
- 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.
- 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.
- 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.
- 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.
- An A2A network implementation for hosting, registering, discovering, and interacting with agents. Includes agent discovery mechanisms.
- An AI agent development framework built on Google's ADK, facilitating agent creation potentially for A2A networks.
- A Self-hosted Browser Using Agent with built-in MCP and A2A support.
- 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.
- Adds nodes to n8n for interacting with AI agents using Google's Agent2Agent (A2A) protocol.
- A standalone A2A agent that can manage a user's Google Calendar, compatible with any OpenAI-compatible API for its LLM.
- 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.
- 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.
- 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.
- 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.
- Workspace-first multi-agent coordination platform for AI development, with shared Specs, Kanban orchestration, and MCP/ACP/A2A support across web and desktop.
- A2A protocol plugin for Hermes Agent enabling peer-to-peer agent communication with instant wake, session injection, and persistent conversation storage.
- 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).
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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 (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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- A lightweight AI agent construction platform with configurable online agents, MCP services, and single-port multi-A2A service support. MIT licensed.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- Official validation tools for A2A agents, including compliance checking and debugging utilities.
- 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.
- Cross-platform desktop app for testing & validating A2A protocol implementations, with features like multi-agent connection and session management.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- Official A2A extension that brings cryptocurrency / HTTP 402-style payments to the Agent2Agent protocol, enabling agents to monetize their services through on-chain payments. Includes the v0.1 spec, Python (x402_a2a) and TypeScript libraries, partner-contributed schemes, and end-to-end examples. Apache 2.0.
- A complete TypeScript implementation of the Python x402 payment protocol extension for A2A, enabling agents to request, verify, and settle crypto payments seamlessly. Features exception-based payment flow, ethers.js wallet integration, dynamic pricing, and multi-network EVM support. Published on npm as a2a-x402. Apache 2.0.
- Easily convert agents and orchestrators from existing agent frameworks to A2A servers.
- Open A2A 1.0 mesh for Claude Code, Codex, Cursor, Cline, Continue, and Gemini. Wraps each coding agent into a standard A2A peer with local discovery, shared inbox, JSON-RPC 2.0 + SSE transport, and optional cross-machine mTLS federation. MIT licensed.
- Run Claude Code, Codex, Gemini CLI, or any ACP-compatible coding agent as an A2A server. Supports signed AgentCards, bearer auth, input-required permission pauses, push notifications, OpenTelemetry tracing, and multiple backends. Apache 2.0 and published on PyPI as a2acode.
- TypeScript monorepo of A2A protocol wrappers that turn production AI backends (GitHub Copilot SDK, OpenCode, and more) into standalone, interoperable A2A agents. Drop a JSON config, get a spec-compliant A2A server with auto-generated AgentCards and session management.
- CLI tool that transforms OpenAPI specs into 9 agent interface formats including A2A Agent Cards, MCP servers, AGENTS.md, CLAUDE.md, and more. (npx agentify-cli transform <openapi-spec>)
- The data integrity layer that stops AI agents from silently corrupting shared state. Implements MESI-style ownership, optimistic commit-CAS, and snapshot sessions for multi-agent workflows, with LangGraph/CrewAI/AutoGen/OpenAI Agents SDK adapters, an MCP server (stale-write-guard-fs), a CLI diagnostic tool, and TLA+ model-checked protocol safety. Apache 2.0 and published on PyPI as agent-coherence.
- A2A Protocol client and developer toolkit featuring an interactive TUI, CLI commands, MCP server integration, agent card inspection, and a bundled reference agent.
- UI components for editing, viewing, and testing A2A agent cards and interactions, with installable packages and self-hosted local or Docker usage.
- Bridge server connecting MCP-compatible AI assistants (like Claude) with A2A agents, enabling seamless cross-protocol discovery, registration, and task management. Supports stdio, streamable-http, and SSE transports.
- Kotlin/JVM mock-server toolkit (built on Ktor) for testing A2A integrations. Ships a dedicated ai-mocks-a2a module with a MockAgentServer, full A2A protocol coverage (11 endpoints), real Server-Sent Events streaming, plus shared mocks for OpenAI/Anthropic/Gemini/Ollama — useful for service virtualization, contract tests, and offline development. MIT licensed and published on Maven Central.
- A general-purpose web UI for the Agent2Agent (A2A) Protocol built with React, Next.js, and Material UI on top of the official a2a-js SDK. Add any A2A-compatible agent by URL, fetch its AgentCard, run multi-turn chat sessions with Context and Tasks, render markdown-supported Messages/Artifacts, and visualize streaming responses and tool-call traces — effectively an early "web browser" for A2A agents. Apache 2.0.
- Modern, production-ready web UI for Google A2A built with Next.js, TypeScript, Tailwind CSS, and shadcn/ui. Features agent CRUD and configuration, Telegram-style real-time chat with streaming, Phoenix/Jaeger trace visualization, dark/light/system themes, Docker and Vercel deployment. MIT licensed.
- A2A protocol plugin for Dify that enables cross-agent communication. Connects Dify workflows to external A2A-compatible agents via JSON-RPC 2.0 with synchronous and asynchronous modes, SSE streaming, and Bearer/API Key/Basic auth. Supports A2A v0.3.0. Apache 2.0.
- Agent-to-agent bridge that lets Claude Code, Codex, OpenClaw, Hermes Agent, Gemini CLI, Zed, and VS Code agents talk to each other through one daemon. Translates between A2A (HTTP + SSE), ACP (stdio JSON-RPC), and MCP channels with multi-session isolation and an SQLite task log. MIT licensed.
- Multi-channel gateway that connects any A2A agent to Telegram, Slack, WhatsApp, Google Chat, Email, Discord, and custom channels. Handles message chunking, rate limiting, retries, streaming responses, and per-channel markdown formatting; supports single-user and multitenant deployment. Apache 2.0.
- Local-first bridge adding A2A protocol support to Hermes Agent. Supports agent discovery, task send/stream/manage, SSE streaming, SQLite persistence, gated file staging, and bearer auth. MIT licensed.
- The adaptive semantic interoperability layer for AI agents. Translates and routes across protocols, auto-generates schemas, handles schema drift, and supports cross-protocol federation (MCP, CLI, A2A, ACP) with multi-hop handoffs. MIT licensed.
- A small, open-source CLI coding agent that exposes itself as an A2A endpoint (swival --serve) and can call remote A2A agents. Features multi-turn context, SSE streaming, rate limiting, bearer auth, MCP support, cross-session memory, and built-in security auditing. MIT licensed.
- An official AWS course for building AI agents with the Strands framework, covering LLM integration via Amazon Bedrock/Anthropic, AWS service connections, tool implementation with MCP/A2A protocols, and agent evaluation using LangFuse/RAGAS. MIT-0 licensed.
a2a-dotnet
- 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.
- 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.
- 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.