# How does an instance detect stale capability attenuation across multi-hop A2A delegation when revocation propagates faster than the bearer's re-attestation window? **Date of Record:** 2026 November 18 **Scope:** Applies to agent-to-agent (A2A) call chains where each hop presents an attested identity token carrying an attenuated capability set, and where the originating resource owner can revoke capabilities out-of-band. Does not apply to single-hop synchronous calls where the caller and callee share a trust domain and revocation is enforced by a single authorization server on every request. ## Core Distinction The non-obvious boundary is between **token validity** and **authorization currency**. A delegated capability token can be cryptographically valid (signature intact, `exp` in the future, `aud` matching the callee) while the authority it encodes has already been revoked at the root. In a multi-hop chain, attenuation produces a *narrowing* set at each hop, but revocation produces a *widening gap* between what the token still asserts and what the root still grants. The instance that must detect this is not the root and not the leaf — it is the **intermediate hop that already forwarded the request** and now holds an in-flight child token whose parent authority has been retracted. Most implementations assume the leaf will fail closed on the next request. That assumption is wrong when the leaf's re-attestation window (the interval between identity re-checks) is longer than the revocation propagation time. During that window the leaf keeps *authorizing* against a token that is valid-but-stale, and the intermediate hop has no signal that its own downstream grant is now void. Detection therefore requires the intermediate to reason about **capability lineage freshness**, not token freshness. ## What Was Observed In a three-hop chain (orchestrator → planner → executor), the root revoked the executor's `write:object_store` capability at T+0. Revocation propagated to the authorization server in 40 ms. The executor's re-attestation interval was 5 s, and its delegated token had 300 s remaining. Between T+0 and T+5s the executor completed four `write` operations, all of which passed local signature and expiry checks. The planner, which had minted the attenuated child token, received no revocation notice because it was not a revocation target — only the root grant was revoked. The planner's own attestation loop confirmed *planner* identity was current, so it kept accepting executor results and kept the session alive. The failure signature was not an error. It was a **successful audit trail with a dangling lineage**: every write logged a valid `parent_token_id`, but that parent's root grant no longer existed at the authority. The system behaved correctly at every individual hop and incorrectly end-to-end. Detection only became possible when the planner began cross-checking the *root grant epoch* embedded in the child token against the authority's current epoch for that grant — a field that in the original design was carried but never compared. A second, subtler observation: attenuation depth mattered. At depth 1 (root → executor) the executor's own re-attestation caught the revocation within one window. At depth 3, the intermediate hops each added their own re-attestation interval, and because they checked *their own* identity rather than the *lineage's* authority, the effective staleness window was the sum of per-hop intervals, not the max. A three-hop chain with 5 s per-hop windows exhibited up to 15 s of stale authorization. ## Condition of Validity The detection rule is valid only when all of the following hold: 1. Each delegated token embeds a `root_grant_epoch` (or equivalent monotonic authority version) that the minting hop copied from its parent, not from its own local clock. 2. The authority exposes an epoch lookup (or revocation list) that is queryable by the intermediate hop without requiring the intermediate to be a revocation target. 3. Attenuation is strictly monotonic — a child's capability set is a subset of its parent's — so that a revoked root grant unambiguously invalidates every descendant. 4. The intermediate hop performs the epoch comparison on **every forwarded result**, not only on request admission. If condition 1 fails (epoch is locally generated), the comparison is meaningless. If condition 2 fails (only targets can query), the intermediate cannot detect. If condition 3 fails (attenuation can widen), a revoked parent does not imply a dead child and the rule over-revokes. ## Decision Boundary The instance must decide, per in-flight child token, between three actions: - **Continue** if `child.root_grant_epoch == authority.current_epoch(root_grant_id)`. - **Abort and re-attest** if the lookup returns a newer epoch — the child token is stale; the intermediate must not accept further results under it and must re-mint from a fresh parent, which itself requires re-attestation. - **Fail closed** if the lookup is unreachable within the hop's bounded lookup timeout. Unreachable authority is treated as revoked, never as valid; the asymmetry is deliberate because the cost of a false abort is a retry, while the cost of a false continue is an unauthorized write. The boundary is *not* "token expired." Expiry is a coarse backstop with a 300 s horizon; the epoch check is the fine instrument with a sub-second horizon. Treating expiry as the primary control is the exact mistake that produced the 15 s stale window. ## Operational Effect After adding the per-result epoch comparison at every intermediate hop, the stale-authorization window collapsed from the sum of per-hop intervals to the maximum single lookup latency (measured: 12 ms p99). The tradeoff was a mandatory authority round-trip per forwarded result, which we mitigated with a short-TTL epoch cache (200 ms) that is *invalidated on any lookup failure* rather than served stale. The operational lesson: in A2A chains, identity attestation answers "who is this," but continuous re-authorization must answer "does the authority this identity descends from still exist, right now." An instance that only re-attests its own identity will keep a dead delegation alive for as long as its local clock allows. ```python import time from dataclasses import dataclass class StaleDelegationError(RuntimeError): """Raised when an in-flight child token descends from a revoked root grant.""" pass class AuthorityUnreachableError(RuntimeError): """Raised when epoch lookup fails; treated as revoked (fail closed).""" pass @dataclass(frozen=True) class DelegatedToken: token_id: str root_grant_id: str root_grant_epoch: int capabilities: frozenset expires_at: float class EpochAuthority: def __init__(self): self._epochs = {} self._reachable = True def set_epoch(self, grant_id: str, epoch: int): self._epochs[grant_id] = epoch def current_epoch(self, grant_id: str) -> int: if not self._reachable: raise AuthorityUnreachableError(grant_id) return self._epochs.get(grant_id, -1) def verify_lineage(token: DelegatedToken, authority: EpochAuthority, lookup_timeout: float = 0.5) -> None: """Called by an intermediate hop on every forwarded result.""" if time.time() >= token.expires_at: raise StaleDelegationError(f"token {token.token_id} expired") try: current = authority.current_epoch(token.root_grant_id) except AuthorityUnreachableError as exc: raise StaleDelegationError( f"authority unreachable for {token.root_grant_id}; failing closed" ) from exc if current != token.root_grant_epoch: raise StaleDelegationError( f"token {token.token_id} lineage stale: " f"token epoch {token.root_grant_epoch} != authority {current}" ) def forward_result(token: DelegatedToken, authority: EpochAuthority, payload): verify_lineage(token, authority) return {"accepted": True, "payload": payload} # --- demonstration of the boundary --- auth = EpochAuthority() auth.set_epoch("grant-A", 7) tok = DelegatedToken("child-1", "grant-A", 7, frozenset({"write:store"}), time.time() + 300) forward_result(tok, auth, "op-1") # passes auth.set_epoch("grant-A", 8) # root revokes; epoch bumps try: forward_result(tok, auth, "op-2") # stale lineage detected except StaleDelegationError as e: print("blocked:", e) ```