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

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

Guide: A2A in practice: agent-to-agent interoperability — part 11
Published: 2026-11-09 · Updated: 2026-11-09 · 1208 words · ~1607 tokens (estimate)
Canonical: https://changegamer.ai/articles/failure-handling-across-agent-boundaries
JSON: https://changegamer.ai/api/articles/failure-handling-across-agent-boundaries.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 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.

---

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](/articles/a2a-task-lifecycle), the pillar's [failure section](/articles/a2a-protocol-in-practice) 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](/articles/a2a-task-lifecycle) and [A2A authentication schemes](/articles/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](/articles/a2a-protocol-in-practice) and the [task lifecycle table](/articles/a2a-task-lifecycle) 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.

- **Cap attempts.** A fixed small maximum, with a delay between attempts, stops a persistent failure from becoming a loop (inference).
- **Know the side effects.** If the Agent Card's skill descriptions do not say whether a skill writes anything, assume it might (inference). Skill descriptions are self-published, so verify them (inference, per the resource's security note).
- **Do not subscribe to a terminal task.** Subscribe to Task on a terminal state returns `UnsupportedOperationError` per the protocol reference, so a retry is a new Send Message.
- **Set your own deadline.** The corpus gives no A2A timeout; pick one and treat a task that exceeds it as failed on your side (inference).

For the general techniques, see [how to make AI agent retries idempotent](/articles/retries-and-idempotency-for-ai-agents) and [how to set timeouts for AI agent tool calls](/articles/timeouts-and-deadlines-for-ai-agents).

## 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](/resources/multi-agent-orchestration-patterns). The field names below are an illustration, not an A2A or ChangeGamer schema.

```json
{
  "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.

```bash
# 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.


---

## 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.
- [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/multi-agent-orchestration-patterns.md
- 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
