ChangeGamer

A2A Production Launch Checklist: Gates to Pass Before You Ship

Part 12 of A2A in practice: agent-to-agent interoperability · 1,147 words · ~5 min read · published · updated · Markdown variant

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.

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.

Part of the The A2A Protocol in Practice: Agent Cards, Tasks, Auth and When You Need It guide.


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.

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.

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 records. If your need is exposing tools, the playbook is 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. The orchestration patterns reference 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.
  3. States. Your orchestrator has a handler for each of the eight task states, and pauses are not failures: task states and operations.

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.

  1. 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.
  2. Authentication. The schemes in the card match who the caller acts for: authentication schemes.
  3. Credential hops. Each hop receives a narrower token aimed at the next hop and never the one it was handed: credential propagation.
  4. 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.

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

  1. Trust. Publisher checked, card text and returned output both treated as untrusted: verify a remote agent.
  2. 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.

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.

  1. Failure. Failed, rejected and canceled each have a branch, and retries happen only for side-effect-free work: failure handling across agent boundaries.

If you adopt a framework to get here, confirm its A2A claim with a live call: framework 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.

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:

Re-run the gates when the card, the version or a peer changes, not only at first launch. The orchestration patterns reference 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
Card Public card reviewed for what a stranger sees card design
States Handler for all eight states task lifecycle
Binding One binding live and tested bindings
Authentication Card schemes match real callers authentication
Credential hops No token forwarded unchanged propagation
Version Explicit 1.0 header sent migration
Trust Output validated before use verification
Discovery Card location known to callers discovery
Failure Branch per terminal state failure handling

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

#a2a #agent2agent #checklist #launch #production #multi-agent

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)