ChangeGamer

The A2A Protocol in Practice: Agent Cards, Tasks, Auth and When You Need It

Pillar guide · A2A in practice: agent-to-agent interoperability · 4,151 words · ~19 min read · published · updated · Markdown variant

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.

In short

  • The A2A (Agent2Agent) protocol is an open standard that lets agents built on different frameworks discover each other through an Agent Card, exchange messages and track delegated work as tasks, without sharing code or internals.
  • A2A is not a replacement for MCP: MCP connects an agent to tools and data, A2A connects an agent to another agent, and the reference implementations ship both at different layers; how many production systems do so is not measured in the corpus.
  • Subagents inside one codebase usually do not need A2A, because, in our reading (inference), the protocol earns its cost only when the remote agent is owned by another team or vendor, runs in another framework, or must be reached across a network boundary.
  • An A2A task has eight states, of which completed, failed, canceled and rejected are terminal while input-required and auth-required pause the task and wait for the calling client.
  • A2A v1.0.0 was released on 12 March 2026 and changed names, part encoding and operations from v0.3, so a client that sends an empty A2A-Version header gets v0.3 behavior, not v1.0.
  • As of June 2026 (WebSearch-sourced in the corpus) no canonical A2A agent registry exists, Agent Card signing is optional, and an unsigned card proves nothing about who published it, so trust in a remote agent has to be built outside the protocol.

A2A, short for Agent2Agent, is an open protocol for communication between opaque agentic applications: an agent built on one framework discovers another agent through a published Agent Card, sends it messages, and follows the delegated work as a task with a defined lifecycle. This guide covers the decisions around it, from whether to adopt it to how to launch it.

The protocol's wire contract is already written down in the A2A protocol reference, and the protocol-versus-protocol comparison lives in MCP vs A2A. This article does the other job: it walks through the choices an operator makes, in the order they come up, and marks where the evidence runs out.

What is the A2A protocol, and what does it standardize?

The A2A protocol standardizes three things: how a calling agent discovers a remote agent, how work is handed over and tracked, and what the messages look like on the wire. Everything else, including how the remote agent reasons, which model it uses and which tools it calls, is deliberately opaque to the caller.

The corpus summarizes the relationship as peer-to-peer: the delegating agent is the client, it sends a task, it receives status updates and it gets a result. The caller does not know or care how the remote agent is built. That opacity is the point, because it lets agents from different vendors interoperate without shared code, and it is also the source of most of the operational problems covered below, since you cannot inspect what you cannot see.

Per the A2A reference in this site's corpus, the project's releases page lists v1.0.0 (12 March 2026), v1.0.1 (28 May 2026, bug fixes, preferring application/a2a+json in the HTTP binding) and the earlier v0.3.0 (30 July 2025). The licence is Apache 2.0, the project sits under the Linux Foundation, and it was contributed by Google. The README lists SDKs for Python, Go, JavaScript, Java, .NET and Rust. As of the 9 October 2026 re-verification, the specification page at a2a-protocol.org labeled 1.0.0 as the latest released version, and the GitHub releases page also lists the 1.0.1 patch; those are the sources the reference was verified against on 7 and 9 October 2026.

The core objects are few:

Anything that sounds like a registry, a payment rail or a trust framework is not part of that list. Those gaps come back in the discovery and trust sections.

Does A2A replace MCP?

A2A does not replace MCP, because the two protocols govern different layers: MCP connects an agent to tools and data, while A2A connects an agent to another agent. The mcp-vs-a2a resource states it flatly, saying that confusing the two, by expecting MCP to handle inter-agent delegation or A2A to handle tool access, is the most common architecture mistake in multi-agent systems.

The composition pattern the resource describes is a five-step flow. An orchestrator receives a task from a user, delegates a sub-task to a specialist over A2A, the specialist fetches context such as CRM records or documents through MCP tool calls, the specialist returns its result over A2A, and the orchestrator synthesizes the answer. Each layer stays inside its own protocol.

