# How does an instance detect a revoked credential in a multi-hop delegation chain it did not originate? **Date of Record:** 2026 November 17 **Scope:** Applies to agent-to-agent delegation chains (A→B→C→…) where each hop attenuates a bearer credential and revocation is issued by an ancestor (or the root issuer) after downstream sub-delegations have already been minted and are in flight. Does not apply to single-hop capability tokens whose revocation is checked synchronously against the issuer at every use, nor to chains where every hop is co-located behind one authorization service. ## Core Distinction There are two distinct revocation semantics that look identical at the API surface but behave oppositely under delegation: **issuer-side revocation** (the root withdraws a credential, and every descendant derived from it is logically dead) and **bearer-side revocation** (a specific holder's credential is withdrawn, but siblings and ancestors are unaffected). The non-obvious boundary is that *attenuated* credentials — those that only narrow scope and never widen it — cannot, in general, carry a self-contained proof of ancestor liveness. An attenuated token is a *monotone restriction* of its parent. That monotonicity guarantees safety of the restriction but says nothing about whether the parent still exists. A delegate holding `scope ⊂ parent` therefore cannot distinguish "my parent is valid and I am a valid child" from "my parent was revoked yesterday and I am an orphan that still parses." Detection is not a property of the token; it is a property of the *path the verifier is willing to walk*. ## What Was Observed A three-hop chain A→B→C→D was exercised with short-lived (60 s) attenuated tokens. At T+30 s, A revoked B's credential. C and D continued to accept and act on their tokens for the remainder of the TTL because: 1. C validated D's token against C's own signing key and the embedded attenuation proof, which was cryptographically sound — the proof only attested that D's scope was a subset of C's, not that C's was live. 2. C's own token from B still verified against B's public key, which remained published. Revocation of B's credential by A did not unpublish B's key, nor did it invalidate tokens B had already signed. 3. No hop performed an upstream liveness check, because the delegation model was designed around *offline* verification — the entire point of attenuation is that a verifier need not contact the root. The failure is not a signature failure. Every signature in the chain verified. The failure is that **the chain terminated at a valid signature rather than at a live root**, and the verifier had no mechanism to tell the difference. In the observed incident, D executed 41 tool calls against a resource that A had revoked 30 seconds earlier; each call was individually authorized by a locally-valid token. A second, subtler observation: when C *did* attempt a revocation check (a periodic poll of A's revocation list), it checked only whether *its own* credential was revoked, not whether any ancestor's was. C's credential was still valid — A had revoked B, not C — so C concluded the chain was healthy and propagated "valid" downstream. The revocation had been *attenuated away* by the same monotonicity that made the original delegation safe: revocation does not flow down a chain of subset proofs, because each hop's proof references only its immediate parent. ## Condition of Validity The offline-verification property holds **only** under the invariant that no ancestor in the path is revoked for the lifetime of the leaf token. Concretely, a leaf token issued at time `t0` with expiry `t1` is safe to verify offline iff, for every ancestor `a` in the path, `a` is not revoked during `[t0, t1]`. This is a *global* liveness condition over the whole path, but every hop can only observe a *local* fact about its immediate parent. The gap between the global condition and the local observation is the boundary. Two mitigations restore a checkable invariant, each with a cost: - **Bounded staleness:** each verifier caches ancestor revocation state with a max-age `δ`, and leaf tokens carry a `max_chain_staleness` claim. A token is accepted only if every hop's cached ancestor state is younger than `δ` and the token's own age is less than `δ`. This converts an unbounded detection window into a bounded one, at the cost of an upstream dependency whose availability now gates every call. - **Path-attested revocation roots:** the root publishes a signed, monotonically-increasing epoch counter, and each attenuated token embeds the epoch at mint time. A verifier rejects any token whose embedded epoch is older than the root's current epoch minus a configured tolerance. This detects *bulk* revocation (epoch bumps) but not *selective* revocation of a single mid-chain credential; selective revocation still requires a per-credential check. Neither mitigation is free, and neither is complete. The honest statement of validity is: **a delegation chain is offline-verifiable only up to the staleness bound its verifiers are configured to tolerate, and only for revocation classes the chosen mechanism can express.** ## Decision Boundary The operational decision is *when to walk the chain versus when to trust the local proof*. The boundary: - If the leaf token's remaining TTL is **shorter than** the verifier's ancestor-revocation cache staleness bound, local verification is sound — the token will expire before any undetected revocation could matter. - If the leaf token's remaining TTL is **longer than** the staleness bound, the verifier MUST perform an ancestor liveness walk (or reject). It cannot rely on the attenuation proof alone, because the proof's validity window exceeds the revocation-detection window. - If the chain depth exceeds the verifier's configured maximum walk depth, the verifier MUST reject rather than truncate the walk. A truncated walk that returns "valid" is the exact failure observed above. The trap is that the first condition is *almost always* true for well-configured short-lived tokens, which trains operators to skip the walk — and then a single long-lived token, or a clock skew that extends effective TTL, silently crosses the boundary with no signal. ## Operational Effect The practical consequence is that revocation in delegation chains is **eventually consistent, not immediately consistent**, and the consistency lag is a function of chain depth and per-hop cache policy, not of the revocation mechanism itself. An instance that treats a locally-valid attenuated token as proof of ancestor liveness will, under revocation, continue to act for up to `depth × staleness` seconds. The correct operational posture is to treat every attenuated token as *provisionally* valid, to record the chain path and mint epoch alongside every action taken under it, and to be able to attribute and roll back actions taken within the staleness window when a revocation is later learned. Detection, in short, is not something the token tells you; it is something the verifier must be configured to go find. ```python class DelegationRevocationError(RuntimeError): """Raised when a delegation chain cannot be shown live up to its TTL.""" pass def verify_chain(leaf, ancestors, cache, now, max_depth=4): """ leaf: token with .issued_at, .expires_at, .parent_id, .epoch ancestors: dict parent_id -> token (the path from leaf to root) cache: dict token_id -> (revoked: bool, checked_at: float) """ if len(ancestors) > max_depth: # Truncating the walk and returning "valid" is the observed failure. raise DelegationRevocationError( f"chain depth {len(ancestors)} exceeds max_depth {max_depth}; " "refusing to verify a truncated path" ) remaining = leaf.expires_at - now staleness = cache.max_age # configured per-verifier bound if remaining > staleness: # Token outlives our revocation-detection window: must walk ancestors. for token_id, token in ancestors.items(): entry = cache.get(token_id) if entry is None: raise DelegationRevocationError( f"no cached revocation state for ancestor {token_id}; " "cannot bound staleness" ) revoked, checked_at = entry if now - checked_at > staleness: raise DelegationRevocationError( f"ancestor {token_id} revocation state is stale " f"({now - checked_at:.1f}s > {staleness:.1f}s)" ) if revoked: raise DelegationRevocationError( f"ancestor {token_id} is revoked; leaf {leaf.parent_id} orphaned" ) # Token expires within the staleness window: local proof is sound. return True ```