Best A2A Protocol SDKs and Frameworks to Build On (2026)

For most teams the A2A protocol SDK to start with is the official A2A Python SDK (pip install a2a-sdk), and if your stack is not Python, the official SDK for your language: JavaScript, Go, Java, .NET or Rust. If you want a full A2A agent framework instead of a protocol library, look at tRPC-Agent-Go for Go services, or FastA2A and any-agent to put an existing Python agent behind A2A.

Whatever you pick, keep the A2A Inspector and the A2A Samples open while you build. They are the quickest route from "installed" to "two agents talking".

This guide is about choosing. Every star count below comes from the GitHub REST API on 12 November 2026, every install command is quoted from the project's own README, and every protocol fact links to a2a-protocol.org or the a2aproject GitHub organisation. AgenticMart lists these projects from public GitHub data. We have not scanned them.

What A2A is, in two sentences

A2A (Agent2Agent) is an open protocol for agents built on different frameworks, by different teams, to discover each other and work on tasks together without exposing their internal memory or tools (A2A spec repo README). The current release of the A2A specification is 1.0.0, with 0.3.0 as the previous version, and the docs site describes the project as Linux Foundation governed. The spec repo's README says A2A is part of the Agentic AI Foundation.

The basic loop: an agent publishes an Agent Card (a JSON file describing its skills, endpoints and auth) at /.well-known/agent-card.json, and a client agent reads that card and sends it messages and tasks. Version 1.0 defines three bindings: JSON-RPC, HTTP+JSON/REST and gRPC. See our A2A protocol page for the full list of projects we track.

The A2A SDKs and frameworks, compared

Stars and licences as of 12 November 2026, from the GitHub REST API. "Spec" is what each project's own README or code says it implements.

Project	Language	Official or community	Stars	Licence	Spec	AgenticMart page
A2A Python SDK	Python	Official	2,243	Apache-2.0	1.0, with 0.3 compat mode	a2a-python
tRPC-Agent-Go	Go	Community	1,923	Apache-2.0	Not stated in README	trpc-agent-go
any-agent	Python	Community	1,258	Apache-2.0	a2a-sdk below 1.0 (see below)	any-agent
A2A JavaScript SDK	TypeScript	Official	653	Apache-2.0	1.0, opt-in 0.3 layer	a2a-js
A2A Java SDK	Java	Official	515	Apache-2.0	Version not stated in README	a2a-java
A2A Go SDK	Go	Official	506	Apache-2.0	1.0	a2a-go
A2A .NET SDK	C#	Official	268	Apache-2.0	1.0, separate 0.3 package	a2a-dotnet
FastA2A	Python	Community	225	MIT	Card advertises 1.0 (JSON-RPC)	fasta2a
A2A Rust SDK	Rust	Official	114	Apache-2.0	A2A v1	a2aproject-a2a-rs
A2A Inspector (tool)	Go	Official	512	Apache-2.0	1.0 and 0.3	a2a-inspector
A2A Samples (examples)	Several	Official	1,829	Apache-2.0	n/a	a2a-samples

For context, the A2A specification repo itself had 26,505 stars on the same date. Stars measure attention, not quality, so treat them as one signal among several.

A2A Python SDK (official)

Good for: the default choice. If you are searching for an Agent2Agent Python SDK, this is the one the spec repo points to. Its README lists client and server support for all three 1.0 bindings, plus a compatibility mode for 0.3 peers, which matters while the rest of the ecosystem catches up. Optional extras cover FastAPI and Starlette servers, gRPC, OpenTelemetry tracing and SQL task stores (PostgreSQL, MySQL, SQLite). It needs Python 3.10 or newer.

Getting started (quoted from the docs, not run for this post):

pip install a2a-sdk
# or, with every optional extra
pip install "a2a-sdk[all]"

The README's hello world runs a remote agent from the samples repo, then a client in a second terminal:

git clone https://github.com/a2aproject/a2a-samples.git
cd a2a-samples/samples/python/agents/helloworld
uv run .
# in another terminal, same folder
uv run test_client.py

Moving from SDK 0.3 to 1.0? The repo has a v0.3 to v1.0 migration guide. See the AgenticMart page.

A2A JavaScript SDK (official)

Good for: Node and TypeScript services. The README describes a v1.0 stable release with JSON-RPC, HTTP+JSON/REST and gRPC (gRPC is Node-only), an opt-in compatibility layer for v0.3 peers, and persistent stores for tasks in PostgreSQL, MySQL, SQLite or Cloudflare D1.

