# How should an instance treat a revocation that arrives after local policy has already authorized the action **Date of Record:** 2026 November 18 **Scope:** Applies to federated agent identity systems where a relying party (RP) caches authorization decisions derived from a remote trust domain's revocation state, and where the RP may act on those decisions between the moment of local authorization and the moment a revocation token from the issuing domain is observed. Does not apply to single-domain revocation, to synchronous online introspection on every call, or to systems where the RP holds no cached authority. ## Core Distinction The naive model of revocation propagation treats revocation as a *state transition*: an identity is valid, then a revocation event flips it to invalid, and the RP observes the flip and stops authorizing. The non-obvious boundary is that in federated settings the RP does not observe a state transition. It observes a *late-arriving assertion about a past interval*. A revocation token from trust domain A carries an `effective_at` timestamp that is almost always earlier than the RP's receipt time, and frequently earlier than the RP's most recent successful authorization of the agent in question. The distinction that matters operationally is between **revocation as a gate** (checked before action) and **revocation as a correction** (applied to history). RPs that implement the gate correctly still fail the correction: they stop future actions but leave already-authorized, in-flight, or recently-completed actions treated as legitimate. The invariant that is actually violated is not "revoked identities must not act" — it is "the RP's local decision log must not assert authority that the issuing domain retroactively denies." Those are different invariants, and only the first is commonly implemented. ## What Was Observed In a three-domain federation (issuer A, broker B, relying parties R1..Rn), agent credentials were issued by A with 15-minute validity and a revocation feed published to B. RPs cached A's revocation set for up to 60 seconds and cached authorization decisions for up to 5 minutes. The feed itself had a median propagation delay of 4.2 seconds from A's revocation commit to B's publication, and a p99 of 38 seconds under load. A compromised agent credential was revoked at A at T0. The RP in question had authorized an action at T0−71s and cached that decision. The revocation reached the RP at T0+9s. The RP's gate correctly rejected the *next* request at T0+9s onward. However: 1. The action authorized at T0−71s completed at T0+3s, after the revocation's `effective_at` (T0) but before the RP observed it. The RP recorded it as authorized. 2. A retry of that action, queued locally, was replayed at T0+12s against the *cached decision* rather than re-evaluated, and succeeded despite the gate — because the gate was on the request path, not the replay path. 3. Audit reconciliation three days later found 14 actions in the RP's log stamped "authorized by A" that A's own log marked as occurring after revocation. The failure was not a race in the revocation feed. The feed was correct and timely. The failure was that the RP's decision cache and its replay path were outside the revocation gate, and that the RP's audit log conflated "authorized at decision time" with "authorized at action time." ## Condition of Validity The gate model is valid only under the conjunction: - Every action path re-evaluates or re-validates the decision against the current revocation set at action time, not decision time; **and** - The decision cache's TTL is strictly less than the minimum revocation propagation delay the RP is willing to tolerate; **and** - The RP's audit log distinguishes decision timestamp from action timestamp and can be retroactively corrected. When any of these fails, the RP is operating under a *stale-authority* condition: it holds and exercises authority that the issuer has already withdrawn. Stale authority is not a security bug in the credential; it is a correctness bug in the RP's model of what a revocation assertion means. The condition is especially dangerous because it is invisible to the gate: the gate reports "revoked, blocked" for every post-observation request, giving a false sense of correctness while the replay and in-flight paths remain open. A second validity condition is often missed: the revocation token's `effective_at` must be trusted only to the precision the issuer guarantees. If A's clock skew relative to the RP exceeds the decision-cache TTL, the RP cannot order its decisions against `effective_at` at all, and must fall back to treating all decisions within a skew window as indeterminate rather than authorized. ## Decision Boundary The operational rule is a boundary between **fail-open on stale authority** and **fail-closed on indeterminate authority**: - If the RP can prove, from its own monotonic clock and the issuer's signed `effective_at` plus a bounded skew, that an action occurred strictly before `effective_at`, the action is authorized and the log is correct. - If the action occurred strictly after `effective_at` and the revocation was observed before the action, the action is unauthorized and must be flagged for reconciliation. - If the ordering is indeterminate (skew exceeds the TTL, or the action is in-flight across the observation point), the RP must treat the action as **provisionally unauthorized**: allow it to complete if interrupting would cause greater harm, but mark it in the audit log as `authority_indeterminate` and route it to reconciliation rather than recording it as authorized. The boundary is not "block or allow." It is "authorized, unauthorized, or indeterminate," and the third category must exist explicitly in the data model. Systems that collapse indeterminate into authorized are the ones that fail audit. Systems that collapse it into unauthorized will interrupt legitimate long-running actions during normal feed jitter and will be tuned to disable the check — which is the worse failure. ## Operational Effect Implementing the three-valued model changes three things. First, the decision cache must carry the issuer's `effective_at` watermark alongside the decision, and the replay path must compare against the current watermark rather than the cached decision. Second, the audit log gains an `authority_state` column with the indeterminate value, and reconciliation jobs consume it. Third, the RP must publish its own skew bound and refuse to make ordering claims outside it, which forces the issuer and RP to negotiate clock discipline as part of the trust establishment rather than discovering the mismatch during an incident. The residual risk is that indeterminate actions accumulate during feed outages. The mitigation is a bounded indeterminate window: if the RP cannot observe a fresh revocation watermark within `2 × p99_propagation`, it must stop authorizing new actions rather than continue on stale authority. This converts an unbounded stale-authority condition into a bounded availability hit, which is the correct trade for a revocation system. ```python import time from dataclasses import dataclass from enum import Enum class StaleAuthorityError(RuntimeError): """Raised when an RP would exercise authority the issuer has withdrawn.""" class AuthorityState(Enum): AUTHORIZED = "authorized" UNAUTHORIZED = "unauthorized" INDETERMINATE = "authority_indeterminate" @dataclass(frozen=True) class RevocationWatermark: effective_at: float # issuer-signed, epoch seconds observed_at: float # RP monotonic receipt time max_skew: float # negotiated bound between issuer and RP def classify_action( action_at: float, watermark: RevocationWatermark | None, decision_ttl: float, now: float, ) -> AuthorityState: if watermark is None: # No revocation state at all: cannot claim authority. raise StaleAuthorityError("no revocation watermark observed; refusing to authorize") # If the watermark is older than the tolerated propagation window, the RP # is operating on stale authority and must not extend new authority. if now - watermark.observed_at > 2.0 * decision_ttl: raise StaleAuthorityError( f"revocation watermark stale by {now - watermark.observed_at:.1f}s; " "bounded indeterminate window exceeded" ) if action_at + watermark.max_skew < watermark.effective_at: return AuthorityState.AUTHORIZED if action_at - watermark.max_skew > watermark.effective_at: return AuthorityState.UNAUTHORIZED # Action straddles the effective_at within skew: ordering is not provable. return AuthorityState.INDETERMINATE def record_action( action_at: float, watermark: RevocationWatermark | None, decision_ttl: float, now: float, ) -> AuthorityState: state = classify_action(action_at, watermark, decision_ttl, now) if state is AuthorityState.INDETERMINATE: # Route to reconciliation rather than silently recording as authorized. # The caller must not treat this as a clean success. return state if state is AuthorityState.UNAUTHORIZED: raise StaleAuthorityError( f"action at {action_at:.3f} postdates revocation effective_at " f"{watermark.effective_at:.3f} beyond skew {watermark.max_skew:.3f}" ) return state ```