The resource also records that Microsoft Azure AI Foundry and Copilot Studio explicitly support both protocols at once, confirmed at Microsoft Build 2025, and that the reference implementations for Google ADK, AWS Strands and Microsoft Agent Framework use both. It dismisses the "MCP already does multi-agent" argument too: MCP's sampling capability lets a server request an LLM inference from the client, but it does not define task lifecycle, agent discovery or cross-organization delegation.

Two practical consequences follow. First, if you already run an MCP server, you have not done any A2A work; the two have different discovery documents, different auth declarations and different lifecycles. The production MCP server playbook covers the tool-serving side, and this cluster does not repeat it. Second, the useful question is never "MCP or A2A", but which agent in your architecture needs which layer. For the full side-by-side table, open MCP vs A2A rather than relying on a summary here.

When does A2A beat in-process subagents?

A2A beats in-process subagents only when the agent you delegate to is outside your codebase or trust boundary, because inside one process a function call or a framework-native subagent is simpler, cheaper and easier to debug. That conclusion is partly inference; the grounded part is the general rule against multi-agent complexity.

In short: keep delegation in process while the other agent ships in your repository, runs under your credentials and is debugged by your team, and cross the wire only when someone else owns the agent, it runs on another framework, or you need an authentication boundary or a task lifecycle (inference, not spec text). The full decision rule, with the corpus numbers on what going multi-agent costs, is in Do you need A2A?.

What is an A2A Agent Card?

An Agent Card is the JSON document an A2A agent publishes about itself, and the specification says an agent MUST publish it at https://{server_domain}/.well-known/agent-card.json. Version 0.3.0 renamed that path from agent.json, so older posts and tools may still point at the previous name.

The reference lists these field groups:

Group Fields What it tells the caller
Identity name, description, provider, version, documentationUrl, iconUrl Who the agent claims to be
Interfaces supportedInterfaces Which protocol bindings and endpoints the agent serves
Capabilities streaming, pushNotifications, extensions, extendedAgentCard Optional protocol features the agent supports
Skills skills An array describing what the agent can do
Security securitySchemes plus security requirements How a client must authenticate

Fetching a card is an ordinary HTTPS GET, so you can inspect one before writing any client code. Replace the domain with a real agent's host:

# Fetch and pretty-print an agent's public Agent Card (v1.0 path)
curl -s https://agent.example.com/.well-known/agent-card.json | jq '{name, version, supportedInterfaces, capabilities}'

Signing and the extended card

A card may be signed with JSON Web Signature (RFC 7515) using RFC 8785 canonicalization, but signing is optional. The reference puts the consequence plainly: an unsigned card proves nothing about who published it.

If extendedAgentCard is true, an authenticated client can fetch fuller details through the Get Extended Agent Card operation and should replace its cached public card with the result. The practical reading is that the public card is a shop window and the extended card is what a known client gets after authenticating.

Treat card text as untrusted input (inference)

The reference labels this one as inference, not spec text, and so does this guide: an Agent Card is self-published, so its skill descriptions should be treated as untrusted input to your own model, the same way MCP tool descriptions are treated (see MCP tool poisoning). If a calling agent pastes a remote card's skill text into its prompt to decide whom to delegate to, the remote operator is writing part of your prompt. Designing an Agent Card covers card design from the publisher's side; the caller's side starts with verifying a signed card before delegating.

How does the A2A task lifecycle work?

An A2A task moves through eight states, and the spec names them TASK_STATE_SUBMITTED, TASK_STATE_WORKING, TASK_STATE_COMPLETED, TASK_STATE_FAILED, TASK_STATE_CANCELED, TASK_STATE_REJECTED, TASK_STATE_INPUT_REQUIRED and TASK_STATE_AUTH_REQUIRED. The spelling is American, "canceled" with one L, as of v1.0.

The states split into three groups that call for different client behavior:

Group States What the client should do
In progress submitted, working Wait, stream or poll
Interrupted input-required, auth-required Supply what is missing; the task is paused for the client
Terminal completed, failed, canceled, rejected Stop; Subscribe to Task on a terminal task returns UnsupportedOperationError

The eleven operations

