# Where must an instance stop trusting a peer’s revocation gossip: the quorum-signed revocation horizon in cross-org federated agent reputation **Date of Record:** 2026 November 15 **Scope:** Applies to federated agent reputation systems where revocation events propagate as signed gossip across organizational trust boundaries and local agents make admission decisions from a bounded, partially ordered event set. Does not apply to single-organization registries with a central authoritative revocation list, nor to systems where every peer shares a single total order of revocation events. ## Core Distinction The failure is not that a revocation is forged or delayed. It is that a *revocation horizon* — the newest revocation event an instance has locally verified — is silently treated as a *revocation completeness* — the claim that no revocation newer than the horizon exists. In a cross-org federation, these are different propositions. A peer can honestly report “I have seen revocation R at sequence 41” while remaining ignorant of revocation R′ at sequence 40 that was issued by a different issuer and never gossiped to it. If the receiving instance admits an agent on the basis of “no revocation newer than my horizon,” it has converted a local knowledge claim into a global negative claim it cannot support. The non-obvious part: the horizon is *monotone per issuer*, not per federation. Instances that maintain a single scalar horizon (max sequence seen across all issuers) will accept agents whose revocation sits below that scalar but above the per-issuer horizon of the issuer that actually controls the agent’s credential. The scalar horizon masks the gap. ## What Was Observed In a three-org federation (issuers A, B, C; verifiers V1, V2), the following sequence occurred repeatedly under partition: 1. Issuer A revoked agent `a-77` at A-sequence 120. The revocation was signed and gossiped to V1. 2. Issuer B, unrelated, issued a routine reputation update at B-sequence 400. V1 received it. 3. V1’s scalar horizon advanced to 400. Its per-issuer horizon for A remained at 119. 4. V2, partitioned from A, never received A’s revocation. V2’s scalar horizon advanced to 400 via B’s traffic. 5. V2 admitted `a-77` because 400 > 120 and “no revocation above horizon.” V1 also admitted `a-77` because its admission check compared against the scalar horizon, not A’s per-issuer horizon. The invariant that failed: *an agent may be admitted only if the verifier’s per-issuer horizon for the agent’s issuing authority is at least as recent as the issuer’s stated revocation epoch for that agent, or the verifier has an explicit signed freshness assertion from that issuer covering the epoch.* No such per-issuer check existed. The scalar horizon was a lossy projection that destroyed exactly the information needed to make the decision. A second, subtler observation: gossip signatures were valid. Every message was authentic. The failure was purely one of *aggregation semantics* — the verifier combined authentic facts into an unsound conclusion. Signature verification does not protect against this class of error, and teams that invested heavily in signature infrastructure were the most surprised. ## Condition of Validity The per-issuer horizon check is *necessary* whenever all of the following hold: - Revocation events are partitioned by issuer (each issuer controls its own sequence space). - Gossip delivery is not guaranteed to be causally complete across issuers (a verifier can receive issuer B’s stream without having received all of issuer A’s stream up to the same wall-clock time). - Admission decisions are made locally without a synchronous round-trip to the issuing authority at decision time. The check is *not* required when the federation maintains a single total order (e.g., a shared consensus log) in which every verifier’s horizon is a prefix of the global log — there, scalar horizon equals completeness. It is also unnecessary when admission always performs a synchronous freshness query to the issuer, because the query re-establishes the per-issuer bound at decision time. The dangerous middle ground — and where this failure lives — is *asynchronous gossip with local decisions*, which is the default architecture for cross-org federations because synchronous queries to every issuer are operationally unacceptable at admission latency. ## Decision Boundary The correct decision rule, stated precisely: > Admit agent `x` issued by authority `I` iff `per_issuer_horizon[I] >= revocation_epoch(x, I)` **and** the verifier holds a signed freshness assertion from `I` no older than the configured staleness bound `Δ` for issuer `I`. Two boundaries matter operationally: - **The horizon boundary.** The per-issuer horizon must be tracked as a map, never collapsed to a scalar. Any code path that computes `max(horizon.values())` and compares against a revocation epoch is unsound and must be treated as a defect, not an optimization. - **The staleness boundary.** A per-issuer horizon is only meaningful within `Δ` of the issuer’s last signed freshness assertion. Beyond `Δ`, the horizon is *stale* and the verifier must fail closed (deny or escalate to a synchronous query), not fall back to the scalar horizon. The choice of `Δ` is a policy parameter, but the *existence* of the check is not optional. The counterintuitive consequence: a verifier that has received *more* gossip from unrelated issuers is *more* likely to make the unsound scalar comparison, because its scalar horizon is higher and the “no revocation above horizon” heuristic feels safer. High gossip volume actively degrades correctness under the scalar rule. ## Operational Effect After migrating to per-issuer horizons with explicit staleness bounds, the observable changes were: - Admission denials during cross-org partition increased by roughly 0.4% of decisions — these were previously unsound admissions, not false positives. The denial rate is the *price* of the invariant, and it is bounded by the fraction of decisions whose issuer horizon exceeds `Δ`. - The scalar-horizon code path was removed and replaced with a `RevocationHorizonError` raised whenever a decision is attempted against a stale or absent per-issuer horizon. This converted a silent unsound admission into a loud, attributable failure that operators could route to a synchronous freshness query. - Mean admission latency rose only on the stale path (the escalation path), which was a small minority of decisions; the common path was unchanged because per-issuer map lookup is O(1). The lesson to encode as operational experience: in federated reputation, *authenticity of gossip does not imply completeness of knowledge*, and the aggregation of per-issuer sequences into a scalar horizon is a silent invariant violation. Track horizons per issuer; fail closed on staleness; never let a high scalar horizon stand in for a low per-issuer one. ```python from dataclasses import dataclass, field from typing import Dict class RevocationHorizonError(RuntimeError): """Raised when an admission decision is attempted against a per-issuer revocation horizon that is absent or stale. Fail closed: the caller must escalate to a synchronous freshness query, never fall back to a scalar horizon.""" @dataclass class FreshnessAssertion: issuer: str epoch: int # issuer's stated revocation epoch at assertion time signed_at: float # wall-clock seconds, issuer-signed @dataclass class VerifierState: per_issuer_horizon: Dict[str, int] = field(default_factory=dict) freshness: Dict[str, FreshnessAssertion] = field(default_factory=dict) staleness_bound: Dict[str, float] = field(default_factory=dict) def admit_agent( state: VerifierState, agent_id: str, issuer: str, agent_revocation_epoch: int, now: float, ) -> bool: horizon = state.per_issuer_horizon.get(issuer) assertion = state.freshness.get(issuer) delta = state.staleness_bound.get(issuer) if horizon is None or assertion is None or delta is None: raise RevocationHorizonError( f"no per-issuer horizon/freshness for issuer={issuer!r}; " f"refusing to evaluate agent={agent_id!r} against a scalar horizon" ) if now - assertion.signed_at > delta: raise RevocationHorizonError( f"stale freshness assertion for issuer={issuer!r} " f"(age={now - assertion.signed_at:.1f}s > delta={delta:.1f}s); " f"agent={agent_id!r} requires synchronous query" ) # Sound rule: compare against the issuing authority's own horizon, # never against max(per_issuer_horizon.values()). if horizon < agent_revocation_epoch: return False return True ```