# A2A Production Launch Checklist: Gates to Pass Before You Ship

> 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.

Guide: A2A in practice: agent-to-agent interoperability — part 12
Published: 2026-11-10 · Updated: 2026-11-10 · 1147 words · ~1526 tokens (estimate)
Canonical: https://changegamer.ai/articles/a2a-production-launch-checklist
JSON: https://changegamer.ai/api/articles/a2a-production-launch-checklist.json
Access: free — editorial guide, not part of the licensed corpus
Pillar: https://changegamer.ai/articles/a2a-protocol-in-practice.md

## In short

- An A2A launch is ready when ten gates pass in order: need, card, task states, binding, authentication, credential hops, version, trust, discovery and failure handling, and the ordering is inference rather than specification text.
- The first A2A launch gate is whether you need the protocol at all, because in-process delegation under one set of credentials is the default and a network protocol has to earn its place (inference).
- Signing an A2A Agent Card is optional under the A2A protocol reference, so an unsigned card is not a launch blocker for a publisher but proves nothing about who published it to a client.
- ChangeGamer speaks MCP and not A2A, and as of 10 November 2026 its site source publishes no agent-card.json under its well-known directory.
- Running an MCP server is not A2A work, because MCP connects an agent to tools and data while A2A connects an agent to a peer agent.

---

An A2A launch is ready when every gate below passes, and each gate is one line here because a sub-article owns the reasoning. The ten-gate grouping and its order are inference, not A2A specification text. The facts come from the ChangeGamer A2A protocol reference (last updated 27 October 2026, with v1.0.0 released on 2026-03-12). For the full guide, start at [A2A protocol in practice](/articles/a2a-protocol-in-practice).

## What does ChangeGamer itself run?

ChangeGamer speaks MCP and does not speak A2A. On 10 November 2026 the `src/pages/.well-known` directory of this site's source contained four published paths and none of them is an Agent Card.

```bash
ls changegamer/src/pages/.well-known
# agent-access.json.ts  api-catalog.ts  mcp  mcp.json.ts
ls changegamer/src/pages/.well-known/mcp
# server-card.json.ts
```

There is no `agent-card.json`, so this checklist is written as an operator's reading of the cluster, not as a record of ChangeGamer shipping A2A. Nothing here claims how many production systems use A2A, because no source in the corpus gives that figure.

## Is running an MCP server A2A work?

No, running an MCP server is not A2A work, and finishing one does not discharge a single gate below. MCP connects an agent to tools and data, while A2A connects an agent to a peer agent, as the [MCP vs A2A reference](/resources/mcp-vs-a2a) records. If your need is exposing tools, the playbook is [MCP server in production](/articles/mcp-server-in-production). The two can run side by side, and the choice between them is the first gate.

## Which gates come before any code?

Three gates come first: need, card and task states, in that order (inference).

1. **Need.** Delegation stays in-process unless the peer is another organization, another framework or behind a trust boundary: [do you need A2A](/articles/do-you-need-a2a). The [orchestration patterns reference](/resources/multi-agent-orchestration-patterns) says to start with one agent.
2. **Card.** The public card holds only what a stranger needs, the rest waits for the extended card: [Agent Card design](/articles/a2a-agent-card-design).
3. **States.** Your orchestrator has a handler for each of the eight task states, and pauses are not failures: [task states and operations](/articles/a2a-task-lifecycle).

If gate 1 fails, stop. Nothing after it is needed.

## Which gates cover the wire and the caller's identity?

Four gates cover the binding, authentication, credential hops and the version, and each has one decision.

4. **Binding.** One binding chosen from the infrastructure you already run, with behavior kept equivalent if you offer more than one: [JSON-RPC vs gRPC vs REST](/articles/a2a-bindings-json-rpc-grpc-rest).
5. **Authentication.** The schemes in the card match who the caller acts for: [authentication schemes](/articles/a2a-authentication-schemes).
6. **Credential hops.** Each hop receives a narrower token aimed at the next hop and never the one it was handed: [credential propagation](/articles/credential-propagation-across-agent-hops).
7. **Version.** The version header is set to 1.0 explicitly, and any v0.3 peer sits behind a check: [v0.3 to v1.0 migration](/articles/a2a-v0-3-to-v1-0-migration).

## How do you decide whether to trust a remote agent?

You decide with a verification routine you can run, because the card alone is a self-published claim. Card signing is optional in the A2A protocol reference, so a client cannot require it of a spec-compliant peer (inference; it can still choose not to delegate to unsigned ones).

