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.
- 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 (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, and for whether you need A2A at all, see 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.
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, 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.
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 and compared in the bindings article.
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.
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.
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.
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".
# 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.
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.
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.
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.
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.