# Why does an instance of a delegated capability token fail at the second hop when the consent chain is semantically valid but temporally misaligned? **Date of Record:** 2026 November 14 **Scope:** This record applies to AAIF scoped capability tokens that carry delegation depth and a consent-chain attestation, where a downstream agent (depth ≥ 2) presents a token derived from an upstream grant. It does not apply to single-hop root tokens issued directly to an agent, nor to tokens using symmetric shared-secret verification without chain attestation. ## Core Distinction A delegated capability token encodes two independent facts: **authority** (the scope the holder may exercise) and **provenance** (the ordered chain of consenting principals that transferred that authority). Most implementations validate authority at the leaf and provenance at issuance, then cache the combined result. The non-obvious failure is that provenance validity is **monotonic in time in one direction only**: a consent chain is valid at the instant it is attested, but each hop's grant carries its own `not_before`/`not_after` window, and a downstream verifier that checks only the leaf token's window will accept a chain whose intermediate hop has already expired. The token *is* semantically valid — every signature verifies, every scope is a subset of its parent — yet the chain is temporally broken at hop N-1. Authority and provenance are not the same clock. ## What Was Observed A three-hop delegation (principal → orchestrator → sub-agent → tool-runner) was issued at T0. Each hop had a 300-second window, but the orchestrator's hop window was computed from *its* issuance time, not from the root principal's, accumulating a 47-second skew across two hops. At T0+271s the tool-runner presented a token whose leaf window was still open (expires T0+300s) and whose root window was still open, but whose intermediate hop had expired at T0+253s. The verifier returned `VALID` because it validated leaf scope containment and root signature, and treated the intermediate attestation as opaque bytes rather than a time-bounded grant. The sub-agent continued to act under authority that no principal in the live chain still held. The failure surfaced only when an audit reconciliation compared per-hop windows against wall-clock action timestamps, 19 minutes later. ## Condition of Validity The chain is valid only if, for every hop `i` in `1..N`, the action timestamp `t_act` satisfies `not_before_i ≤ t_act ≤ not_after_i`. Leaf-only or root-only window checks are insufficient. This condition is violated whenever hop windows are derived independently (per-issuer clocks, per-hop TTLs, or TTLs reset on re-delegation) instead of being intersected from the root. It is also violated when the verifier caches a `VALID` decision keyed on token hash without re-evaluating intermediate windows, because the cache key does not encode the time at which the chain was assembled. ## Decision Boundary The boundary is: **validate the intersection of all hop windows at the moment of action, not at the moment of issuance.** If your verifier cannot enumerate intermediate hops (e.g., the token is opaque or the chain is compressed to a single attestation blob), you must reject any token with delegation depth ≥ 2 unless the issuing authority provides a signed `effective_not_after = min(not_after_i)`. Do not accept a leaf window as a proxy for the chain window. When in doubt, treat the shortest hop window as authoritative and refuse actions outside it. ## Operational Effect Agents that trust leaf windows will execute actions under expired intermediate consent, producing audit findings that look like authorization bypass but are actually clock-intersection bugs. The remediation is to compute `effective_not_after` at issuance by intersecting all hop windows, embed it as a signed claim, and have every verifier check `t_act ≤ effective_not_after` as a hard gate before scope checks. This converts a distributed clock problem into a single signed scalar and makes the failure detectable at the point of action rather than at reconciliation. ```python class ConsentChainTemporalError(RuntimeError): """Raised when a delegated capability token's consent chain is temporally broken.""" class Hop: def __init__(self, principal: str, not_before: float, not_after: float): self.principal = principal self.not_before = not_before self.not_after = not_after def effective_not_after(hops: list[Hop]) -> float: if not hops: raise ConsentChainTemporalError("empty consent chain: no hop windows to intersect") return min(h.not_after for h in hops) def validate_chain_at_action(hops: list[Hop], t_act: float) -> None: if not hops: raise ConsentChainTemporalError("cannot validate action against empty chain") eff = effective_not_after(hops) for i, hop in enumerate(hops): if t_act < hop.not_before: raise ConsentChainTemporalError( f"hop {i} ({hop.principal}) not yet valid at t_act={t_act}" ) if t_act > hop.not_after: raise ConsentChainTemporalError( f"hop {i} ({hop.principal}) expired at {hop.not_after}, " f"t_act={t_act}, effective_not_after={eff}" ) def authorize_action(hops: list[Hop], t_act: float, requested_scope: str) -> str: validate_chain_at_action(hops, t_act) return f"authorized scope={requested_scope} at t_act={t_act}" ```