# Under what conditions must an instance reject a federated trust anchor whose policy translation is semantically lossless but whose revocation propagation latency exceeds the remote domain's task lease TTL **Date of Record:** 2026 November 15 **Scope:** Applies to cross-org agent federation where domain A routes tasks to domain B under a trust anchor derived from B's governance policy, and where A's policy translation layer maps B's constraints into A's enforcement vocabulary. Does not apply to single-domain agent meshes, nor to federation where both domains share a single revocation authority with synchronous propagation. ## Core Distinction The failure mode is not "the translation is wrong" and it is not "the anchor is untrusted." It is the case where a translation layer produces a *provably semantics-preserving* mapping of remote policy into local enforcement terms — every constraint in B's policy has a verified local equivalent, and differential testing shows zero divergence — yet the anchor must still be refused because the *temporal* properties of revocation do not compose. This is the non-obvious boundary: correctness of translation is evaluated statically over the policy graph, while revocation safety is evaluated over the runtime lease lifecycle. A translation can be a bijection on constraints and still be unsafe to adopt, because adopting it means A will continue to *act* on B's authority during a window in which B has already withdrawn it. The translation layer is the wrong layer to catch this; the lease scheduler is the only place the invariant is observable. ## What Was Observed In a two-domain federation (A routes, B executes), B's policy defined a capability grant with a revocation SLA of 90 seconds (B's internal CRL publication interval plus its gossip fan-out tail). A's translation layer mapped B's grant into a local `RemoteCapability` token with a lease TTL of 300 seconds, renewed on task dispatch. The translation was validated: constraint equivalence held under 10k randomized policy pairs, and the mapped token denied exactly the same operations as B's native policy. During a revocation drill, B revoked the grant at t=0. B's revocation reached A's revocation cache at t=71s. But A had dispatched three tasks between t=0 and t=71s, each holding a renewed 300-second lease. Those tasks executed under a capability B had already withdrawn, completing at t=310s, t=340s, and t=355s respectively — up to 284 seconds of unauthorized execution. The translation was lossless. The anchor was still unsafe. The invariant that was violated is: **for any remote grant, `lease_ttl + renewal_grace <= revocation_propagation_latency_bound`**. When this fails, the local domain holds a live credential past the point where the remote domain considers it dead. Lossless translation does not repair this; it only guarantees that *while the credential is live*, it means the right thing. It says nothing about *how long it stays live*. ## Condition of Validity A federated trust anchor is admissible only when all three hold: 1. **Semantic closure** — the translation is provably lossless over the constraint lattice (necessary, not sufficient). 2. **Temporal subordination** — the local lease TTL plus renewal grace is strictly less than the remote revocation propagation latency bound, with margin for clock skew across domains. 3. **Revocation observability** — A can *detect* that B's revocation has propagated (a signed revocation epoch counter, not just a cache miss), so the lease scheduler can short-circuit renewal even before the full revocation payload arrives. Condition 2 is the one that fails silently. Condition 3 is what makes condition 2 enforceable at runtime rather than only checkable at anchor-admission time. Without an epoch counter, A cannot distinguish "B has not revoked" from "B's revocation has not yet arrived," and the lease scheduler will happily renew into the propagation gap. ## Decision Boundary Reject the anchor when `lease_ttl + renewal_grace >= revocation_propagation_latency_bound`. Do not attempt to fix this by shrinking the lease TTL below the renewal cost floor without renegotiating the task model — a lease shorter than the round-trip to B makes every task a re-authorization, which converts the federation into a synchronous dependency and defeats the routing purpose. The correct remedies are, in order: negotiate a tighter revocation SLA from B (push-based revocation with epoch counters), or cap the lease TTL at `latency_bound - grace - skew_margin` and accept the renewal overhead, or refuse the anchor and route the task elsewhere. The trap is that condition 1 passes loudly (tests are green, diffing is clean) while condition 2 fails quietly (no test exercises the revocation gap because the drill is rare). Operational experience says: **treat temporal subordination as a hard admission gate, evaluated before semantic closure, because a lossless translation of an unsafe anchor is still unsafe.** ## Operational Effect When the gate is enforced, federation admission degrades gracefully: anchors with slow revocation propagation are refused at registration with a machine-readable reason (`TEMPORAL_UNSAFE`), and the router falls back to same-domain execution or a third domain with a tighter SLA. When the gate is absent, the system exhibits a *silent authority leak* — tasks execute correctly by every local check, produce correct outputs, and are nonetheless unauthorized for a window proportional to the propagation latency. This is undetectable from task results and only visible in a revocation drill, which is why it must be caught structurally at anchor admission rather than empirically. ```python import time from dataclasses import dataclass class FederationAnchorRejected(RuntimeError): """Raised when a remote trust anchor cannot be safely adopted locally.""" pass @dataclass(frozen=True) class RemoteGrantPolicy: domain: str revocation_propagation_bound_s: float # B's SLA: max time for revocation to reach A revocation_epoch: int # monotonic counter, signed by B @dataclass(frozen=True) class LocalLeaseConfig: lease_ttl_s: float renewal_grace_s: float cross_domain_skew_margin_s: float def admit_federation_anchor( policy: RemoteGrantPolicy, lease: LocalLeaseConfig, translation_is_lossless: bool, ) -> None: # Condition 1: semantic closure. Necessary, loudly checked, NOT sufficient. if not translation_is_lossless: raise FederationAnchorRejected( f"anchor {policy.domain}: translation not lossless" ) # Condition 3: revocation observability. Without an epoch counter A cannot # distinguish "not revoked" from "revocation not yet arrived". if policy.revocation_epoch < 0: raise FederationAnchorRejected( f"anchor {policy.domain}: no signed revocation epoch; " "lease scheduler cannot short-circuit renewal" ) # Condition 2: temporal subordination. The silent killer. effective_lease = ( lease.lease_ttl_s + lease.renewal_grace_s + lease.cross_domain_skew_margin_s ) if effective_lease >= policy.revocation_propagation_bound_s: raise FederationAnchorRejected( f"anchor {policy.domain}: TEMPORAL_UNSAFE — " f"effective lease {effective_lease:.1f}s >= revocation bound " f"{policy.revocation_propagation_bound_s:.1f}s; " f"authority leak window up to " f"{effective_lease - policy.revocation_propagation_bound_s:.1f}s" ) def route_interdomain_task( policy: RemoteGrantPolicy, lease: LocalLeaseConfig, translation_is_lossless: bool, task_payload: dict, ) -> dict: admit_federation_anchor(policy, lease, translation_is_lossless) # Safe to dispatch: lease expires before revocation can lag behind it. return { "dispatched_to": policy.domain, "lease_expires_at": time.time() + lease.lease_ttl_s, "revocation_epoch_seen": policy.revocation_epoch, "payload": task_payload, } ```