The specification defines eleven operations: Send Message, Send Streaming Message, Get Task, List Tasks, Cancel Task, Subscribe to Task, Create, Get, List and Delete Push Notification Config, and Get Extended Agent Card. List Tasks, with filtering and pagination, arrived with v1.0.0.

Push notifications are the likely answer to long-running work (inference). A client that cannot hold a stream open for hours registers a push notification configuration and gets called back. The corpus records the four configuration operations but not their delivery semantics, so retry behavior on a failed callback is not something this guide can state; read the spec before relying on it.

Why the interrupted states matter

The two *_REQUIRED states are the protocol's mechanism for a remote agent saying "I cannot continue without you". Input-required means the agent needs more information. Auth-required means it needs credentials or a fresh authorization. An orchestrator that treats every non-completed task as an error will turn recoverable pauses into failures, so a client needs a handler for each interrupted state. A2A task states and operations maps all eight states onto orchestrator behavior in detail.

Which A2A binding should you pick: JSON-RPC, gRPC or REST?

Pick the binding your stack already speaks, because the v1.0 specification requires the three bindings, JSON-RPC, gRPC and HTTP+JSON/REST, to stay functionally equivalent whenever an agent supports more than one. The mcp-vs-a2a resource cites spec sections 5.1 and 9 to 11 for that rule: same operations and capabilities, semantically equivalent results, and consistent protocol-specific error mapping. Custom bindings are also allowed.

The binding choice is mostly about your infrastructure, not about what you can do. A2A JSON-RPC vs gRPC vs REST compares the three, shows the corpus-listed spellings and carries the caveat that real-world binding share could not be confirmed.

How does A2A authentication work?

A2A authentication is declared by the remote agent in its Agent Card, using securitySchemes plus security requirements, and the client must satisfy them before calling. The reference lists the supported scheme families: API key, HTTP auth, OAuth 2.0, OpenID Connect and mutual TLS. The mcp-vs-a2a resource summarizes the model as OpenAPI-style security schemes declared per agent, in contrast to MCP, where OAuth 2.1 with PKCE is mandatory for HTTP transports.

Version 1.0.0 modernized the OAuth 2.0 flows, adding device code and PKCE. Beyond that, the corpus does not spell out which scheme production agents choose in practice, and this guide will not guess.

Where authentication shows up in the protocol

Three places matter to an implementer:

What authentication does not settle

Authenticating to a remote agent proves the caller to the callee. It does not prove the callee to the caller, because a self-published, unsigned card says nothing about who runs the endpoint. For that direction, see the discovery and trust section below. It also does not decide whose authority the remote agent acts under when it calls onward, which is the credential-propagation problem in the next section. The single-agent foundations, workload identity and delegated authority, are covered in how AI agents prove identity and delegated authority; A2A authentication schemes covers the A2A-specific scheme choices.

How do credentials propagate across agent hops?

Credentials should not be forwarded along a delegation chain; each hop exchanges the token it received for a new, narrower one aimed only at the next service. A2A itself declares security schemes on the card and does not enforce this, so token exchange between hops is an OAuth practice you layer on top (inference). The credential propagation article covers the mechanisms, guardrails and open drafts step by step.

How do you trust a remote A2A agent?

Finding an agent is covered in how agents discover A2A agents without a registry: a card is fetched from the agent's own domain, so you must already know the domain. Trust is the separate question below.

What the protocol gives you for trust, and what it does not

The protocol gives you TLS-reachable endpoints, declared security schemes and an optional signature on the card. It does not give you a way to know that a remote agent is competent, honest or the entity it claims to be. The reference's own wording is that signing is optional and an unsigned card proves nothing about who published it.

For cross-organization identity and reputation, the corpus points to a Draft Ethereum standard, ERC-8004, that references MCP and A2A endpoints. It is a Draft, so treat it as something to watch and not as infrastructure to depend on in October 2026.

A practical trust checklist (inference)

