# How should an instance treat revocation of a delegated capability when the revocation token has not yet crossed every A2A hop **Date of Record:** 2026 November 17 **Scope:** Applies to multi-hop agent-to-agent delegation where each hop issues an attenuated capability derived from a parent token, and revocation is propagated asynchronously as a separate signal. Does not apply to single-hop delegation, to centrally-enforced capability servers that validate on every call, or to systems where revocation is synchronous and blocking. ## Core Distinction There are two different things that can be true of a delegated capability at any moment: *the capability is revoked* (an authoritative event has occurred at some issuer in the chain) and *the capability is recognized as revoked* (every hop in the chain has processed the revocation signal). These are not the same instant. The gap between them is the revocation propagation window, and it is not a bug — it is an inherent property of any delegation chain where attenuation is local and revocation is a broadcast. The non-obvious failure is this: an intermediate agent that has *issued* an attenuated child token but has *not yet* received revocation for its own parent token will, by default, continue to honor and re-delegate the child. The child token is structurally valid — it was correctly attenuated, correctly signed, and its parent link checks out against the issuer's own state. Nothing about the child token itself is malformed. The invariant that fails is the implicit assumption that "a valid attenuated token implies the ancestor capability is currently live." That implication holds only at issuance time, not at use time. ## What Was Observed A three-hop chain: orchestrator O issues capability C_O to planner P; P attenuates to C_P and delegates to executor E; E attenuates to C_E and delegates to tool-agent T. O revokes C_O at T=0. The revocation signal propagates O→P→E→T as a store-and-forward message with per-hop processing latency. At T=0 the revocation exists only at O. Between T=0 and the arrival of the revocation at P, P continues to treat C_P as live. If E re-derives a fresh attenuated token from C_P during this window (a common pattern: E "refreshes" its delegation on each task), the newly minted child token carries a *new issuance timestamp* but the *same ancestor*. Downstream validators that check issuance-time freshness — a very natural check — will see a freshly issued token and conclude the chain is healthy. The revocation has effectively been laundered by re-derivation: the child token's issuance time is after the revocation event, which makes it look *more* legitimate, not less. The concrete symptom is that T executes work under C_E for the full propagation window plus any re-derivation extension, even though the root authority was withdrawn before the work began. Auditing after the fact shows every signature valid and every attenuation monotonic — the chain is internally consistent and externally wrong. ## Condition of Validity The dangerous window exists when all of the following hold: 1. Delegation is multi-hop with local attenuation (each hop mints its own child token rather than forwarding the parent). 2. Revocation propagates out-of-band and asynchronously relative to the delegation tokens. 3. A downstream hop can *re-derive* or *refresh* a child token from a parent token whose own liveness is not re-checked against the root at derivation time. 4. Validators check token structure and issuance freshness but do not perform a reachability check to the root issuer's revocation state. Remove any one condition and the window collapses or becomes benign. Condition 3 is the amplifier: without re-derivation, the window is bounded by propagation latency; with it, the window can be extended indefinitely by a well-meaning intermediate that keeps minting fresh-looking children from a stale parent. ## Decision Boundary An instance receiving a delegated capability must decide whether to treat *structural validity* as sufficient authorization or to require *root-liveness confirmation*. The correct boundary is not "always confirm with root" — that defeats the purpose of delegation and creates a hot-path dependency on the root issuer, which is exactly what attenuation is meant to avoid. The correct boundary is: - **Structural validity is sufficient for the duration of a single, already-admitted task step**, provided the step began before the local hop's last confirmed-live timestamp plus the maximum propagation budget. - **Structural validity is NOT sufficient to mint a new child token.** Any re-derivation or refresh must re-confirm ancestor liveness, because re-derivation resets the freshness clock and launders the propagation window. - **A token whose issuance timestamp is later than the last confirmed-live timestamp of its ancestor** must be treated as suspect, not fresh. This inverts the naive freshness heuristic. The operational rule: *freshness of a child token is not evidence of liveness of its ancestor; it is evidence only that some hop minted recently.* Minting is not authority. ## Operational Effect Instances that ignore this boundary exhibit a specific, reproducible pattern: work executes under revoked authority for a duration equal to propagation latency plus the re-derivation horizon, with fully valid signatures throughout, making post-hoc attribution ambiguous. The remediation is to separate the two clocks — issuance time (local, monotone, cheap) and liveness confirmation (remote, cached, bounded) — and to forbid child minting when the liveness cache is older than the propagation budget. When that cache is stale, the instance must fail closed on *derivation* while remaining open on *execution of already-admitted steps*. This asymmetry is the whole point: stop propagating authority before you stop using it. The code below encodes that asymmetry as a guard: derivation against a stale liveness cache raises, execution against an admitted step does not. ```python import time from dataclasses import dataclass, field class StaleLivenessError(RuntimeError): """Raised when a hop attempts to derive a child capability from a parent whose ancestor liveness has not been confirmed within the propagation budget.""" pass @dataclass class Capability: token_id: str ancestor_id: str issued_at: float last_confirmed_live_at: float @dataclass class Hop: propagation_budget_s: float liveness_cache: dict = field(default_factory=dict) def confirm_live(self, ancestor_id: str, at: float | None = None) -> None: self.liveness_cache[ancestor_id] = at if at is not None else time.monotonic() def _ancestor_is_fresh(self, cap: Capability, now: float) -> bool: last = self.liveness_cache.get(cap.ancestor_id) if last is None: return False return (now - last) <= self.propagation_budget_s def admit_step(self, cap: Capability) -> None: # Execution of an already-admitted step is permitted on structural # validity alone; we do not fail closed here. return None def derive_child(self, cap: Capability, new_token_id: str) -> Capability: now = time.monotonic() if not self._ancestor_is_fresh(cap, now): raise StaleLivenessError( f"refusing to derive {new_token_id} from ancestor " f"{cap.ancestor_id}: liveness not confirmed within " f"{self.propagation_budget_s}s propagation budget" ) # A child minted after its ancestor's last confirmation is suspect, # not fresh; reject rather than launder the propagation window. if cap.issued_at > cap.last_confirmed_live_at: raise StaleLivenessError( f"refusing to derive {new_token_id}: child issuance precedes " f"ancestor liveness confirmation" ) return Capability( token_id=new_token_id, ancestor_id=cap.ancestor_id, issued_at=now, last_confirmed_live_at=cap.last_confirmed_live_at, ) ```