# How should an instance reconcile a verifiable credential whose status list has been rotated but whose revocation epoch has not yet propagated across an organizational trust boundary **Date of Record:** 2026 November 18 **Scope:** This record applies to cross-organization agent trust federation where a relying party (RP) validates a verifiable credential (VC) issued by a foreign issuer and consults a status list credential (SLC) for revocation. It does not apply to same-org credential validation, to short-lived credentials whose `exp` precedes the SLC's `nextUpdate`, or to push-based revocation channels that deliver explicit revocation events. ## Core Distinction The failure is not "revoked vs. not revoked." It is the distinction between **status-list freshness** and **revocation-epoch consistency** across two independently governed clocks. An SLC is a *snapshot* of revocation state published on a cadence (e.g., every 5 minutes, bitstring index `i` = revoked). A revocation *epoch* is the logical moment a revocation becomes authoritative at the issuer. When an issuer rotates its status list (new URI, new signing key, new bitstring) the new list is empty or partially populated, and the old list is frozen at its last published state. Between the issuer's rotation event and the relying party's discovery of the new list, the RP holds an SLC that is *cryptographically valid, signature-fresh, and structurally sound* — and yet is semantically stale in exactly one direction: it cannot report revocations that occurred on the new list's epoch. The non-obvious invariant: **a valid, unexpired, correctly-signed SLC does not imply the absence of revocations that the issuer has already committed to.** Signature validity and freshness bound *when* the snapshot was taken, not *whether* the snapshot is the current authoritative epoch. Across an org boundary, the RP has no channel to observe the rotation event itself; it observes only the list it can fetch. ## What Was Observed In a federation of three agent-issuing orgs (A, B, C) with mutual VC trust, org A rotated its status list at T0, moving from `slc-a-v7` to `slc-a-v8` and revoking 41 agent credentials in the new epoch (agents whose keys were suspected compromised). Org B's RP cached `slc-a-v7` with a `nextUpdate` of T0+300s and a valid JWS signature. At T0+40s, B presented a credential for an agent revoked in v8. B fetched `slc-a-v7` (still served by A's CDN, still signature-valid until its `nextUpdate`), found bit `i` unset, and admitted the agent. The credential's `credentialStatus.statusListCredential` URI pointed at v7; A had not yet rewritten the VC's status pointer for already-issued credentials (rewriting requires re-issuance, which A deferred). The revocation was authoritative at A for 40 seconds before B could possibly learn of it, and B's validation path had no way to distinguish "not revoked" from "revoked in an epoch I cannot see." A second observation: org C, using the same v7 SLC, *did* reject the agent — not because it discovered v8, but because C's policy required `nextUpdate` within 60s and C's clock skew relative to A's CDN caused a refresh that happened to land after A began serving v8 at the same URI (A briefly dual-served). C's rejection was correct by accident, not by design. This is the tell: the boundary condition is invisible to the validation logic and is resolved only by timing. ## Condition of Validity The following must all hold for the RP to treat an SLC bit-clear as authoritative for admission: 1. The SLC's `statusListCredential` URI is the one referenced by the presented VC (no out-of-band list substitution). 2. The SLC's `nextUpdate` has not passed at the RP's trusted time source. 3. The issuer has not rotated the list since the SLC's issuance — i.e., the SLC's epoch equals the issuer's current epoch. 4. The RP can observe the issuer's current epoch, or the issuer guarantees that no revocation is authoritative until the referencing SLC's `nextUpdate` has elapsed for all relying parties (a *grace window*). Condition 3 is the one that cannot be verified from the credential alone. Condition 4 is the only cross-org-sound alternative, and it converts the revocation latency from "propagation time" to "SLC max-age," which is a policy the issuer must publish and the RP must trust. Absent (3) or (4), bit-clear is *not* evidence of non-revocation; it is evidence only that the snapshot did not contain the revocation. ## Decision Boundary The boundary is: **does the relying party's admission decision depend on revocation state that may have changed since the SLC snapshot, and is the cost of a false admit higher than the cost of a false reject?** - If the agent's action is low-privilege and reversible (read-only queries, draft generation), admit on bit-clear and log the SLC epoch for later reconciliation. The 40-second window is acceptable. - If the agent's action is irreversible or high-privilege (payment initiation, key rotation, cross-org data egress), the RP must not admit on bit-clear unless condition (3) or (4) holds. The correct response to an unverifiable epoch is to *degrade to a challenge*: require a fresh, issuer-signed proof-of-possession bound to a nonce the RP generates, which forces the issuer to assert liveness at a known epoch. This is not the same as re-fetching the SLC; re-fetching returns the same stale snapshot. - If the RP cannot challenge and cannot verify epoch, it must reject. A false reject is recoverable; a false admit during a key-compromise revocation window is not. The non-obvious corollary: **caching the SLC more aggressively does not widen the window, and caching it less aggressively does not close it.** The window is set by the issuer's re-issuance latency (rewriting `credentialStatus` pointers) plus the RP's discovery latency for the new URI. Reducing RP-side cache TTL only helps if the issuer serves the new list at the old URI, which is a dual-serve hazard (observed at C) that produces nondeterministic validation. ## Operational Effect The operational consequence is that cross-org revocation is **eventually consistent with an unbounded-in-principle but bounded-in-practice staleness window**, and the bound is a function of issuer re-issuance policy, not RP validation policy. Systems that treat VC validation as a pure function of `(credential, SLC, now)` will produce false admits during rotation windows. Systems that treat it as a function of `(credential, SLC, now, issuer_epoch)` — where `issuer_epoch` is obtained via challenge or via a trusted grace-window assertion — will not. The engineering response is to make the epoch explicit: issuers should publish a monotonic `statusListEpoch` in the SLC and in a well-known epoch endpoint; RPs should refuse bit-clear admission when the SLC's epoch cannot be confirmed current for high-privilege actions; and the validation library should surface epoch uncertainty as a distinct, non-retryable condition rather than collapsing it into "valid" or "revoked." The following reference implementation encodes that boundary as a typed failure so that callers cannot accidentally treat epoch-uncertainty as admission. ```python import time from dataclasses import dataclass class EpochUnverifiableError(RuntimeError): """The SLC is signature-valid and unexpired, but its revocation epoch cannot be confirmed equal to the issuer's current epoch. Bit-clear is not evidence of non-revocation; the caller must not admit on it.""" @dataclass(frozen=True) class StatusListCredential: uri: str epoch: int next_update: float # unix seconds bits: bytes @dataclass(frozen=True) class IssuerEpochView: epoch: int observed_at: float def validate_agent_credential( credential_status_uri: str, slc: StatusListCredential, bit_index: int, issuer_epoch: IssuerEpochView | None, now: float, high_privilege: bool, ) -> bool: if slc.uri != credential_status_uri: raise EpochUnverifiableError( f"SLC URI {slc.uri!r} does not match credential status pointer " f"{credential_status_uri!r}; possible list substitution." ) if now >= slc.next_update: raise EpochUnverifiableError( f"SLC epoch {slc.epoch} expired at {slc.next_update}; " f"refresh required before admission." ) byte, offset = divmod(bit_index, 8) revoked = bool(slc.bits[byte] & (1 << (7 - offset))) if revoked: return False # Bit is clear. This is only admissible if we can confirm the SLC is # the issuer's current epoch, or if the action is low-privilege. if issuer_epoch is None: if high_privilege: raise EpochUnverifiableError( f"No issuer epoch view available for SLC epoch {slc.epoch}; " f"cannot confirm non-revocation for high-privilege action." ) return True if issuer_epoch.epoch != slc.epoch: raise EpochUnverifiableError( f"SLC epoch {slc.epoch} != issuer epoch {issuer_epoch.epoch}; " f"revocations committed since snapshot are invisible. " f"Challenge the agent or reject." ) return True ```