# What happens when an instance advertises an A2A Agent Card capability it cannot honor under delegated authority **Date of Record:** 2026 November 16 **Scope:** Applies to A2A v1.0 agents that publish an Agent Card declaring skills, then accept tasks delegated from a calling agent whose authorization context differs from the callee's own. Does not apply to same-tenant, same-credential delegation where caller and callee share an identical authorization envelope. ## Core Distinction The Agent Card is a *discovery-time* artifact. It describes what an agent claims it can do. Task acceptance is an *invocation-time* act governed by the authorization context presented on the task request. A2A v1.0 treats these as decoupled: the card is fetched once (often cached), while each `tasks/send` carries its own credentials and `metadata`. The non-obvious boundary is that a callee can pass discovery, pass capability matching, accept the task, and *still* be structurally unable to execute — because the delegated authority on the request is narrower than the authority the card implicitly assumes. The card is a promise about *ability*. The task envelope is a promise about *permission*. Conflating them is the failure. ## What Was Observed A purchasing orchestrator (Agent A) discovered a supplier agent (Agent B) via its Agent Card at `/.well-known/agent.json`. The card declared a skill `createPurchaseOrder` with `inputModes: ["application/json"]` and an `examples` block. Agent A matched the skill, sent `tasks/send` with a `metadata` block carrying a scoped OAuth token minted for `po:write` only. Agent B accepted the task (state `submitted` → `working`), then failed at execution with a downstream `403` from its own ERP backend, because the token Agent B forwarded was scoped to `po:write` but the ERP required `po:write` *plus* `costcenter:read` to resolve the cost center embedded in the PO. Agent B had no way to request the missing scope mid-task: A2A v1.0 has no in-band scope-escalation primitive — `input-required` is for *data*, not *authority*. The task entered `input-required`, Agent A had no mechanism to supply a broader token within the existing task, and the task hung until timeout. The card had been truthful about ability. It was silent about the authority envelope required to exercise that ability. Agent A had no field to read. ## Condition of Validity This boundary is only reachable when all of the following hold: 1. The callee performs a *second-hop* call using credentials derived from the task envelope (not its own service identity). 2. The callee's downstream dependency requires a scope not present in the caller's delegated token. 3. The A2A task is already in `working` when the missing scope is discovered (i.e., the gap is not detectable from the request alone). If the callee uses its own service identity for downstream calls, the caller's token scope is irrelevant and this failure cannot occur. If the scope gap is detectable before acceptance, the callee can reject at `tasks/send` with a structured error and the caller can re-mint — that is the *correct* path, not this failure. ## Decision Boundary The callee must choose, at task acceptance time, between two postures: - **Strict**: reject any task whose envelope credentials do not cover the full downstream scope closure of the declared skill. Requires the card to publish a `requiredScopes` (or equivalent `metadata.authorization`) declaration so callers can pre-flight. Safe, but rejects tasks the callee could have served with its own identity. - **Permissive**: accept, attempt, and surface scope gaps as `input-required` with a structured `metadata.reason = "authorization"`. Flexible, but the caller has no defined way to respond — A2A v1.0 `input-required` payloads are for task data, and replying with a new token mid-task is out-of-spec. The correct boundary is: **publish the authorization envelope on the card, and enforce it at `tasks/send`.** Do not defer authority checks to execution. A task that reaches `working` and then stalls on authority is a protocol dead-end. ## Operational Effect Callers that trust the card as a complete contract will build orchestrators that accept `input-required` as a recoverable state and retry with fresh credentials — which fails, because the task ID is bound to the original envelope. The retry either reuses the stale token (loops) or opens a new task (loses idempotency, duplicates side effects if the first attempt partially committed). The observable symptom is a cluster of `input-required` tasks with `metadata.reason: "authorization"` that never resolve, and downstream duplicate-detection alarms firing on the callee's ERP. Mitigation: treat the Agent Card's authorization declaration as a hard precondition. If it is absent, the callee is not safe to delegate to under a narrowed token, regardless of how complete its skill list looks. ```python from __future__ import annotations from dataclasses import dataclass from typing import Iterable class AgentCardContractError(RuntimeError): """Raised when a callee's Agent Card is not a complete delegation contract.""" @dataclass(frozen=True) class AgentCard: agent_id: str skills: tuple[str, ...] declared_scopes: frozenset[str] | None # None == card omits authorization envelope @dataclass(frozen=True) class TaskEnvelope: task_id: str skill: str delegated_scopes: frozenset[str] def preflight_delegation( card: AgentCard, envelope: TaskEnvelope, downstream_scope_closure: dict[str, Iterable[str]], ) -> None: """Refuse to send a task whose delegated authority cannot satisfy the skill. Enforces the decision boundary: the authorization envelope must be published on the card and must cover the skill's downstream closure. Deferring this check to execution produces unresolvable `input-required` tasks in A2A v1.0. """ if envelope.skill not in card.skills: raise AgentCardContractError( f"agent {card.agent_id!r} does not declare skill {envelope.skill!r}" ) if card.declared_scopes is None: raise AgentCardContractError( f"agent {card.agent_id!r} publishes no authorization envelope; " f"delegation under a narrowed token is unsafe for skill " f"{envelope.skill!r} (task {envelope.task_id!r} not sent)" ) required = frozenset(downstream_scope_closure.get(envelope.skill, ())) missing = required - envelope.delegated_scopes if missing: raise AgentCardContractError( f"task {envelope.task_id!r}: delegated scopes " f"{sorted(envelope.delegated_scopes)} cannot satisfy downstream " f"closure {sorted(required)} for skill {envelope.skill!r}; " f"missing {sorted(missing)}. Re-mint the token before tasks/send — " f"do not accept and stall in 'working'." ) def send_task( card: AgentCard, envelope: TaskEnvelope, downstream_scope_closure: dict[str, Iterable[str]], ) -> str: preflight_delegation(card, envelope, downstream_scope_closure) return envelope.task_id ```