# Does Your Agent Framework Really Support A2A? How to Read the Claim and What to Test

> Which agent frameworks list A2A support, what native, add-on, platform-gated and unrecorded mean, a short test checklist to run before you rely on it, and how that differs from the protocol's own SDKs.

Guide: A2A in practice: agent-to-agent interoperability — part 10
Published: 2026-11-08 · Updated: 2026-11-08 · 1184 words · ~1575 tokens (estimate)
Canonical: https://changegamer.ai/articles/agent-frameworks-with-a2a-support
JSON: https://changegamer.ai/api/articles/agent-frameworks-with-a2a-support.json
Access: free — editorial guide, not part of the licensed corpus
Pillar: https://changegamer.ai/articles/a2a-protocol-in-practice.md

## In short

- As recorded in the ChangeGamer framework comparison on 28 September 2026, Google ADK, LlamaIndex Workflows and Mastra list native A2A support, and Pydantic AI lists it through the separate fasta2a package.
- LangGraph lists A2A only through LangSmith Deployment, formerly LangGraph Platform, and the framework comparison records it as not available in the open-source library alone.
- The OpenAI Agents SDK is recorded with no A2A support, only handoffs, as of the ChangeGamer framework comparison re-verified on 28 September 2026.
- A framework listing "A2A: Yes" does not say which A2A protocol version, binding or Agent Card behaviour it implements, so verify those with a live call before building on it.
- The A2A project lists six SDKs of its own, Python, Go, JavaScript, Java, .NET and Rust, and those are a separate thing from agent-framework support for the protocol.

---

Nine agent frameworks are compared in the ChangeGamer corpus, and seven of them list A2A support, but "supports A2A" covers four different situations. This article reads that claim, gives a short test to run before relying on it, and separates it from the protocol's own SDKs. The pillar's [A2A protocol in practice](/articles/a2a-protocol-in-practice) framework table is the status list; this article regroups it by mechanism rather than repeating it row by row, and the full comparison is [the agent frameworks compared resource](/resources/agent-frameworks-compared).

Dating: the framework facts below are as recorded on 28 September 2026. That pass checked package-registry releases; the GitHub repository pages were not independently re-fetched. ChangeGamer itself speaks MCP, not A2A, so it has not tested any framework's A2A behaviour.

## What does "supports A2A" actually mean for a framework?

A framework listing A2A support falls into one of four situations, and the ChangeGamer record only distinguishes some of them. The tiers below are inference from the wording of the comparison table, not an official classification.

| Tier (inference) | Frameworks as recorded 28 September 2026 | What the record says |
|---|---|---|
| Native | Google ADK, LlamaIndex Workflows, Mastra | Listed as native; ADK auto-generates an Agent Card |
| Add-on package | Pydantic AI | Via fasta2a; `Agent.to_a2a()` deprecated and removed in v2.0 |
| Platform-gated | LangGraph | Via LangSmith Deployment; not in the open-source library alone |
| None recorded | OpenAI Agents SDK | Handoffs only, no cross-vendor A2A |

Three frameworks do not fit a tier: CrewAI is recorded as a bare "Yes", Microsoft Agent Framework as "Yes" with a 1.0 release in April 2026 and Python-to-.NET interoperability over A2A, and AWS Strands Agents as "Yes" with SDK 1.0 in May 2026; none of the three states the mechanism. They may be native or add-on; the record does not say, so no tier is forced on them.

Each tier carries a different dependency. Native means the library is the dependency. An add-on means a second package to pin and track. Platform-gated means a hosted product sits in the path.

## How native, add-on and platform-gated support differ in practice

The practical difference is what you must install, pin and pay for to expose or call an A2A agent. This section is inference built on the recorded facts.

- **Native.** Mastra's A2A page is mastra.ai/docs/agents/a2a, and the comparison dates its support to May 2026. LlamaIndex Workflows is recorded as built into LlamaIndex Agents in 2026. Google ADK is described as the strongest A2A first-mover, a characterisation in the record rather than something measured here.
- **Add-on.** For Pydantic AI, a deprecated convenience method was removed in v2.0, so older snippets that call `Agent.to_a2a()` are a warning sign. The resource records v2.0 going GA in June 2026.
- **Platform-gated.** For LangGraph, an open-source install alone is not enough per the record, so A2A is tied to LangSmith Deployment, which is the renamed LangGraph Platform.
- **None recorded.** The OpenAI Agents SDK has handoffs, which move control between agents inside the SDK, not a cross-vendor protocol. That is a dated snapshot, not a claim that it can never support A2A, and the same goes for LangGraph.

## What should you test before relying on a framework's A2A claim?

