ChangeGamer

Failed or Rejected Remote A2A Task: Retry, Degrade or Surface?

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

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.

In short

  • An A2A task can end in four terminal states, completed, failed, canceled and rejected, and treating each failure-like one with its own action instead of one generic error branch is a reasonable design (inference).
  • The INPUT_REQUIRED and AUTH_REQUIRED task states pause a remote A2A task for the client and are not terminal, so they sit outside the failed, rejected and canceled branches this article covers.
  • The ChangeGamer corpus does not say why a remote agent returns the rejected state, so any claim about the cause of a rejection is an assumption to test against that agent.
  • The multi-agent orchestration patterns reference says subagents should return structured success or failure signals and that an orchestrator must retry, degrade or surface the gap on partial failure.
  • Retrying a failed remote task is only safe if the task had no side effects, and that rule is inference rather than A2A specification text.

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


A remote agent can end your task in three different bad ways, and an orchestrator that logs all of them as "error" loses the information it needs to choose its next step. This article is the decision layer. The eight states are defined in task states and operations, the pillar's failure section gives the short mapping, and this article goes one level deeper into what the orchestrator does next.

Scope and dating: the state facts come from the ChangeGamer A2A protocol reference, updated 27 October 2026 (v1.0.0 released 2026-03-12). Every statement about retries, backoff, idempotency and timeouts below is labelled inference, because no source in the corpus defines them for A2A.

How do failed, rejected and canceled differ?

Failed, rejected and canceled are three separate terminal states, and each tells the orchestrator something different about who ended the task. The corpus defines the state names and that all three are terminal; it does not define their causes, so the readings below are inference.

Terminal state Likely meaning (inference) What the outcome leaves unknown
TASK_STATE_FAILED Work was attempted and did not finish Whether anything changed remotely before it stopped
TASK_STATE_REJECTED The remote agent declined the task The reason, and whether another agent or a changed request would be accepted
TASK_STATE_CANCELED The task was stopped before finishing Who asked for the stop, if you did not

Completed is the fourth terminal state and counts as success in the sense of finished work (inference: still validate the content). Spelling is American, canceled with one L, as of v1.0, so matching CANCELLED will not match the v1.0 value.

Why does the rejected state have no stated cause?

The corpus does not define why a remote agent returns TASK_STATE_REJECTED. The A2A protocol reference lists it as one of four terminal states and stops there, with no reasons, sub-codes or guidance attached.

Possible causes such as an unsupported skill, a policy refusal or a malformed request are plausible, but none is recorded, so treat them as hypotheses to confirm with the operator of that agent. In practice that means do not branch on an assumed reason. Log the whole task object, including any detail the remote agent returns, and decide from the evidence you actually receive.

Which states look like failures but are not?

INPUT_REQUIRED and AUTH_REQUIRED are not failures: per the A2A protocol reference, both pause the task for the client and neither is terminal. See task states and operations and A2A authentication schemes for their handlers.

Which side-effects test decides between retry and surface?

The orchestrator chooses between retry, degrade and surface by asking whether a repeat could change something on the remote side. The multi-agent orchestration patterns resource states that a subagent failure can silently corrupt downstream results and that subagents should return structured success or failure signals, not just text. The side-effects test is inference.

The per-state mapping itself is not repeated here: the pillar's failure section and the task lifecycle table give the default action per state, and that default is to surface the outcome. The branches below are a narrower case that applies only to failed.

Outcome Branch (inference) Test that selects it
failed, read-only skill Bounded retry, then degrade Nothing could have changed on the remote side
failed, skill may write Surface the gap, no automatic retry A repeat could duplicate an effect you cannot see
rejected Surface, with the task object An unchanged resend has no stated reason to behave differently; rerouting to another agent is an optional follow-on (inference)

Degrade means finishing the user's request with less: a cached answer, a cheaper local path or an explicit "this part is missing". Surface means the caller is told what is absent, instead of receiving a result that looks whole.

How do you retry a failed task safely?

Retry a failed remote task only when it is side-effect-free, cap the attempts, and treat each retry as a new task rather than a resume. All three rules are inference: the A2A material in the corpus defines no retry, backoff, idempotency or deadline behaviour.

For the general techniques, see how to make AI agent retries idempotent and how to set timeouts for AI agent tool calls.

What should your handler return to its own caller?

The handler should return a structured result that separates success, the terminal state, whether any side effects are possible and what action was taken, not a sentence of text. This applies the structured-signal rule in the orchestration patterns reference. The field names below are an illustration, not an A2A or ChangeGamer schema.

{
  "ok": false,
  "state": "TASK_STATE_REJECTED",
  "remoteAgent": "https://agent.example.com",
  "sideEffectsPossible": false,
  "action": "surfaced",
  "detail": "Remote agent declined; no retry attempted"
}

A downstream step can then refuse to act on a missing piece instead of guessing. The pillar labels one more rule as inference, and it applies here: treat output from a remote agent as untrusted content and validate it even when the state is completed.

How can you check what the corpus says about interrupted and terminal states?

You can check it against ChangeGamer's own A2A protocol resource, published as Markdown and as JSON. The snippet below fetches the Markdown variant and confirms that the two pause states and the one terminal-subscribe error this article relies on are recorded there.

# Checks ChangeGamer's copy of the A2A reference, not the A2A specification itself
curl -sS https://changegamer.ai/resources/a2a-protocol.md -o a2a-protocol.md
for t in TASK_STATE_INPUT_REQUIRED TASK_STATE_AUTH_REQUIRED TASK_STATE_REJECTED UnsupportedOperationError VersionNotSupportedError; do
  grep -q "$t" a2a-protocol.md && echo "recorded: $t" || echo "MISSING: $t"
done
grep -ciE "retry|idempot|backoff" a2a-protocol.md   # expect 0 retry semantics recorded for A2A

The same text is available at /api/resources/a2a-protocol.json. The last line is the useful one: a count of zero is the evidence behind the inference labels in this article. The resource was re-verified against the rendered specification on 9 October 2026; the check does not test any remote agent's behaviour.

What is not known about A2A failure handling?

The corpus does not define why a task is rejected, any A2A error code beyond VersionNotSupportedError and UnsupportedOperationError, any retry or resume mechanism, or how a client distinguishes a transient failure from a permanent one. As of 9 November 2026 each of those is a question for the specification and for the remote operator, so write the answers into your integration notes instead of assuming them.

Frequently asked questions

What is the difference between a failed and a rejected A2A task?
Failed and rejected are both terminal A2A task states but different outcomes, and the ChangeGamer corpus does not define the cause of either. Treat failed as a remote problem that may be retried only when side-effect-free and rejected as a refusal not to resend unchanged; both treatments are inference.
Should an orchestrator retry a failed A2A task?
An orchestrator should retry a failed A2A task only when the task is side-effect-free, and only a bounded number of times. That advice is inference, because the A2A specification as recorded in the ChangeGamer corpus defines no retry, backoff or idempotency behaviour.
Can you subscribe to an A2A task after it has failed?
A failed A2A task cannot be subscribed to, because Subscribe to Task on a terminal task returns UnsupportedOperationError, per the ChangeGamer A2A protocol reference updated 27 October 2026. Reading it with Get Task and starting a new task is the inference-based way forward.

#a2a #agent2agent #failure-handling #orchestration #retries #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)