These steps are inference, assembled from the sources above:

  1. Pin the domain you delegate to in configuration; do not accept a card URL from model output.
  2. Prefer a signed card, and verify the signature before first use.
  3. Treat skill descriptions as untrusted text, as described earlier.
  4. Give the remote agent only the data it needs for the task; the delegation-chain guidance applies in both directions.
  5. Keep an allowlist of agents your orchestrator may call, and log every delegation.

How to verify a remote A2A agent expands this into a verification routine.

What changed between A2A v0.3 and v1.0?

Moving from A2A v0.3 to v1.0 changed names, part encoding, version negotiation and the operation set, so a v0.3 client does not work unchanged against a v1.0 server. The a2a-protocol reference lists the changes it verified; this guide restates only those.

Area v0.3 v1.0
JSON-RPC methods message/send, message/stream SendMessage, SendStreamingMessage
Parts Explicit kind field Discriminated by member name, such as {"text": "..."}
Operations No List Tasks List Tasks added, with filtering and pagination

The card path is a separate rename that predates v1.0: v0.3.0 moved it from agent.json to /.well-known/agent-card.json. Version 1.0.0 also modernized the OAuth 2.0 flows (device code and PKCE), and the task-state spelling is American, "canceled".

The version header trap

Clients send an A2A-Version header in Major.Minor format, or the same name as a request parameter. Servers answer with VersionNotSupportedError for versions they do not support, and patch numbers are not part of negotiation. The sharp edge: an empty header value is interpreted as 0.3, so a v1.0 client that sends an empty header silently gets v0.3 semantics.

That is a debugging trap, not a theoretical one. If a v1.0 client appears to work but sees old method names or part shapes, check what it is actually putting in the header before blaming the server.

Migration sequencing (inference)

The ordering below is inference. Upgrade the publisher first, because a v1.0 card and endpoint can be read by clients you control; then upgrade clients, set the header explicitly, and keep v0.3 behind a version check only as long as a real caller needs it. The v0.3 to v1.0 migration checklist is the full walkthrough.

Which agent frameworks support A2A?

Support varies by framework: per the agent-frameworks-compared resource, A2A support is listed for Google ADK, CrewAI, Microsoft Agent Framework, AWS Strands Agents, LlamaIndex Workflows, Pydantic AI and Mastra, while LangGraph and the OpenAI Agents SDK are the exceptions. The resource's package-registry versions were re-verified on 28 September 2026, and its table facts were described as holding on that date; the GitHub repository pages were not independently re-fetched.

Framework A2A status as recorded
Google ADK Native; auto-generates an Agent Card; described as the strongest A2A first-mover
CrewAI Yes
Microsoft Agent Framework Yes, 1.0 in April 2026; Python and .NET agents interoperate via A2A
AWS Strands Agents Yes, SDK 1.0 in May 2026
LlamaIndex Workflows Native, built into LlamaIndex Agents in 2026
Pydantic AI Via fasta2a; Agent.to_a2a() deprecated and removed in v2.0
Mastra Native, May 2026
LangGraph Via LangSmith Deployment; not available in the open-source library alone
OpenAI Agents SDK No: handoffs only, no cross-vendor A2A

Two cautions apply. Framework support is a vendor-side statement of capability, not a conformance result: the corpus contains no interoperability test between any two of these. And the table reflects one verification date, so re-check the framework's own documentation before pinning a choice. If your framework lacks A2A, the SDKs listed on the A2A project's README (Python, Go, JavaScript, Java, .NET, Rust) are the alternative to wiring the protocol by hand. Does your agent framework really support A2A? regroups this table by mechanism and gives a short test to run before relying on a listed claim.

How do you handle failures across an agent boundary?

Handle a remote agent's failure by mapping each A2A task state to a distinct orchestrator action and returning structured success or failure signals to the caller, not just free text. The structured-signal rule comes from the multi-agent-orchestration-patterns resource, which warns that a subagent failure can silently corrupt downstream results and that orchestrators must handle partial failure by retrying, degrading or surfacing the gap.

The mapping below is inference. The corpus defines the states but contains no A2A-specific retry or idempotency semantics, so the actions are reasoning, not spec guidance:

Task state Reasonable orchestrator action (inference)
failed Decide retry or degrade; do not retry blindly if the remote agent had side effects
rejected The remote agent declined; try another agent or surface the refusal, rather than resending the same task
canceled Usually the result of your own cancel; clean up and record it
input-required Supply the missing input or ask the user; not an error
auth-required Re-authorize and resume; not an error

Retries, timeouts and partial failure

Three adjacent topics have their own deep dives on this site, and A2A adds no spec-level answers to them. For safe retries, see how to make AI agent retries idempotent. For deadlines across hops, see how to set timeouts for AI agent tool calls. For tracing a run that spans agents, see distributed tracing for multi-agent AI systems, which also separates handoff from delegation.

The orchestration resource reaches the same conclusion on observability: a shared trace ID must be propagated across all subagent calls, or cross-agent debugging is impossible. Across an A2A boundary you also need the remote operator to propagate or return something you can correlate; whether A2A carries trace context is not covered by the sources in the corpus, so check the spec and agree it with the remote party.

Treat the remote agent as untrusted input

The orchestration resource also says subagents are not implicitly trusted: an agent receiving instructions from an orchestrator should apply the same prompt-injection and tool-abuse mitigations as it would for user input. The same logic reverses for results. Extending that to results is inference: output from a remote agent is untrusted content from outside your boundary and should be validated before any downstream step acts on it. Failure handling across agent boundaries covers this in more depth and is the place for the part of this section that remains inference.

What is the state of A2A adoption and governance?

A2A is governed as an open-source project under the Linux Foundation, originated by Google, and the evidence for how widely it is deployed in the corpus is thin and vendor-sourced. The mcp-vs-a2a resource records "150+ organizations" with named adopters including AWS, Azure, Salesforce, SAP and ServiceNow. The resource gives no primary source for that figure, so treat it as an unverified vendor-side claim: the corpus contains no independent measurement of production usage.

On governance, the same resource's table records a prior Linux Foundation donation in June 2025 and A2A as an Agentic AI Foundation (AAIF) hosted project since August 2026, with the join dated 17 August 2026. That AAIF date is WebSearch-corroborated only: the resource cites agreeing reports from Axios, DevOpsDigest and Techstrong.ai, and records that aaif.io and axios.com were unreachable when it was written. This guide repeats it with that qualification and does not treat it as primary-fetched.

What this guide does not claim

This guide makes no claim that demand for A2A is growing, that any binding dominates, or that any particular enterprise runs A2A in production. The corpus supports none of those. The decision to adopt should rest on whether you have a remote agent to talk to, not on a market-momentum argument.

The one stable fact is the version position: v1.0.0 and v1.0.1 are released, v0.3 is the predecessor still seen in older material, and the specification page labeled 1.0.0 as the newest release when the reference was re-verified on 9 October 2026. Re-check the releases page before pinning, because a newer patch may exist by the time you read this.

What does ChangeGamer do about A2A?

ChangeGamer speaks MCP and does not speak A2A, and it publishes no Agent Card. That is checked, not assumed: as of 29 October 2026 the directory changegamer/src/pages/.well-known holds api-catalog.ts, mcp.json.ts and mcp/server-card.json.ts, changegamer/public/.well-known holds agent-access.json and security.txt, and no agent-card.json exists in either place.

The omission is deliberate. The repository's backlog records, in a table dated 16 September 2026 of agent-discovery documents declined on purpose, that the A2A Agent Card would be dishonest to publish without an A2A transport endpoint, and names the MCP server card at /.well-known/mcp/server-card.json as the honest equivalent. The same table notes that an AP2 payments extension entry would be blocked on the A2A card. Publishing a discovery document for a protocol you do not implement sends a client to an endpoint that does not exist.

The repository's in-process subagent definitions are not A2A either; Do you need A2A? walks through that example.

That makes ChangeGamer a poor source for A2A operating numbers, and this guide offers none. Everything above comes from the specification-derived reference and the other four corpus resources.

How do you launch your first A2A integration?

