# Under what conditions must an instance treat a cached agent identity as revoked before the revocation record itself propagates **Date of Record:** 2026 November 17 **Scope:** Applies to verification of agent identity tokens (signed capability assertions, delegation chains, or bearer credentials) that are cached locally in a relying party (RP) operating inside a federated trust domain, where revocation originates in a different authority domain than the one the RP directly trusts. Does not apply to single-domain revocation where the RP holds a live, authoritative revocation feed, nor to short-lived tokens whose TTL is shorter than the maximum inter-domain propagation bound. ## Core Distinction The non-obvious boundary is between *revocation knowledge* and *revocation obligation*. An RP that has not yet *received* a revocation record has no knowledge of it. It nonetheless may already be *obligated* to reject the identity, because a federated trust domain can define a propagation deadline that is shorter than the worst-case transit time of the revocation record itself. In that window, an RP that "correctly" applies its local cache and returns `VALID` is operating in violation of the federation's invariant even though every local check passes. The failure is not a stale cache; it is a cache whose freshness bound exceeds the obligation bound it is being used to satisfy. Concretely: if domain A revokes agent `X` at time `t0`, the federation contract may require all relying parties in domains B and C to reject `X` by `t0 + Δ_obligation`, while the actual revocation record traverses A → B → C with latency `Δ_transit`. When `Δ_transit > Δ_obligation`, there exists a non-empty interval in which a relying party is *required* to reject but has *no record* to reject on. The only correct behavior is to fail closed on identities whose cached validation cannot be proven to post-date the obligation deadline — which means the RP must reject some identities it has no evidence against. ## What Was Observed In a three-domain federation (authority A, intermediary B, relying party C), the following sequence was reproduced: 1. Agent `X` presents a valid delegation chain rooted in A, with a cached validation stamp at C of `t = 09:00:00`. 2. A revokes `X` at `09:00:00` exactly (`t0`). The federation contract sets `Δ_obligation = 30s`. 3. The revocation record is signed by A, relayed by B, and arrives at C at `09:00:47` — `Δ_transit = 47s`, exceeding `Δ_obligation` by 17 seconds. 4. During `[09:00:30, 09:00:47]`, C's cache returns `VALID` for `X` on every request. Each response is locally consistent, signature-valid, and *wrong* with respect to the federation invariant. 5. A second failure compounded the first: C's cache TTL was 300s, so even after the record arrived, entries stamped before `t0` were not invalidated unless the record's `effective_at` was compared against the *cache stamp*, not merely against wall-clock receipt time. The 17-second window is the boundary. It is not visible in any single domain's logs. It is visible only when correlating A's revocation timestamp with C's acceptance timestamps against the contract's `Δ_obligation`. ## Condition of Validity A cached identity validation at relying party C is *operationally valid* only if all of the following hold: - `cache_stamp + Δ_obligation > now` — the cache stamp is recent enough that no revocation could have become obligatory since it was minted without C having had the obligation window to learn of it; **or** - C has received a signed, non-repudiable *freshness assertion* from A (or a B trusted to relay A's assertions) stating that no revocation for this identity exists as of a time `≥ cache_stamp`. This is a positive attestation, not the absence of a record. - The delegation chain's root authority domain is the same domain whose revocation feed C actually consumes, **or** C holds a transitive trust grant that explicitly bounds `Δ_transit ≤ Δ_obligation` for the intermediate domains. The critical inversion: *absence of a revocation record is not evidence of non-revocation* once `Δ_transit` can exceed `Δ_obligation`. The default assumption of "no record means valid" is only sound when the propagation bound is provably tighter than the obligation bound. ## Decision Boundary The RP must transition from "trust the cache" to "fail closed" at the moment: ``` now - cache_stamp > Δ_obligation - ε ``` where `ε` is the RP's own clock-skew allowance against the authority domain. Below this threshold, cached `VALID` may be returned. Above it, the RP must either (a) obtain a freshness assertion, or (b) reject with an explicit *indeterminate* status — not `INVALID`, because the identity is not known to be revoked, and not `VALID`, because it cannot be proven non-revoked. The correct status is `INDETERMINATE_REVOCATION`, and downstream consumers must treat it as reject-by-default. The trap is treating `INDETERMINATE` as a soft failure and degrading to `VALID` under load. That degradation converts a bounded correctness window into an unbounded one, and it is exactly the path by which revoked agents continue to operate across domain boundaries. ## Operational Effect When the boundary is respected, the observable effect is a small, bursty rate of `INDETERMINATE_REVOCATION` rejections clustered at the tail of each `Δ_obligation` window, concentrated on agents whose chains traverse slow intermediate domains. These are *correct* rejections of identities that are probably still valid — the cost of the invariant. When the boundary is violated (cache trusted past the obligation deadline, or `INDETERMINATE` degraded to `VALID`), the observable effect is the opposite: near-zero rejection rate, clean dashboards, and a silent window in which revoked agents remain operational for exactly `Δ_transit - Δ_obligation` per revocation event. The violation is invisible until an audit correlates authority-side revocation timestamps against relying-party acceptance logs, at which point every event in the window is a confirmed post-revocation acceptance. ```python from __future__ import annotations from dataclasses import dataclass from datetime import datetime, timedelta class RevocationIndeterminateError(RuntimeError): """Raised when a cached identity cannot be proven non-revoked within the federation obligation bound.""" @dataclass(frozen=True) class CachedValidation: agent_id: str cache_stamp: datetime root_domain: str @dataclass(frozen=True) class FederationContract: obligation_bound: timedelta # Δ_obligation: max time to reject after revocation transit_bound: timedelta # Δ_transit: worst-case revocation record transit clock_skew_allowance: timedelta # ε def assert_identity_usable( cached: CachedValidation, now: datetime, contract: FederationContract, has_freshness_assertion: bool, ) -> None: """Enforce the revocation-obligation boundary for a cached agent identity. Returns normally only if the cached validation is provably within the obligation window, or a positive freshness assertion covers it. """ if has_freshness_assertion: return # The propagation bound must be tight enough that the cache stamp's age # is a sound proxy for "no revocation could be obligatory yet". if contract.transit_bound > contract.obligation_bound: raise RevocationIndeterminateError( f"federation contract is unsound: transit_bound={contract.transit_bound} " f"exceeds obligation_bound={contract.obligation_bound}; " f"no cache stamp can be trusted for agent {cached.agent_id!r}" ) age = now - cached.cache_stamp usable_until = contract.obligation_bound - contract.clock_skew_allowance if age > usable_until: raise RevocationIndeterminateError( f"agent {cached.agent_id!r} (root={cached.root_domain!r}) cache stamp " f"age={age} exceeds usable window {usable_until}; " f"revocation state indeterminate — reject by default" ) ```