DOCSEARCHbyAlgolia
Submit Docs

awesome-a2a

repository·main·Indexed 20 days ago

https://github.com/ai-boost/awesome-a2a

A curated collection of resources, implementations, tools, and examples for the Agent2Agent (A2A) Protocol. A2A is an open standard developed by Google and partners to enable secure communication and interoperability between AI agents regardless of vendor, framework, or platform. This repository provides links to official SDKs and community implementations across TypeScript, Python, Go, Rust, Java, .NET, Ruby, and C++, as well as integrations with frameworks like LangGraph, CrewAI, Genkit, and Semantic Kernel.

Tokens
9.6K
Snippets
7
Records
47
Agent score
21%

What's inside awesome-a2a

  1. What is the Agent2Agent (A2A) Protocol?

    main
    The Agent2Agent (A2A) Protocol is an open standard developed by Google and partners to enable secure communication and collaboration between different AI agents, regardless of their vendor, framework, or platform. It aims to eliminate silos in agentic systems, allowing for complex, cross-application automation through interoperability.

  2. Explore A2A Frameworks for building agents

    main
    A2A (Agent-to-Agent) includes developer-first frameworks specifically designed to build agents that are compliant with the A2A specification. These frameworks provide the necessary abstractions to ensure agents can communicate, negotiate, and collaborate effectively within an A2A ecosystem.

  3. Explore A2A Implementations and Libraries

    main

    The awesome-a2a repository maintains a curated list of implementations, runtimes, and frameworks that support the Agent-to-Agent (A2A) protocol. These tools range from JVM and Rust runtimes to Python and TypeScript frameworks, enabling developers to build, host, and consume A2A-compliant agents.

    Key Implementations by Ecosystem

    JVM / Java / Spring

    • Atmosphere: A JVM runtime for streaming, governable AI agents. Supports A2A, MCP, and AG-UI via WebSocket, SSE, gRPC, and WebTransport/HTTP3. Includes adapters for Spring AI and LangChain4j.
    • ReachAI (Enterprise Agent Framework): A Java/Spring Boot framework. Uses @AiCapability annotations to register business APIs as governed AI capabilities, exposing them via A2A and MCP.

    Python

    • tinyagent: A minimal framework with MCP tool support and optional A2A/MCP serving.
    • orxhestra: A multi-agent orchestration framework. It is a spec-compliant v1.0 server using JSON-RPC 2.0 and supports agent card discovery. Published on PyPI as orxhestra.
    • BeeAI Framework: Supports building multi-agent systems with a Serve module to expose agents via A2A.
    • Agno: A lightweight library where AgentOS exposes agents and teams as A2A-compatible services using A2AClient and RemoteAgent. Published on PyPI as agno.
    • fast-agent: A framework for building and evaluating agents with A2A and MCP/ACP integration. Published on PyPI as fast-agent-mcp.

    Rust

    • ADK Rust: A model-agnostic toolkit with native A2A v1.0.0 support via A2aServer::quick_start. Published on crates.io as adk-rust.

    TypeScript / JavaScript

    • Lucid Agents: A TypeScript runtime for machine commerce. Uses @lucid-agents/a2a for Agent Card discovery and token-protected asynchronous tasks. Published on npm as @lucid-agents/*.
    • Evolver: A self-evolution engine that connects to the EvoMap hub via A2A to sync assets. Published on npm as @evomap/evolver.

    .NET / Go

    • Microsoft Agent Framework: A multi-language framework (.NET and Python) with A2A hosting support (e.g., A2AAgent/A2ACardResolver).
    • Microsoft Agent Framework for Go: The Go implementation of MAF with first-class A2A protocol support.

    Other Specialized Runtimes

    • Harness: An agent runtime that exposes agents via auto-generated Agent Cards.
    • Solace Agent Mesh: An event-driven framework using Solace event messaging for A2A discovery and delegation.
    • Kagenti ADK: A toolkit to turn any agent into an A2A-compliant service.
    • YoMo: A serverless LLM function-calling framework with A2A support.
    • Forge: An enterprise runtime where agents are deployed as A2A endpoints with a spec-conformant Agent Card at /.well-known/agent-card.json.

  4. Key Principles of the A2A Protocol

    main

    The A2A protocol is designed around several core architectural principles:

    • Simple: Leverages existing standards like HTTP, JSON-RPC, and SSE.
    • Enterprise Ready: Prioritizes Authentication, Security, Privacy, and Monitoring.
    • Async First: Built to handle long-running tasks and human-in-the-loop interactions.
    • Modality Agnostic: Supports various data types including Text, Files, Forms, and Streams.
    • Opaque Execution: Agents can interact and collaborate without exposing their internal logic or specific toolsets to one another.

  5. How A2A communication works at a high level

    main

    A2A interaction follows a structured lifecycle involving discovery, communication, execution, and updates:

    1. Discovery: An agent publishes an Agent Card (in JSON format) that describes its capabilities, endpoints, and authentication requirements.
    2. Communication: A Client agent initiates a Task request. This request contains a Message composed of one or more Parts. Communication typically uses HTTP/JSON-RPC 2.0 to reach a Remote Agent (Server).
    3. Execution & Response: The Server processes the task and updates its status. Once complete, it responds with the final status and any generated Artifacts (which also contain Parts).
    4. Updates: For asynchronous or long-running tasks, the Server can stream updates to the client using TaskStatusUpdateEvent or TaskArtifactUpdateEvent via Server-Sent Events (SSE) or Push Notifications.

  6. Getting started with A2A

    main

    To begin working with the A2A protocol, follow these steps:

    1. Learn the Basics: Review the high-level concepts of A2A and read the official announcement.
    2. Study Core Objects: Familiarize yourself with the primary data structures: Agent Card, Task, Message, Part, and Artifact via the Official Technical Documentation.
    3. Watch Demos: View the Official Demo Video and explore the Multi-Agent Web App Demo.
    4. Run Official Samples: Clone the Official Samples Repo to run a client (such as the CLI) against a sample agent (e.g., LangGraph or Genkit).
    5. Analyze Implementations: Examine the common (Python) or server/client (JS/TS) libraries in the samples to understand how the protocol is implemented in code.
    6. Build: Use the provided libraries or adapt existing samples to create your own A2A-compatible agent or client.

  7. AgentUp: Portable and scalable agent framework

    main

    AgentUp is an open-source framework designed for portability, scalability, and security.

    Key Features:

    • Configuration-driven architecture.
    • Built-in authentication (OAuth2, JWT, API key).
    • Automatic A2A discovery.
    • Asynchronous task management.
    • Support for both A2A and MCP protocols.

  8. Implement A2A payments with the x402 extension

    main

    The a2a-x402 extension enables agents to monetize services using cryptocurrency and HTTP 402-style payments.

    Implementations:

    • Python: Use the x402_a2a library.
    • TypeScript: Use the a2a-x402 package (published on npm). It supports exception-based payment flows, ethers.js wallet integration, dynamic pricing, and multi-network EVM support.
    • Internet Court Skill: A trust layer for commerce providing natural-language mandates, ERC-7710 delegated permissions, and escrow.
    npm install a2a-x402

  9. Agentic Kernel: Modular multi-agent architecture

    main

    Agentic Kernel is a foundation AI system for creating A2A-compatible autonomous agents built on Google's A2A standard and the ADK framework.

    Key Features:

    • Modular multi-agent architecture.
    • Dynamic planning with an Orchestrator Agent.
    • Chainlit-based interactive UI.

    Installation: Available on PyPI as agentic-kernel.

  10. Swarm: Rust framework for multi-agent orchestration

    main

    A Rust framework for building and orchestrating intelligent multi-agent systems using A2A and MCP standards.

    Key Components:

    • Planner Agent: Produces static or dynamic workflows.
    • Executor Agent: Carries out workflows with a built-in LLM-as-a-Judge evaluation loop.
    • Agent Factory: Programmatic agent instantiation at runtime.
    • MCP Runtime: Bridges agents to external tools.

    Implementation Details: Built on a2a-rs and rmcp.

  11. Discover and register A2A agents via Registry Services

    main

    To find or manage A2A agents, you can use various registry and discovery implementations. These services allow agents to publish their AgentCard and enable other agents or users to discover them via semantic or lexical search.

    Key discovery tools include:

    • A2A Agent Registry on AWS: A scalable serverless registry using Amazon Bedrock and S3 Vectors for semantic search. Includes a Python SDK and React Web UI.
    • A2A Registry: A community-driven directory with a REST API, Python client, and MCP server.
    • DNS-AID Core: A DNS-based discovery implementation (IETF BANDAID draft) that allows agents to publish via DNS (e.g., Route 53, Cloudflare) instead of centralized registries.
    • LAD-A2A: A protocol for discovering A2A agents on local networks using mDNS/DNS-SD.
    • A2ARegistry: A centralized service supporting OAuth 2.0 and cross-registry federation.
    • HOL Registry Broker Skills: AI agent skills that allow you to search live agent inventory and register your own via tools like Claude or Cursor.

  12. Google ADK: Official Go and Java toolkits

    main

    Google provides official open-source, code-first toolkits for building, evaluating, and deploying AI agents with native A2A protocol support.

    ADK Go

    • Language: Go
    • Features: MCP integration, multi-agent orchestration, and seamless Vertex AI / Gemini interoperability.
    • License: Apache 2.0

    ADK Java

    • Language: Java
    • Features: Native A2A protocol integration for remote agent-to-agent communication, Google Maps grounding, human-in-the-loop workflows, and robust session management.
    • License: Apache 2.0