8. **Trust.** Publisher checked, card text and returned output both treated as untrusted: [verify a remote agent](/articles/trusting-a-remote-agent).
9. **Discovery.** You know how agents find yours and how you find theirs, given that the specification prescribes no registry API (checked against the specification's discovery topic on 6 November 2026, as recorded in that article): [discovery without a registry](/articles/a2a-agent-discovery-without-a-registry).

## What must be true about failure before launch?

Before launch, every terminal outcome of a remote task must map to a named action, and that mapping is gate 10.

10. **Failure.** Failed, rejected and canceled each have a branch, and retries happen only for side-effect-free work: [failure handling across agent boundaries](/articles/failure-handling-across-agent-boundaries).

If you adopt a framework to get here, confirm its A2A claim with a live call: [framework support](/articles/agent-frameworks-with-a2a-support).

## How do you smoke-test a published card before announcing it?

Fetch the card from the well-known path the specification requires and read it as a stranger would, before anyone else does. The A2A protocol reference says an agent MUST publish its card at `/.well-known/agent-card.json`; the host below is a placeholder.

```bash
curl -sS -f -i https://agent.example.com/.well-known/agent-card.json | head -40
curl -sS https://agent.example.com/.well-known/agent-card.json | python3 -m json.tool > /dev/null && echo "valid JSON"
```

Three things to look for in the output (inference, a reviewer's habit and not a spec test): the response is public JSON without credentials, nothing in it would embarrass you in a search result, and the interfaces and security schemes listed are the ones you actually run. Sensitive detail belongs behind authentication, which is the extended-card split from gate 2.

## What should the launch review record?

The launch review should record, per gate, who passed it, on what date and against which protocol version, so a later change can be compared with the state you shipped (inference). A short record is enough:

- Which A2A version you target and the date you last read the specification, since the corpus reference dates from 27 October 2026 and can age.
- The binding, the declared security schemes and whether the card is signed.
- The remote agents you call, who publishes each, and how you checked.
- The action chosen for each terminal task state.
- The named owner who is paged when a remote task misbehaves.

Re-run the gates when the card, the version or a peer changes, not only at first launch. The [orchestration patterns reference](/resources/multi-agent-orchestration-patterns) warns that one failing subagent may quietly corrupt what runs downstream, which is the cost a stale gate lets through.

## What is the one-page version?

The one-page version is a table you can paste into a launch ticket, with a pass condition per gate.

| Gate | Pass condition | Owner |
|---|---|---|
| Need | A named reason in-process delegation fails | [do-you-need-a2a](/articles/do-you-need-a2a) |
| Card | Public card reviewed for what a stranger sees | [card design](/articles/a2a-agent-card-design) |
| States | Handler for all eight states | [task lifecycle](/articles/a2a-task-lifecycle) |
| Binding | One binding live and tested | [bindings](/articles/a2a-bindings-json-rpc-grpc-rest) |
| Authentication | Card schemes match real callers | [authentication](/articles/a2a-authentication-schemes) |
| Credential hops | No token forwarded unchanged | [propagation](/articles/credential-propagation-across-agent-hops) |
| Version | Explicit 1.0 header sent | [migration](/articles/a2a-v0-3-to-v1-0-migration) |
| Trust | Output validated before use | [verification](/articles/trusting-a-remote-agent) |
| Discovery | Card location known to callers | [discovery](/articles/a2a-agent-discovery-without-a-registry) |
| Failure | Branch per terminal state | [failure handling](/articles/failure-handling-across-agent-boundaries) |

## What is not covered by any gate?

No gate here covers adoption, performance or cost of A2A in production, because the ChangeGamer corpus holds no independent measurement of production use as of 10 November 2026; its only adoption figure is the unsourced "150+ organizations" count in [mcp-vs-a2a](/resources/mcp-vs-a2a). The pass conditions in the table are inference: the specification defines the protocol, and it does not define a launch standard.

## Frequently asked questions

### What should be on an A2A production launch checklist?

An A2A production launch checklist should cover ten gates: whether you need A2A, the Agent Card, task states, the binding, authentication, credential propagation, the protocol version, trust in remote agents, discovery, and failure handling. The grouping and order are inference, not A2A specification text.

### Is an MCP server enough to count as supporting A2A?

An MCP server does not count as supporting A2A, because the two protocols solve different problems. MCP gives an agent tools and data, and A2A lets one agent delegate a task to another agent, so an MCP server publishes no A2A Agent Card.

### Do you have to sign an A2A Agent Card before launch?

No, signing an A2A Agent Card is optional according to the A2A protocol reference in the ChangeGamer corpus. A publisher can launch with an unsigned card, but clients should then treat the card as an unverified claim about the endpoint (inference).

### Which A2A protocol version should a new launch target?

A new A2A launch should target v1.0, which the A2A protocol reference records as released on 12 March 2026. Send the version header explicitly, because an empty value is interpreted as 0.3 under the specification.


---

## 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.
- [Does Your Agent Framework Really Support A2A? How to Read the Claim and What to Test](https://changegamer.ai/articles/agent-frameworks-with-a2a-support.md): 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.
- [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.

## Reference resources

- https://changegamer.ai/resources/a2a-protocol.md
- https://changegamer.ai/resources/multi-agent-orchestration-patterns.md
- https://changegamer.ai/resources/mcp-vs-a2a.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