Run five checks against a live agent, because a "Yes" in a comparison table says nothing about wire behaviour. This checklist is inference, not framework documentation, and each step uses the contract in [the A2A protocol reference](/resources/a2a-protocol).

1. **Fetch the card.** An A2A agent must publish an Agent Card at `/.well-known/agent-card.json`; read its `supportedInterfaces` to see which bindings and endpoints it serves.
2. **Send one message.** Make a single Send Message call over a binding the card lists.
3. **Watch the task states.** Confirm the agent reports states from the eight defined ones and ends in a terminal state; see [task states and operations](/articles/a2a-task-lifecycle).
4. **Pin the version.** Send an explicit `A2A-Version` header, because an empty value is read as 0.3; see [the v0.3 to v1.0 migration checklist](/articles/a2a-v0-3-to-v1-0-migration).
5. **Read the card as a stranger would.** Check that skills, security schemes and interfaces are what you expect; see [designing an Agent Card](/articles/a2a-agent-card-design).

```bash
# Replace the host with the agent you are evaluating.
curl -sS https://agent.example.com/.well-known/agent-card.json | head -c 2000
```

The comparison records no A2A protocol version or binding for any framework, and only one card-behaviour note (Google ADK auto-generates an Agent Card), so this test is how you find them out.

## How do the A2A project's own SDKs relate to framework support?

The A2A project's SDKs are libraries for speaking the protocol, while framework support is a feature of an agent-orchestration library, so the two are different questions. The A2A reference records six SDKs in the project README: Python, Go, JavaScript, Java, .NET and Rust. The SDK page at a2a-protocol.org/latest/sdk was re-fetched on 2026-11-08 and lists the same languages.

This article does not map those SDKs onto frameworks, because the record does not say which framework uses which SDK, or whether any does. A framework can be a good A2A citizen without a mention of the project SDKs, and an SDK in your language does not give you a framework's orchestration, state or tracing.

## How should you choose a framework if A2A matters?

Choose on language, vendor gravity and the dependency tier first, and treat A2A as one filter among several. The corpus gives only these facts, so the guidance is hedged.

- **Language.** Mastra is recorded as the only TypeScript-native framework in the comparison; most others are Python-first, and Google ADK, LangGraph and AWS Strands also ship TypeScript SDKs per the record.
- **Vendor gravity.** The comparison notes Google ADK leaning toward Gemini and Vertex AI, AWS Strands toward Bedrock, and Microsoft Agent Framework toward Azure; all are technically model-agnostic.
- **Platform dependency.** If you adopt LangGraph for A2A, budget for LangSmith Deployment, since the open-source library alone is not recorded as enough.
- **Handoffs only.** If you need cross-vendor delegation, the OpenAI Agents SDK is recorded as not providing it as of 28 September 2026.

Whether a protocol is needed at all is a separate decision, covered in [the pillar](/articles/a2a-protocol-in-practice). The corpus holds no adoption figures, so nothing here ranks frameworks by popularity.

## What can this comparison not tell you?

The comparison cannot tell you whether any listed framework interoperates with another in your setup, because it records a status word per framework and not test results. It names no A2A protocol version and no binding for any framework, and its only Agent Card note is that Google ADK auto-generates one, and it does not say whether a framework can both call and expose A2A agents. Its package-registry versions were re-verified on 28 September 2026, and the GitHub repository pages were not independently re-fetched, so repository-level claims carry less weight than the registry facts.

Treat every row as a starting hypothesis. Read the framework's own current A2A documentation, run the five checks above against a real agent, and re-run them after upgrading the framework or the A2A version you target, since both move independently.

## Frequently asked questions

### How should you read a framework's claim of A2A support?

Treat a framework's claim of A2A support as one of four situations as recorded on 28 September 2026: native (Google ADK, LlamaIndex Workflows, Mastra), an add-on package (Pydantic AI), platform-gated (LangGraph) or none recorded (OpenAI Agents SDK), then confirm it with a live Agent Card fetch and one message call.

### Does LangGraph support A2A?

LangGraph lists A2A support through LangSmith Deployment, formerly LangGraph Platform, and the ChangeGamer framework comparison records it as not available in the open-source library alone. Whether that changes later is not something the comparison can say, so check the current LangGraph documentation.

### Does the OpenAI Agents SDK support A2A?

The ChangeGamer framework comparison, re-verified on 28 September 2026, records the OpenAI Agents SDK as having no A2A support, only handoffs between agents within the SDK. That is a dated snapshot rather than a statement about the future, so re-check before relying on it.

### Is an A2A SDK the same as an agent framework with A2A support?