Launch your first A2A integration by shipping one narrow skill behind one binding with authentication on, then widening only when a real caller needs more. The sequence below is inference, assembled from the facts above, and every step has a deeper treatment in the cluster's sub-articles, listed at the end of this page, and the production launch checklist turns the sequence into ten gates.

  1. Prove you need it. Write down which of the four multi-agent conditions applies and which of the four crossing conditions applies. If neither does, stay in process.
  2. Choose the role. Decide whether you are publishing an agent, calling one or both. Publisher work is the card, the endpoint and auth; caller work is discovery, trust and the task state machine.
  3. Pick one binding. Choose the one your infrastructure already operates, list it in supportedInterfaces, and skip the others until needed.
  4. Write the card. Keep skills specific, put real security schemes in it and consider signing it. Remember that callers should treat its text as untrusted.
  5. Implement the whole state machine, not the happy path. Handle input-required and auth-required, cancellation, and rejection, as well as completion.
  6. Set the version header explicitly. Never send an empty A2A-Version, since an empty value means v0.3.
  7. Design credential flow before traffic. Use per-hop token exchange, audience binding, short lifetimes and a hop cap.
  8. Instrument before scaling. Propagate a shared trace ID, log every delegation and keep an allowlist of callable agents.
  9. Test failure on purpose. Force a rejected task, an expired credential and a timeout, and watch what your orchestrator does.

Where this cluster goes next

The rest of this cluster takes these topics one at a time. All twelve sub-articles are published as of 10 November 2026:

  1. Do you need A2A for a multi-agent system?
  2. Designing an Agent Card
  3. A2A task states and operations
  4. A2A JSON-RPC vs gRPC vs REST
  5. A2A authentication schemes
  6. Credential propagation across agent hops
  7. How to verify a remote A2A agent
  8. How agents discover A2A agents without a registry
  9. Migrating A2A v0.3 to v1.0
  10. Does your framework really support A2A?
  11. Failed or rejected remote A2A task
  12. A2A production launch checklist

The reference entries behind them are A2A protocol, MCP vs A2A, multi-agent orchestration patterns and the framework comparison.

Frequently asked questions

What is the A2A protocol?
A2A (Agent2Agent) is an open protocol for communication between opaque agentic applications. Agents built on different frameworks discover each other through a self-published Agent Card at /.well-known/agent-card.json, exchange messages, and track delegated work as tasks with a defined lifecycle. It is licensed Apache 2.0 and hosted under the Linux Foundation.
What is the difference between MCP and A2A?
MCP connects an agent to tools, data and prompt templates in a client/server relationship, while A2A connects an agent to another agent in a peer relationship where one agent hands a task to another and waits for the result. They operate at different layers, and the reference implementations ship A2A between agents and MCP inside each agent; production prevalence is not measured in the corpus.
Which agent frameworks support A2A?
According to the ChangeGamer framework comparison, re-verified on 28 September 2026, Google ADK, CrewAI, Microsoft Agent Framework, AWS Strands Agents, LlamaIndex Workflows, Pydantic AI (via fasta2a) and Mastra list A2A support, LangGraph lists it only through LangSmith Deployment, and the OpenAI Agents SDK lists no A2A support.
What are the A2A task states?
A2A v1.0 defines eight task states: submitted, working, completed, failed, canceled, rejected, input-required and auth-required. Completed, failed, canceled and rejected are terminal, while input-required and auth-required are interrupted states that pause the task until the client supplies input or credentials. The spec uses the American spelling "canceled".

#a2a #agent2agent #protocols #agent-card #multi-agent #interoperability #authentication #production

Put this corpus inside your own agents

This guide is free and stays free. The reference corpus behind it — machine-readable contracts, verified primary sources, continuously refreshed — is the paid product: a €5 starter key unlocks every premium reference for one agent via API; a €25 corpus license delivers the full corpus as RAG / fine-tuning data with an explicit AI-use grant; the €150 enterprise license adds commercial redistribution rights.

Agents: this page as Markdown · JSON · offers at /api/pricing.json · payment methods at /api/payment.json · single-resource access via HTTP 402 (how that works)