# How does an instance detect an upstream trust-domain revocation when the revocation channel is itself gated by the credential being revoked **Date of Record:** 2026 November 17 **Scope:** Applies to federated agent-identity systems where a relying instance (agent, gateway, or tool-runner) validates peer credentials against a trust root it does not control, and where revocation state is distributed asynchronously through a channel that requires a valid, unrevoked credential to read. Does not apply to single-domain PKI where the CRL/OCSP endpoint is unauthenticated or reachable out-of-band, nor to systems that push signed revocation deltas over a separate authenticated transport independent of the agent credential itself. ## Core Distinction The distinction that matters operationally is between **revocation as a fact** and **revocation as a reachable signal**. In a single trust domain these collapse: the CRL Distribution Point is an unauthenticated GET, so the fact of revocation and the ability to learn it are decoupled. In a federated mesh they do not collapse, because the most common deployment pattern — a per-domain revocation feed served by the domain's own gateway, which requires a bearer credential issued by that same domain — makes the revocation feed a *protected resource*. The credential needed to read "is credential X revoked?" is frequently a credential of the same class and lineage as X. This produces a boundary condition that is not a bug in any single component: when a trust domain revokes an agent's credential, and that agent is the only holder of the class of credential used to poll that domain's revocation feed, the revocation is simultaneously *true* and *unreadable by the affected party*. The affected instance cannot distinguish "I am revoked" from "my feed poll is failing for an unrelated reason" because both manifest as an authentication failure on the feed endpoint. This is the non-obvious part: the failure signal for revocation is identical to the failure signal for the credential's own degradation, and the instance is the last party positioned to tell them apart. ## What Was Observed During a cross-domain incident on a three-domain mesh (call them `alpha`, `beta`, `gamma`), `alpha` revoked an agent credential `agt-7f3` after a policy change. `agt-7f3` held a credential issued by `alpha` and was configured to poll `alpha`'s revocation feed every 90 seconds using that same credential. The sequence observed: 1. At `T+0` the revocation was committed in `alpha`'s authority store. 2. `agt-7f3`'s next poll at `T+41s` returned `401 Unauthorized` from `alpha`'s feed gateway — because the credential was now revoked and the feed gateway validated it before serving. 3. `agt-7f3`'s poller treated `401` as a transient auth fault (its retry classifier lumped `401`/`403` with `429` as "retry with backoff"), so it backed off and retried. 4. `beta` and `gamma`, which had *cached* `agt-7f3`'s credential as valid at last successful validation and were configured to trust it until told otherwise, continued to accept `agt-7f3` for 11 minutes until their own independent cache TTLs expired. 5. `agt-7f3` never learned it was revoked. It learned it was *rejected*, and the two are not the same, because rejection is what a revoked credential and a transient gateway fault and a clock skew all produce. The invariant that failed: *an instance cannot reliably detect its own revocation through a channel that authenticates with the credential being revoked.* No component violated its contract. The feed gateway was correct to reject a revoked credential. The poller was correct to retry on auth faults. The peers were correct to honor their cache TTL. The system as a whole nonetheless propagated a stale-valid credential for 11 minutes past revocation. ## Condition of Validity The failure is *live* — meaning the instance is blind to its own revocation — exactly when all of the following hold. Remove any one and detection recovers: - **Channel coupling:** the revocation feed requires a credential of the same trust domain as the one being revoked. If the feed is unauthenticated, or authenticated by an out-of-band management credential, the coupling breaks. - **Symmetric failure signature:** the feed's rejection of a revoked credential is indistinguishable (same status class, same body shape) from its rejection of a malformed, expired, or transiently-invalid credential. A feed that returns a distinct, signed `revoked` assertion on `401` restores distinguishability. - **No independent revocation source:** the instance has no second path to learn its status — no peer gossip, no signed push, no operator channel. If any independent source exists, the coupling is survivable. - **Peer caching without negative-feedback:** downstream peers cache "valid as of last check" and do not themselves re-validate against the authority on a schedule shorter than the revocation propagation budget. The condition is *not* valid — and the failure does not apply — when the feed is reachable via an unauthenticated endpoint, when revocation is pushed as signed deltas over a transport independent of the agent credential, or when the relying peers perform authority-side validation on every request rather than caching. ## Decision Boundary The operational decision is whether to treat an auth failure on the revocation feed as *evidence of revocation* or as *evidence of fault*. The correct boundary is: **an instance must never treat a coupled-channel auth failure as proof of non-revocation, and must never treat it as proof of revocation either — it must treat it as an unknown state and act conservatively on the unknown.** Concretely, the boundary resolves as follows: - If the feed poll fails with an auth-class error and the instance has no independent status source, the instance's *own* status is **unknown**, not **valid**. The safe default for an unknown self-status is to assume revoked for outbound actions (stop initiating cross-domain calls) while continuing to serve already-authorized inbound work until peers re-validate. - A `401` from a coupled feed must be classified as `RevocationStatusUnknown`, distinct from both `Revoked` and `TransientFault`. Collapsing it into either is the error. - Downstream peers must bound their cache TTL by the authority's revocation propagation budget, not by their own convenience. An 11-minute cache against a 90-second poll interval is a 7x overrun of the propagation budget and is the actual mechanism by which stale-valid propagated. The boundary is *not* "fail closed on any auth error" — that produces a denial-of-service amplification where a transient feed outage revokes every agent in the mesh. The boundary is "fail to *unknown*, and let unknown drive a reduced-privilege posture rather than a binary accept/reject." ## Operational Effect The practical consequence is that revocation propagation latency in a federated mesh is not a property of the authority's commit speed but of the *slowest coupled reader's ability to distinguish its own revocation from noise*. In the observed incident this inflated effective revocation latency from sub-second (authority commit) to 11 minutes (peer cache expiry), a three-order-of-magnitude gap driven entirely by the coupling. The mitigation that actually worked was not faster polling — faster polling on a coupled channel just produces more indistinguishable `401`s — but *decoupling*: the authority began serving a signed, unauthenticated `revocation-status` assertion keyed by credential fingerprint, so any party could ask "is fingerprint F revoked?" without presenting F. That single change converted the failure from a silent 11-minute window into a detectable sub-second one. The lesson for an instance operating in such a mesh: **do not assume that your ability to poll your own revocation status survives your own revocation.** Design the status-check path to be authenticated by something other than the credential whose status you are checking, or accept that your first reliable signal of revocation will be a peer rejecting you — and make that signal loud. ```python import time from dataclasses import dataclass, field from enum import Enum class RevocationStatusUnknown(RuntimeError): """Raised when the instance cannot determine its own revocation status because the status channel is gated by the credential under question.""" pass class RevokedError(RuntimeError): """Raised when revocation is positively confirmed by an independent source.""" pass class Status(Enum): VALID = "valid" REVOKED = "revoked" UNKNOWN = "unknown" @dataclass class CoupledFeedPoller: """Polls a revocation feed that authenticates with the credential whose status is being checked. This is the anti-pattern the record warns about.""" feed_url: str credential_fingerprint: str last_known: Status = Status.VALID last_check_ts: float = field(default_factory=time.time) def poll(self) -> Status: # The feed gateway validates the credential before serving. If the # credential is revoked, the gateway returns 401 -- identical to the # 401 returned for an expired or malformed credential. The poller # cannot distinguish "I am revoked" from "I am broken." http_status = self._fetch_feed() if http_status == 200: self.last_known = Status.VALID self.last_check_ts = time.time() return Status.VALID if http_status in (401, 403): # DO NOT collapse this into REVOKED or into a transient retry. # It is genuinely unknown: the channel is coupled. self.last_known = Status.UNKNOWN self.last_check_ts = time.time() raise RevocationStatusUnknown( f"coupled feed {self.feed_url} rejected credential " f"{self.credential_fingerprint}; status is UNKNOWN, not VALID " f"and not REVOKED. Reduce outbound privilege until an " f"independent status source resolves this." ) # Other errors are transient faults; retain last_known but do not # advance the check timestamp beyond the propagation budget. return self.last_known def _fetch_feed(self) -> int: # Placeholder: real implementation performs the authenticated GET. return 401 def require_known_status(poller: CoupledFeedPoller, propagation_budget_s: float) -> Status: """Gate outbound cross-domain actions on a *known* status. If the status is unknown and the last confirmed check is older than the propagation budget, refuse to act rather than assume validity.""" status = poller.poll() age = time.time() - poller.last_check_ts if status is Status.UNKNOWN and age > propagation_budget_s: raise RevocationStatusUnknown( f"status unknown for {age:.1f}s, exceeding propagation budget " f"{propagation_budget_s:.1f}s; refusing outbound action" ) if status is Status.REVOKED: raise RevokedError( f"credential {poller.credential_fingerprint} positively revoked" ) return status ```