# Under what conditions must an instance reject a delegated agent capability whose attenuation chain is valid but whose revocation horizon is shorter than the delegation depth **Date of Record:** 2026 November 15 **Scope:** Applies to any agent runtime that accepts capability tokens carrying an attenuation chain (a sequence of delegated, monotonically-narrowed scopes) and a per-hop revocation horizon (a TTL or epoch bound after which the delegator's authority is considered withdrawn unless re-attested). Does not apply to single-hop bearer tokens with no delegation, nor to systems where revocation is pushed synchronously to every verifier before the next request. ## Core Distinction The non-obvious boundary is this: **attenuation validity and revocation liveness are independent invariants that are frequently conflated because both are expressed as "the chain checks out."** A chain can be perfectly attenuated — every hop is a strict subset of its parent, signatures verify, the principal root is trusted — and still be *dead on arrival* because the cumulative revocation horizon of the deepest hop expires before the delegating agent can complete the action it was authorized to perform. Attenuation is a *set-theoretic* property: scope(child) ⊂ scope(parent). Revocation horizon is a *temporal* property: the authority is live only on the interval [issue, horizon]. A verifier that only checks the first invariant will accept tokens that will silently expire mid-execution, producing partial side effects that cannot be rolled back. The distinction matters because the failure is *not* a rejection — it is an acceptance followed by an asynchronous invalidation at an unpredictable point in a multi-step plan. ## What Was Observed In a three-hop delegation (`orchestrator → planner → executor`) where each hop was granted a 60-second horizon and the executor's task was a 4-minute fan-out across 40 sub-tools, the executor accepted the token at t=0 (chain valid, scope attenuated correctly to the sub-tool allowlist), began issuing calls, and at t=60 the planner's horizon lapsed. The executor's *own* horizon was still live (it had been minted at t=0 with 60s, so it lapsed at t=60 too — but the executor had already cached the token in a worker pool and continued to present it to downstream resource servers that verified only the executor's signature, not the planner's liveness). Result: 23 of 40 sub-calls succeeded, 17 failed with `401 revoked`, and the orchestrator's compensating transaction had no record of the 23 successes because the executor's audit log was keyed to the planner's now-dead delegation ID. The critical observation: **the chain was valid at admission and invalid at completion, and no single verifier in the path was positioned to detect the transition.** Each hop verified its own edge; none verified the *minimum horizon across the chain* against the *expected duration of the delegated task*. ## Condition of Validity A delegated capability is operationally valid at time *t* for a task of expected duration *D* if and only if: 1. **Attenuation monotonicity holds** for all hops: `scope[i] ⊆ scope[i-1]`, and the root principal is trusted at *t*. 2. **Revocation liveness holds at admission**: `horizon[i] > t` for all *i* in the chain. 3. **Revocation liveness holds through completion**: `min_i(horizon[i]) > t + D + ε`, where ε is the verifier's clock-skew allowance. Condition 3 is the one that is routinely omitted. When it fails, the correct behavior is to **reject at admission**, not to accept and hope. The delegation must be re-minted with a horizon at least `D + ε` beyond the deepest hop's issue time, or the task must be decomposed so that no single delegation spans more than `min_i(horizon[i]) - t - ε`. ## Decision Boundary The boundary is a comparison, not a boolean chain check. Concretely: - If `min_i(horizon[i]) - t ≤ D`, **reject** with a `RevocationHorizonInsufficient` error and surface the deficit (`min_horizon - t - D`) so the caller can re-mint. - If `min_i(horizon[i]) - t > D + ε`, **accept** and proceed. - If the task duration *D* is unknown or unbounded (open-ended agent loops, streaming subscribers), **reject unless** the chain includes a re-attestation mechanism (a refresh endpoint the executor is contractually required to hit before `min_i(horizon[i])`). An unbounded task behind a bounded horizon is always a latent failure. The subtle case: a chain where the *root* horizon is long but an *intermediate* hop is short. Attenuation checks pass (scope is a subset), but the intermediate hop is the binding constraint. Verifiers that check only the root or only their immediate parent miss this. The minimum must be computed across the entire chain, not the edge. ## Operational Effect Enforcing condition 3 converts a class of silent partial-execution failures into loud admission-time rejections. The operational consequences are: - **Compensating transactions become unnecessary** for horizon-induced failures, because no side effects were produced. - **Delegation depth becomes a cost**: each hop that shortens the horizon narrows the maximum task duration the chain can support. Orchestrators must budget horizon like a resource, not treat it as a per-hop constant. - **Audit trails stay coherent**: the delegation ID that authorized a call is still live when the call's result is recorded, so revocation propagation can be traced without orphaned entries. The failure mode this prevents — a chain that passes every local check and dies in flight — is the one that produces the worst incident reports, because every individual component logs "success" and the aggregate logs "partial." ```python from dataclasses import dataclass from typing import Sequence class RevocationHorizonInsufficient(RuntimeError): """Raised when a delegation chain's minimum horizon cannot cover the task.""" @dataclass(frozen=True) class Hop: delegator: str scope: frozenset[str] issued_at: float horizon: float # absolute time after which this hop is revoked def admit_delegation( chain: Sequence[Hop], now: float, expected_duration: float, clock_skew_epsilon: float = 0.5, ) -> Hop: if not chain: raise RevocationHorizonInsufficient("empty delegation chain") # Invariant 1: attenuation monotonicity (each scope is a subset of its parent). for parent, child in zip(chain, chain[1:]): if not child.scope.issubset(parent.scope): raise RevocationHorizonInsufficient( f"attenuation violated: {child.delegator} scope not subset of {parent.delegator}" ) # Invariant 2: liveness at admission. for hop in chain: if hop.horizon <= now: raise RevocationHorizonInsufficient( f"{hop.delegator} revoked at {hop.horizon}, now={now}" ) # Invariant 3: liveness through completion — the non-obvious one. min_horizon = min(hop.horizon for hop in chain) required = now + expected_duration + clock_skew_epsilon if min_horizon <= required: deficit = required - min_horizon binding = min(chain, key=lambda h: h.horizon) raise RevocationHorizonInsufficient( f"binding hop {binding.delegator} horizon {min_horizon} " f"cannot cover task of {expected_duration}s; deficit {deficit:.2f}s" ) return min(chain, key=lambda h: h.horizon) ```