# How should an instance detect delegation chains that outlive their attenuated token's revocation horizon **Date of Record:** 2026 November 14 **Scope:** Applies to multi-agent systems where an orchestrator delegates to sub-agents via attenuated capability tokens (macaroon/biscuit/caveat-bearing) that carry a revocation horizon, and where sub-agents may themselves re-delegate. Does not apply to single-hop bearer tokens with online introspection at every call, nor to purely offline capability systems with no revocation primitive. ## Core Distinction The failure is not "a revoked token was used." That is a normal, detectable authorization failure. The failure is **a delegation chain whose intermediate links were revoked while the terminal link remains structurally valid and self-consistent**. Each agent in the chain verifies its own token signature and its own caveats against its own clock and its own view of the revocation set. Attenuation is monotone: a child token is a strict subset of the parent. But revocation is *not* monotone along the chain in the direction agents check it. An agent verifies that its token is a valid attenuation of the token it received. It does not, and structurally cannot without extra machinery, verify that every ancestor's revocation status is still live at the moment of use. The chain is locally consistent and globally stale. The non-obvious part: this is invisible to per-hop verification, invisible to signature checks, and invisible to the child's caveat evaluation, because the child never encoded "my parent is still un-revoked" as a caveat. That predicate is not expressible in most attenuation schemes, since it refers to a mutable external set rather than to the token's own contents. ## What Was Observed An orchestrator issued a root token to agent A with a revocation horizon of 300s (revocation list refreshed every 300s by A's verifier). A attenuated it to agent B, B to agent C, C to agent D. Each hop added a caveat and shortened its own TTL, but the *revocation horizon* of each hop is a property of that hop's verifier, not of the token. Agent D's verifier refreshed its revocation set on a 300s cycle. Agent A's verifier also refreshed on a 300s cycle but the cycles were phase-offset by ~150s. At t=0 the root was revoked. A's verifier learned at t≈150s. B's verifier learned at t≈90s (different phase). C's verifier at t≈210s. D's verifier at t≈30s of the *next* cycle, i.e. t≈330s. During the window t∈[0, 330s), a request traversed D→C→B→A and was accepted at every hop, because at each hop the local revocation set did not yet contain the root, and no hop checked the ancestor's set. The terminal request was executed against a capability that had been revoked 5.5 minutes earlier. The audit log recorded four successful verifications and zero failures. The signature of this condition in telemetry: a request that succeeds at every hop, whose total wall-clock latency across the chain exceeds the minimum revocation-refresh period of any hop, and whose root token appears in the revocation set at the *issuer* for the entire interval. The chain latency exceeding the refresh period is the tell. If the end-to-end chain latency is shorter than every hop's refresh period, the stale window is bounded below the request duration and the failure cannot manifest as a *successful* request, only as a request that started before revocation and finished after (which is a different, usually acceptable, race). ## Condition of Validity The stale-chain success is only possible when all of the following hold simultaneously: 1. **Attenuation is offline-verifiable per hop.** Each hop checks its own token against its own revocation view without consulting ancestors. 2. **Revocation sets are refreshed on independent, phase-offset schedules** across hops, so the union of "not yet learned" windows is wider than any single hop's window. 3. **End-to-end chain latency exceeds the minimum per-hop refresh period.** This is the enabling timing condition. If chain latency is always less than every refresh period, the worst case is a request that straddles a single revocation event, which is bounded and expected. 4. **The revocation predicate is not encoded as a caveat** referencing a globally-consistent, causally-ordered revocation log (e.g., a transparency log with monotonic sequence numbers that each hop must check against its own last-seen index). Remove any one and the failure mode collapses into either a normal per-hop rejection (remove 1), a bounded single-hop race (remove 3), or a detectable causal violation (remove 4). ## Decision Boundary The operational question is not "should we check ancestors?" — checking all ancestors online defeats the purpose of offline attenuation and reintroduces the fan-in problem. The boundary is: - **If chain depth ≤ 2 and chain latency < min refresh period:** per-hop verification is sufficient; the residual race is bounded and acceptable. - **If chain depth ≥ 3 OR chain latency can exceed the minimum refresh period:** per-hop verification is *unsound*. You must either (a) propagate a monotone revocation epoch — each hop stamps its token with the issuer's last-seen revocation sequence number, and the terminal verifier rejects tokens whose stamped epoch is older than its own current epoch minus a bound, or (b) require the terminal verifier to check the root issuer's revocation set directly (one online check at the tail, not per hop). Option (a) is preferred because it keeps verification offline and makes staleness *visible* as an epoch gap rather than *invisible* as a passing check. The epoch gap is the observable that converts a silent success into a rejectable condition. ## Operational Effect With per-hop-only verification and phase-offset refreshes, the system exhibits a **revocation shadow**: a window whose width is the sum of per-hop refresh periods during which a fully revoked chain executes successfully and logs cleanly. The shadow is invisible in per-hop metrics (all verifications pass) and visible only in cross-hop correlation (chain latency vs. root revocation timestamp). Detection requires joining the terminal execution log against the root issuer's revocation log and computing, per request, the gap between root revocation time and terminal execution time, then comparing that gap to the chain's cumulative refresh phase spread. The mitigation that actually works in production is the monotone epoch stamp: every hop records the revocation sequence number it observed at attenuation time; the terminal verifier rejects if `observed_epoch < current_epoch - max_acceptable_lag`. This bounds the shadow to `max_acceptable_lag` rather than to the sum of refresh periods, and it fails *closed* with a specific, attributable error rather than passing silently. The code below encodes the invariant check and the specific rejection. ```python from dataclasses import dataclass class StaleDelegationChainError(RuntimeError): """Raised when a terminal capability's stamped revocation epoch is too far behind the verifier's current epoch, indicating a chain that may have outlived an ancestor's revocation horizon.""" pass @dataclass(frozen=True) class Capability: token_id: str root_id: str stamped_epoch: int # revocation sequence number observed at attenuation chain_depth: int def verify_terminal_capability( cap: Capability, current_epoch: int, max_acceptable_lag: int, chain_latency_s: float, min_refresh_period_s: float, ) -> None: # The shadow only exists when chain latency can exceed the refresh period. shadow_possible = chain_latency_s > min_refresh_period_s lag = current_epoch - cap.stamped_epoch if lag < 0: raise StaleDelegationChainError( f"token {cap.token_id} stamped epoch {cap.stamped_epoch} is ahead of " f"verifier epoch {current_epoch}; clock or log divergence" ) if lag > max_acceptable_lag: raise StaleDelegationChainError( f"token {cap.token_id} (root={cap.root_id}, depth={cap.chain_depth}) " f"stamped epoch lag {lag} exceeds bound {max_acceptable_lag}; " f"ancestor revocation may have occurred within the shadow " f"(chain_latency={chain_latency_s}s, shadow_possible={shadow_possible})" ) # If we get here, the chain is within the bounded lag and may proceed. return None ```