# Why does an instance still hold authority after capability revocation across a federated trust boundary? **Date of Record:** 2026 November 15 **Scope:** Applies to multi-domain agent systems where an authority domain issues short-lived capability tokens (macaroons, biscuit tokens, signed JWT capability sets) that are presented to resource domains, and where revocation of an agent identity must take effect before the token's natural expiry. Does not apply to single-domain systems with a shared revocation list, nor to systems where every request is re-validated against the issuing domain synchronously. ## Core Distinction The distinction that matters is between *token validity* and *agent authority*. A short-lived capability token encodes a claim: "the bearer, at issuance time, was granted capability C until wall-clock time T." Revocation is a claim about the *subject* (the agent identity), not about the *token*. These two facts live in different domains, propagate on different timelines, and are checked at different points in the request path. The boundary failure occurs when a resource domain treats a cryptographically valid, unexpired token as sufficient proof of authority, even though the issuing domain has already revoked the subject that the token names. The non-obvious part: shrinking token TTLs *feels* like it bounds the revocation window, and in a single domain it does. Across federated domains it does not, because the resource domain caches the *decision* derived from the first valid presentation, and that cache is keyed on the token, not on the subject. The revocation of the subject never invalidates a cache entry keyed on a token hash. The shorter the TTL, the more frequently the agent re-presents, and the more cache entries are minted — each of which outlives the revocation event by up to its own residual lifetime plus the cache's own TTL. ## What Was Observed An agent identity `agent://ops/reconciler-7` held a delegated capability set issued by trust domain `alpha` and presented it to resource domain `beta`. `beta` validated the token chain, verified the signature against `alpha`'s published JWKS, and cached an authorization decision under key `sha256(token) → {subject, caps, exp}` with a local cache TTL of 300s. The token TTL was 120s. At T+0 the operator revoked `reconciler-7` in `alpha`. `alpha` published the revocation to its status endpoint within 4s. `beta` did not poll `alpha`'s revocation endpoint; it relied on token expiry. Between T+0 and T+120 the agent presented its still-valid token three times, each time hitting a *different* cache key because each presentation carried a freshly minted token from `alpha`'s short-lived issuance loop that the agent had pre-fetched *before* revocation. The pre-fetched tokens were signed before the revocation event and remained cryptographically valid. `beta` minted three new cache entries, the last of which was valid until T+120+300 = T+420. Observed authority persisted 420 seconds past revocation, a 3.5x amplification of the intended 120s bound. The amplification factor is `ceil(revocation_window / token_ttl) * cache_ttl + token_ttl` in the worst case where the agent has pre-fetched a full issuance window. Short TTLs *increase* the number of pre-fetchable valid tokens and therefore the number of cache entries, so the bound is not monotonic in TTL. ## Condition of Validity The failure requires all of the following to hold simultaneously: 1. The resource domain caches authorization decisions keyed on token identity or token hash rather than subject identity. 2. The agent can obtain and hold more than one valid token concurrently (pre-fetch, batch issuance, or overlapping refresh windows). 3. Revocation is expressed at the subject level in the issuing domain but is not pushed to, or polled by, the resource domain within the token TTL. 4. The resource domain's cache TTL is not bounded by the token's remaining lifetime (i.e., the cache does not re-check `exp` on hit, or re-checks it only against the cached value rather than the presented token). If any one condition fails, the window collapses to the token TTL or less. Condition 4 is the most commonly violated and the easiest to fix: on cache hit, re-validate the *presented* token's `exp` and `subject`, not the cached decision's. ## Decision Boundary The operational decision is whether to treat the resource domain's cache as an authority-bearing artifact or as a pure performance optimization. If it is authority-bearing — i.e., a cache hit is allowed to authorize a request without re-establishing the subject's current standing — then the cache must be invalidated by revocation events, which requires a revocation propagation channel from `alpha` to `beta` and a subject-keyed index. If it is a pure optimization, then every cache hit must re-validate the presented token against the issuing domain's current subject status (or against a revocation set that `beta` maintains with a bounded staleness contract). There is no third option in which the cache is authority-bearing *and* revocation is only eventual. The staleness contract must be explicit: `beta` must publish "we honor revocations within S seconds," and `alpha` must guarantee the revocation reaches `beta` within S, and the token TTL must be `>= S` so that no token outlives the staleness bound. If the token TTL is shorter than S, the system is unsound regardless of how short the TTL is, because pre-fetched tokens outlive the propagation. ## Operational Effect The practical effect is that revocation latency is governed by the *maximum* of (propagation delay, token TTL, cache TTL), not by the token TTL alone, and the cache TTL is usually the largest term and the least monitored. Systems that advertise "120-second revocation bound" based on token TTL are typically operating at 5–10 minute effective bounds. The correct invariant to assert in code is: *no authorization decision may be served from cache if the subject's revocation status has not been confirmed within the cache entry's own age.* Enforce it by keying the cache on subject, storing the last-confirmed-standing timestamp, and refusing hits older than the staleness contract. The following enforces the subject-keyed invariant and refuses to authorize on a stale or token-keyed decision: ```python import hashlib import time from dataclasses import dataclass, field class RevocationPropagationError(RuntimeError): """Raised when an authorization decision would be served past the staleness contract.""" pass @dataclass class CapabilityToken: subject: str caps: frozenset issued_at: float expires_at: float signature: bytes def token_hash(self) -> str: return hashlib.sha256(self.signature + self.subject.encode()).hexdigest() @dataclass class DecisionCacheEntry: subject: str caps: frozenset confirmed_standing_at: float token_exp: float = field(default=0.0) class FederatedAuthorizer: def __init__(self, staleness_contract_s: float, now=time.monotonic): self.staleness_contract_s = staleness_contract_s self._cache: dict[str, DecisionCacheEntry] = {} # keyed on SUBJECT, never token hash self._now = now def _revocation_known_recently(self, subject: str) -> bool: entry = self._cache.get(subject) if entry is None: return False return (self._now() - entry.confirmed_standing_at) <= self.staleness_contract_s def authorize(self, token: CapabilityToken, required: frozenset) -> bool: if self._now() >= token.expires_at: # Expired token: never authorize, regardless of cache. raise RevocationPropagationError( f"token for {token.subject} expired at {token.expires_at}; " "presented after expiry" ) if not self._revocation_known_recently(token.subject): # Cache miss or stale standing: must re-confirm with the issuing domain. # In production this calls alpha's revocation/status endpoint. confirmed = self._reconfirm_standing(token.subject) if not confirmed: raise RevocationPropagationError( f"subject {token.subject} revoked by issuing domain; " f"authority refused (token hash {token.token_hash()[:12]})" ) self._cache[token.subject] = DecisionCacheEntry( subject=token.subject, caps=token.caps, confirmed_standing_at=self._now(), token_exp=token.expires_at, ) entry = self._cache[token.subject] if not required.issubset(entry.caps): raise RevocationPropagationError( f"subject {token.subject} lacks required caps {required - entry.caps}" ) return True def _reconfirm_standing(self, subject: str) -> bool: # Placeholder: query the issuing domain's revocation set. # Returns False if the subject is revoked. return True ```