An A2A SDK is not the same thing as a framework with A2A support. The A2A project lists its own SDKs for Python, Go, JavaScript, Java, .NET and Rust, while frameworks such as Google ADK or Mastra are agent-orchestration libraries that list A2A as a capability.


---

## The rest of this guide

- [The A2A Protocol in Practice: Agent Cards, Tasks, Auth and When You Need It](https://changegamer.ai/articles/a2a-protocol-in-practice.md): A practical guide to the A2A (Agent2Agent) protocol: what it standardizes, when it beats in-process subagents, how Agent Cards, task states, bindings and authentication work, how credentials cross agent hops, and how to launch it.
- [Do You Need A2A for a Multi-Agent System? A Decision Rule](https://changegamer.ai/articles/do-you-need-a2a.md): A decision rule for choosing between in-process subagents and the A2A protocol: start with one agent, add more only for a named failure, and cross the network with A2A only when a remote party, framework or trust boundary demands it.
- [Designing an Agent Card: What Goes in the Public Card and What Waits](https://changegamer.ai/articles/a2a-agent-card-design.md): How to design an A2A Agent Card: the field groups, the well-known path, optional signing, and a rule for splitting what the public card advertises from what an authenticated client fetches in the extended card.
- [A2A Task States and Operations: What Each State Means for an Orchestrator](https://changegamer.ai/articles/a2a-task-lifecycle.md): The eight A2A task states, the eleven operations that act on tasks, the difference between interrupted and terminal states, and an inference-labelled handler matrix for an orchestrator.
- [A2A JSON-RPC vs gRPC vs REST: What Differs Between the Three Bindings](https://changegamer.ai/articles/a2a-bindings-json-rpc-grpc-rest.md): The three A2A protocol bindings (JSON-RPC, gRPC, HTTP+JSON/REST): what the specification keeps identical, what differs on the wire, and an inference-labelled guide to picking one.
- [A2A Authentication Schemes: Which to Declare in Your Agent Card](https://changegamer.ai/articles/a2a-authentication-schemes.md): The five security scheme families an A2A Agent Card can declare (API key, HTTP auth, OAuth 2.0, OpenID Connect, mutual TLS), an inference-labelled rule for choosing one, and how a client handles auth-required tasks.
- [Credential Propagation Across Agent Hops: Exchange, Audience and Depth](https://changegamer.ai/articles/credential-propagation-across-agent-hops.md): How to carry authority through a chain of delegating agents: why forwarding a token fails, per-hop RFC 8693 exchange with act and may_act, RFC 8707 audience binding, a worked sequence and a failure walk-through.
- [How to Verify a Remote A2A Agent Before Delegating](https://changegamer.ai/articles/trusting-a-remote-agent.md): What a signed Agent Card proves and does not, how domain, key and ERC-8004 identity differ, where Web Bot Auth fits, and why card text and returned artifacts are untrusted input, ending in an ordered checklist.
- [How Do Agents Discover A2A Agents Without a Standard Registry?](https://changegamer.ai/articles/a2a-agent-discovery-without-a-registry.md): The three discovery strategies in the A2A documentation, why the spec prescribes no registry API, what vendor registries fill the gap, and how to choose between a well-known URI, a registry and direct configuration.
- [Migrate A2A v0.3 to v1.0: An Ordered Checklist for Clients and Servers](https://changegamer.ai/articles/a2a-v0-3-to-v1-0-migration.md): An ordered checklist for moving an A2A client or server from v0.3 to v1.0: the A2A-Version header rule, method names, Part shape, a runnable grep check, and symptom-to-cause pointers.
- [Failed or Rejected Remote A2A Task: Retry, Degrade or Surface?](https://changegamer.ai/articles/failure-handling-across-agent-boundaries.md): How to decide what happens after a remote A2A task ends badly: the side-effects test that splits failed into retry or surface, why rejected is not a retry case, why input-required is not a failure, and a structured result for the caller.
- [A2A Production Launch Checklist: Gates to Pass Before You Ship](https://changegamer.ai/articles/a2a-production-launch-checklist.md): A go/no-go checklist for launching A2A agent-to-agent delegation, one line per gate, each pointing to the article that owns the detail: need, card, states, binding, auth, trust, versioning, failure.

## Reference resources

- https://changegamer.ai/resources/agent-frameworks-compared.md
- https://changegamer.ai/resources/a2a-protocol.md

All guides: https://changegamer.ai/api/articles.json · Reference corpus: https://changegamer.ai/llms.txt
Licensing: https://changegamer.ai/api/pricing.json (offer catalog) · https://changegamer.ai/api/payment.json (payment methods, HTTP 402 flow) · access guide: https://changegamer.ai/resources/access-and-pricing.md