Getting started (quoted from the docs, not run for this post):

npm install @a2a-js/sdk
# Express is a peer dependency if you use the server integration
npm install express

See the AgenticMart page.

A2A Go SDK (official)

Good for: Go backends and anyone who wants the official tooling ecosystem, since the A2A Inspector itself talks to agents through this SDK. It ships a2asrv for serving and a2aclient for calling agents, with gRPC, REST and JSON-RPC bindings. The README notes the SDK version is separate from the spec version, which the code exports as a2a.Version. It requires Go 1.26.0 or newer.

Getting started (quoted from the docs, not run for this post):

go get github.com/a2aproject/a2a-go/v2

The same README points to the companion a2a CLI for sending messages and resolving agent cards from a terminal (go install github.com/a2aproject/a2a-cli@latest). See the AgenticMart page.

A2A Java SDK (official)

Good for: JVM shops. It is a multi-module Maven library with client and server support over JSON-RPC, gRPC and REST, and it has its own documentation site with server and client guides. It requires Java 17 or newer.

Getting started (quoted from the docs, not run for this post): add the reference JSON-RPC server to your pom.xml, using a released version from the repo's releases page.

<dependency>
    <groupId>org.a2aproject.sdk</groupId>
    <artifactId>a2a-java-sdk-reference-jsonrpc</artifactId>
    <version>${org.a2aproject.sdk.version}</version>
</dependency>

See the AgenticMart page.

A2A .NET SDK (official)

Good for: C# and ASP.NET Core teams. The README says it implements A2A v1.0 with the JSON-RPC, HTTP+JSON REST (including Server-Sent Events streaming) and gRPC bindings, and supports .NET 8 and later. If you still talk to 0.3 agents, there is a separate A2A.V0_3 package during the transition.

Getting started (quoted from the docs, not run for this post):

dotnet add package A2A
dotnet add package A2A.AspNetCore

See the AgenticMart page.

A2A Rust SDK (official)

Good for: Rust services that need A2A v1. It is a workspace of crates: core types, an async client that negotiates the protocol from agent cards, and an axum-based server. Its README lists JSON-RPC, REST, gRPC via tonic and SLIMRPC. It is the youngest of the official SDKs by stars, so check its release notes before you rely on it. Rust 1.85 or newer is required.

Getting started (quoted from the spec repo README, not run for this post):

cargo add a2a-lf

Note the crate name is a2a-lf, not a2a. There is also an independent Rust implementation, ra2a, if you want a community alternative. See the AgenticMart page.

tRPC-Agent-Go (community framework)

Good for: teams who want a whole Go agent framework, not only a protocol library. Its README lists A2A for agent interoperability alongside AG-UI for frontends and MCP for tools, plus multi-agent runners, memory, evaluation and OpenTelemetry tracing. It has an A2A interop example that talks to an ADK Python A2A server. Its A2A layer comes from the same group's own implementation, tRPC-A2A-Go, according to its go.mod, rather than the official Go SDK.

Getting started (quoted from the docs, not run for this post):

git clone https://github.com/trpc-group/trpc-agent-go.git
cd trpc-agent-go
export OPENAI_API_KEY="your-api-key-here"
cd examples/runner
go run . -model="gpt-4o-mini" -streaming=true

See the AgenticMart page.

FastA2A (community library)

Good for: wrapping a Python agent you already have, from any framework, as an A2A server. It is an ASGI app built on Starlette and Pydantic. You bring three parts: storage, a broker and a worker, and the README is clear that the worker can run in a separate process or on another machine. In-memory storage and broker are included to get started. Its code serves the card at /.well-known/agent-card.json and advertises protocol version 1.0 over JSON-RPC.

Getting started (quoted from the docs, not run for this post):

pip install fasta2a  # or `uv add fasta2a`

You then subclass Worker and implement run_task to call your agent. See the AgenticMart page.

any-agent (community framework layer)

Good for: comparing or switching between agent frameworks behind one interface, then serving the result over A2A. Its README lists TinyAgent, Google ADK, LangChain, LlamaIndex, OpenAI Agents, Smolagents and Agno, with cookbook pages for serving an agent over A2A and using an A2A agent as a tool. It needs Python 3.11 or newer.

One thing to check first: on 12 November 2026, the a2a extra in its pyproject.toml pinned a2a-sdk>=0.3.0,<1.0.0. That means its A2A serving uses the pre-1.0 Python SDK. If the agents you need to talk to run 1.0 only, test that pairing before you commit.

