# Why does an instance of A2A v1.0 Agent Card discovery silently succeed against a stale, non-authoritative card and then fail only at the third delegation hop? **Date of Record:** 2026 November 14 **Scope:** Applies to A2A v1.0 (and draft-compatible v0.3+) cross-vendor agent delegation where the calling agent resolves a peer via Agent Card discovery (`/.well-known/agent.json` or registry-mediated resolution) and then chains tasks through one or more intermediary agents. Does not apply to single-hop, same-vendor, or statically-pinned-card deployments where the card digest is verified out-of-band. ## Core Distinction There are two distinct notions of "the agent is reachable" that A2A v1.0 conflates at the discovery layer: 1. **Card liveness** — the discovery endpoint returned an HTTP 200 with a structurally valid Agent Card whose `skills`, `capabilities`, and `securitySchemes` parse correctly. 2. **Card authority** — the returned card reflects the *current* task-lifecycle contract (state machine version, `pushNotifications` semantics, accepted `TaskState` enum members) actually enforced by the executor behind that card. A2A v1.0 discovery validates (1) but does not, by default, bind (2). The invariant that fails is: *a card that parses implies a peer that will honor the lifecycle transitions the card advertises.* This invariant holds at the first hop and degrades at each subsequent hop, because intermediaries cache and re-advertise cards whose authority has already expired. ## What Was Observed In a three-hop delegation chain (Orchestrator → Vendor-A broker → Vendor-B worker), the orchestrator resolved Vendor-B's card successfully and initiated a task. The card advertised `capabilities.pushNotifications: true` and a `TaskState` set including `input-required`. The first two hops returned `submitted → working` transitions correctly. At the third hop, the worker had been upgraded to a build that removed `input-required` from its state machine (replaced with a terminal `failed` on missing input) but continued serving a **cached, stale card** from a CDN edge with a 24-hour TTL. The orchestrator sent an `input-required` continuation, received `working`, then hung until its own deadline because the worker never emitted a terminal state the orchestrator recognized. The failure was *non-obvious* because every individual observable was healthy: discovery 200 OK, card schema valid, first-hop handshake clean, no transport errors. The break was a **state-machine version skew** invisible to card validation and only detectable by probing a transition the card claims to support but the executor no longer implements. ## Condition of Validity The "card parses ⇒ peer honors lifecycle" invariant is only valid when **all** of the following hold: - The card's `version` and any `capabilities` extensions are matched against the executor's actual build, not merely schema-validated. - The discovery response carries a cache directive whose TTL is shorter than the executor's upgrade cadence, **or** the card is content-addressed and the digest is re-verified per delegation. - Intermediary agents do not re-advertise a downstream card without re-resolving it against the downstream executor. When any condition is violated — most commonly the second, because CDN defaults are tuned for static assets, not for mutable capability contracts — the invariant silently fails. The failure is *latent*: it does not manifest until a delegation exercises a transition whose existence the stale card asserts and the live executor denies. ## Decision Boundary The operational decision is **whether to trust a resolved card directly or to perform an active lifecycle probe before delegating a stateful task.** - **Trust directly** when the task is stateless or single-transition (`message/send` with a self-contained payload that terminates in one round-trip), or when the card digest was pinned out-of-band by the caller. - **Probe before delegating** when the task requires any multi-transition lifecycle (`input-required`, `auth-required`, streaming `working` updates, or push-notification continuations), or when the delegation chain length exceeds one hop, or when the resolved card's `version` does not match a locally recorded expectation. The boundary is crossed the moment a delegation depends on a `TaskState` transition the caller has not observed the executor actually emit. At that point card liveness is no longer sufficient evidence of card authority, and the caller must either probe or refuse. ## Operational Effect Treating a parsed card as authoritative produces **silent hangs** rather than errors: the caller waits on a terminal state the executor will never send, burning the full task deadline before failing with an uninformative timeout. Downstream, this manifests as orphaned tasks on the worker (which did receive the continuation but rejected it internally) and inflated latency SLOs attributed to the wrong hop. The mitigation that held in practice: before any stateful delegation, issue a cheap, idempotent probe task that forces the executor to emit the exact `TaskState` transition the caller intends to rely on, and compare the emitted state against the card's advertised set. If the executor emits a state outside the advertised set, or fails to emit an advertised state within a bounded probe window, the card is stale and the delegation is refused rather than attempted. This converts a silent hang into a fast, attributable failure at the discovery boundary. ```python from __future__ import annotations from dataclasses import dataclass from typing import FrozenSet class StaleAgentCardError(RuntimeError): """Raised when a resolved Agent Card's advertised lifecycle no longer matches the executor's actual TaskState behavior (card authority skew).""" @dataclass(frozen=True) class ResolvedCard: agent_id: str advertised_states: FrozenSet[str] cache_ttl_seconds: int version: str def verify_card_authority( card: ResolvedCard, observed_states: FrozenSet[str], required_transition: str, chain_length: int, max_cache_ttl_seconds: int = 300, ) -> None: """Guard invoked before delegating a stateful task across hops. Raises StaleAgentCardError if the card cannot be trusted to honor the required lifecycle transition. Callers must probe the executor first and pass the states it actually emitted as `observed_states`. """ if required_transition not in card.advertised_states: raise StaleAgentCardError( f"{card.agent_id}: card does not advertise required state " f"{required_transition!r}; refusing delegation" ) # The executor emitted a state the card never claimed: the card is not # merely stale, it describes a different state machine entirely. unadvertised = observed_states - card.advertised_states if unadvertised: raise StaleAgentCardError( f"{card.agent_id}: executor emitted unadvertised states " f"{sorted(unadvertised)}; card authority violated" ) # Multi-hop chains amplify cache skew: a stale card at hop N poisons # every hop above it, so demand a tight TTL before trusting it. if chain_length > 1 and card.cache_ttl_seconds > max_cache_ttl_seconds: raise StaleAgentCardError( f"{card.agent_id}: cache TTL {card.cache_ttl_seconds}s exceeds " f"{max_cache_ttl_seconds}s on a {chain_length}-hop chain; " "re-resolve or pin digest before delegating" ) if required_transition not in observed_states: raise StaleAgentCardError( f"{card.agent_id}: probe did not observe {required_transition!r} " "within the probe window; executor may have dropped the transition" ) ```