# A2A Task States and Operations: What Each State Means for an Orchestrator

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

Guide: A2A in practice: agent-to-agent interoperability — part 3
Published: 2026-11-01 · Updated: 2026-11-01 · 1162 words · ~1545 tokens (estimate)
Canonical: https://changegamer.ai/articles/a2a-task-lifecycle
JSON: https://changegamer.ai/api/articles/a2a-task-lifecycle.json
Access: free — editorial guide, not part of the licensed corpus
Pillar: https://changegamer.ai/articles/a2a-protocol-in-practice.md

## In short

- The A2A v1.0 TaskState enumeration has eight values: 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.
- In A2A, completed, failed, canceled and rejected are terminal task states, and calling Subscribe to Task on a terminal task returns UnsupportedOperationError.
- The A2A states TASK_STATE_INPUT_REQUIRED and TASK_STATE_AUTH_REQUIRED pause the task for the client, so, as inference, an orchestrator that treats every non-completed task as a failure can misreport recoverable pauses.
- The A2A specification defines eleven operations, including Send Message, Get Task, List Tasks, Cancel Task and Subscribe to Task, and List Tasks arrived with v1.0.0 on 12 March 2026.
- The A2A reference in the ChangeGamer corpus records the four push-notification config operations but not delivery, retry or authentication semantics, so none of those can be assumed from this article.

---

The A2A task lifecycle is eight named states and eleven operations, and the useful design question is what your calling agent does when it sees each state. The [A2A protocol reference](/resources/a2a-protocol) (updated 27 October 2026) holds the contract; this article reads it as an orchestrator author would. For the protocol overview, start with [the A2A protocol in practice](/articles/a2a-protocol-in-practice), and for whether you need A2A at all, see [Do you need A2A?](/articles/do-you-need-a2a).

Dated facts first: per the project's releases page, v1.0.0 shipped on 12 March 2026 and the v1.0.1 patch on 28 May 2026. The reference was fetched on 7 October 2026, checked again on 9 October 2026, and one of its sources is the specification's main branch, which the reference says may be ahead of v1.0.1. Confirm any string you hard-code against the version you target.

## What are the A2A task states?