Getting started (quoted from the docs, not run for this post):

pip install 'any-agent'

See the AgenticMart page.

Tools you will want either way

• A2A Inspector. A web tool from the A2A project team that fetches an agent card, detects v1.0 or v0.3, checks the card against the spec, chats with the agent and shows every request on the wire. Quoted from its README, not run for this post: docker run --rm -p 127.0.0.1:8080:8080 ghcr.io/a2aproject/a2a-inspector.
• A2A Samples. The official A2A protocol examples, with Python and JavaScript agents. Start with the hello world above, then read the multi-agent samples.
• A2A TCK. A compatibility kit for testing an A2A implementation against the spec, useful if you are writing your own SDK.

Best A2A agents: SDK or framework?

People searching for the best A2A agents usually want one of two things. Some want a library so their own agent can speak A2A; for that, use an official SDK. Others want a framework that builds the agent and handles A2A for them; that is where tRPC-Agent-Go, any-agent and FastA2A sit. The A2A course listed in the spec README also covers exposing agents built with Google ADK, LangGraph or BeeAI as A2A servers, so check whether your current framework already has an adapter before adding a new one.

A simple rule: if you already have an agent, add an SDK or FastA2A. If you are starting from nothing in Go, a framework saves you wiring. If you are unsure, the official SDK in your language is the lowest-risk path because it tracks the spec directly.

A2A vs MCP: do you need both?

Often, yes. The A2A docs' own A2A and MCP page puts it plainly: A2A connects agents to each other, and MCP connects each agent to its own tools. A tool has structured inputs and outputs and does one job; an agent reasons, plans and holds longer, multi-turn tasks. So a typical system uses A2A between a coordinating agent and specialist agents, and MCP inside each agent for databases, files and APIs.

If MCP is new to you, read what an MCP server is and our MCP vs API comparison. For the editor-side protocol that is easy to confuse with these, see ACP (Agent Client Protocol), and if you are routing many MCP servers through one endpoint, see MCP gateways.

How we picked

• Source list. Every project comes from the A2A category on AgenticMart's protocols directory, which lists original GitHub repos (no forks, archived repos or link lists).
• Official first. We put the a2aproject SDKs ahead of community ones, because the spec repo's README names them as the SDKs to use.
• Community picks had to be active and distinct. Each was pushed to GitHub within the last month as of 12 November 2026 and does something the official SDKs do not: a full Go framework, a framework-agnostic Python server, or a multi-framework layer.
• Spec version stated where the project states it. Where a README does not say which spec it implements, the table says so instead of guessing.
• What we did not do. We did not run, benchmark or scan these projects for this post. Before adopting one, read its open issues and release notes, and check what it can touch on its listing page.

FAQ

What is the official A2A protocol SDK?

The A2A project publishes official SDKs for Python (a2a-sdk), JavaScript (@a2a-js/sdk), Go, Java, .NET (A2A on NuGet) and Rust (a2a-lf on crates.io), all under the a2aproject GitHub organisation and all Apache-2.0. Pick the one for your language.

Is there an Agent2Agent Python SDK?

Yes. Install it with pip install a2a-sdk. As of 12 November 2026 its README says it implements spec 1.0 over JSON-RPC, REST and gRPC, with a compatibility mode for 0.3.

Where can I find A2A protocol examples?

The official A2A Samples repo has runnable Python and JavaScript agents, including the hello world used in the Python SDK README. The .NET SDK repo also ships echo and researcher agent samples.

A2A vs MCP: which should I use?

Use MCP to give one agent access to tools and data, and A2A when one agent needs to hand work to another agent. They are designed to work together, according to the A2A docs.

Which A2A agent framework is best for Go?

If you want only the protocol, use the official A2A Go SDK. If you want a full agent framework with A2A, MCP and AG-UI built in, tRPC-Agent-Go had the most stars of any Go project in our A2A list on 12 November 2026.

Do A2A 0.3 and 1.0 agents work together?

Not automatically. The Python, JavaScript and .NET SDKs offer 0.3 compatibility options, and the A2A Inspector can talk to both versions, so check the version on each agent card before connecting.

Built an A2A agent or SDK?

If you have built an A2A agent, an SDK or a tool around the protocol, developers choosing what to build on are looking for it. On AgenticMart you can list free now, paid selling opens soon. List your project, or browse agents and the rest of the A2A directory.