The eight `TaskState` values in A2A are spelled `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") as of v1.0. The pillar already groups the same eight values in [its lifecycle section](/articles/a2a-protocol-in-practice), so this article does not repeat that table.

What the reference does not give is just as important. It does not define the difference between submitted and working, and it does not describe a transition graph or say which operation moves a task into which state. This article therefore makes no claim about any of those; read the specification before you encode a state machine.

## What are the A2A operations?

Eleven operations make up the specification: Send Message and Send Streaming Message start work, Get Task, List Tasks, Cancel Task and Subscribe to Task act on tasks, four Push Notification Config operations (Create, Get, List, Delete) manage callbacks, and Get Extended Agent Card fetches the fuller card. List Tasks, with filtering and pagination, arrived with v1.0.0; the reference does not list the pagination parameters, so they are not covered here.

Each operation has a per-binding spelling (for example `SendMessage` in JSON-RPC and `POST /message:send` over HTTP+JSON), listed in [the A2A protocol reference](/resources/a2a-protocol) and compared in [the bindings article](/articles/a2a-bindings-json-rpc-grpc-rest).

Older posts show `message/send` and `message/stream`; those are the v0.3-era JSON-RPC spellings, so check the `A2A-Version` you target. How the bindings differ is a separate topic, and the extended card belongs to [the Agent Card design article](/articles/a2a-agent-card-design).

## What is the difference between interrupted and terminal states?

A terminal state ends the task, while an interrupted state pauses it for the client. The reference lists four terminal states (completed, failed, canceled, rejected) and says the two `*_REQUIRED` states, `TASK_STATE_INPUT_REQUIRED` and `TASK_STATE_AUTH_REQUIRED`, pause the task for the client.

One operation-level consequence is grounded: Subscribe to Task on a terminal task returns `UnsupportedOperationError`. A client that opens a subscription after the task has finished therefore gets that error.

Two points are inference, not spec text. First, because the error is documented for Subscribe to Task, a client that may arrive late should expect to learn the outcome with Get Task instead of a subscription. Second, the reference itself groups the two paused states as "interrupted" versus terminal. Which operation resumes a paused task, and what the client must send, is not in the reference, so it is not described here.

## What should an orchestrator do in each A2A state? (inference)

An orchestrator should map each state to exactly one of four reactions: surface, wait, ask the user, or escalate. The mapping below is inference, not spec text, and it contains no retry or backoff policy; failure handling is a separate topic of this cluster.

| State | Reaction | Why (inference) |
|---|---|---|
| `TASK_STATE_SUBMITTED` | Wait | The task exists and has not finished, so nothing is yet wrong or ready |
| `TASK_STATE_WORKING` | Wait | Same reaction; show progress if you have it |
| `TASK_STATE_INPUT_REQUIRED` | Ask the user | The reference says the task is paused for the client, and (inference) the missing piece is information |
| `TASK_STATE_AUTH_REQUIRED` | Supply credentials you are authorised to give; escalate otherwise | Credentials are a decision for whoever holds authority; the auth flow is not covered here |
| `TASK_STATE_COMPLETED` | Surface | Return the result to the caller |
| `TASK_STATE_FAILED` | Surface | Report the failure with the task identity; do not hide it behind a generic message |
| `TASK_STATE_CANCELED` | Surface | Report that it was canceled; the reference does not say who canceled it |
| `TASK_STATE_REJECTED` | Surface | Report that the remote agent declined the task; the reference does not define its reasons |

The sentence that matters most is the split between the two waiting states and the two paused ones. An orchestrator that treats every non-completed task as an error turns recoverable pauses into failures, which is the mistake the pillar warns about. As inference, an orchestrator that only waits can stall on a task that is waiting for it.

### Keeping the handler honest

Write the handler as an exhaustive switch over the eight strings, so that a ninth value in a later spec version fails loudly in a test instead of falling through to "working".

```bash
# Check your own client source for all eight strings (run in your repo)
for s in SUBMITTED WORKING COMPLETED FAILED CANCELED REJECTED INPUT_REQUIRED AUTH_REQUIRED; do
  grep -rq "TASK_STATE_$s" src/ && echo "handled: TASK_STATE_$s" || echo "MISSING: TASK_STATE_$s"
done
```

This only checks that each string appears somewhere. It does not prove the branch is correct, and it will not catch a British spelling elsewhere in your code, so also grep for `CANCELLED`.

## Does A2A support push notifications for task updates?

A2A has four push-notification config operations (Create, Get, List and Delete Push Notification Config) and a `pushNotifications` capability in the Agent Card's `capabilities` block. That is all the corpus records. Delivery semantics, retry behavior on a failed callback and how the callback is authenticated are not in the reference, so this article states none of them; read the specification before relying on push for anything important.

Inference: push notifications are the obvious candidate for work that outlives a held-open stream, but the capability flag only tells a client whether the agent claims to support them. Check the card before you register a config.

## Does ChangeGamer implement A2A tasks?

No. As of 1 November 2026, ChangeGamer implements no A2A task endpoint: a grep for `SendMessage`, `SendStreamingMessage`, `GetTask`, `CancelTask`, `message:send` and `TASK_STATE` across `changegamer/src/pages`, `src/lib`, `src/layouts`, `src/components`, `worker/` and `public/` returns zero matches. Those strings appear in the site's content data, not in any request handler. The site speaks MCP, not A2A, so everything in this article about handling states is reasoning from the reference, not from a production run.

The rule to take from that is the same as for the card: build the state handler once you operate or call a real A2A agent, and test it against that agent's actual behavior. For the card side, see [designing an Agent Card](/articles/a2a-agent-card-design).

## Frequently asked questions

### Which handler should an orchestrator run for each A2A task state?

A2A v1.0 defines eight TaskState values: 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.

### Which A2A task states are terminal?

The terminal A2A task states are completed, failed, canceled and rejected. The two states ending in REQUIRED are not terminal: they pause the task for the client, which is why they are called interrupted states.

### What happens if you subscribe to a finished A2A task?

Calling Subscribe to Task on a task in a terminal state returns UnsupportedOperationError, according to the A2A reference in the ChangeGamer corpus. The reference does not describe what a client should do instead, so check the specification for that.

### How many operations does A2A define?

The A2A 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 arrived with v1.0.0.


---

## 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 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.
- [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/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
