# When must an instance refuse a federated capability grant it cannot verify? Trust-broker attestation staleness in cross-org multi-agent federation **Date of Record:** 2026 November 16 **Scope:** Applies to cross-org multi-agent federations where a trust broker mediates capability grants between mutually distrusting organizations, and where the granting broker's attestation of a peer's policy state may lag the peer's actual state. Does not apply to single-org agent meshes operating under one policy authority, nor to federations where every inter-org call is synchronously policy-checked against a live authority. ## Core Distinction The boundary is not "trusted vs. untrusted broker." It is **verified-now vs. verified-then**. A capability grant carries two distinct pieces of state: the *delegation chain* (who authorized this capability for this principal, signed by whom) and the *policy predicate* (the conditions under which the capability is valid at the peer). Delegation chains are append-only and cryptographically checkable offline. Policy predicates are mutable and only meaningful relative to a version of the peer's policy document. The failure mode is treating a validated delegation chain as sufficient to conclude the policy predicate still holds. It does not. A broker can prove *that* org B granted org A's agent `task:submit` on queue `q`, while being entirely unable to prove that B's current policy still permits submissions to `q` from A's trust tier. ## What Was Observed During a federation between three orgs (call them A, B, C) with a broker run by C, A's planner agent requested `task:submit` on a B-owned queue. The broker returned a grant with a signed delegation chain and a policy-predicate hash `p_h` referencing B's policy document version 41. B had rotated to version 42 six minutes earlier, tightening the trust-tier requirement for that queue from `tier>=2` to `tier>=3`; A's agent was tier 2. The broker's cache TTL for B's policy documents was 15 minutes. The grant validated cleanly at A: signature chain intact, predicate hash matched the *cached* document, tier check passed against version 41. A submitted 1,400 tasks over the next nine minutes. B's ingress rejected all of them with `policy_version_mismatch`, but B's task router had already enqueued side-effect intents (audit records, quota debits) before the ingress check, producing 1,400 orphaned audit entries and a quota overdraw that took B's ops team a day to reconcile. The broker never errored. Every signature was valid. The failure was strictly a temporal one: the grant was *verified-then*, and the consumer treated it as *verified-now*. ## Condition of Validity A federated capability grant is operationally valid only if all three hold at the moment of use, not the moment of issuance: 1. The delegation chain is unrevoked (checkable via a revocation list or short-lived tokens). 2. The policy-predicate hash resolves to a document whose version is still current at the peer. 3. The peer's ingress enforces the predicate *before* any side effect, not after. Condition 3 is the one teams forget. Even a correct grant can produce orphaned side effects if the peer's enforcement point sits downstream of state mutation. The federation's correctness invariant is therefore not "grants are valid" but "grant validity is re-established at the enforcement boundary, and enforcement precedes mutation." A broker that cannot establish (2) at use-time must be treated as able to issue only *conditional* grants, which the peer must resolve locally. ## Decision Boundary An instance must refuse to act on a federated grant — and must escalate to policy renegotiation rather than proceed — when the grant's policy-predicate version cannot be confirmed current within a bounded staleness window that the *peer* defines, not the broker. Concretely: if the peer publishes `max_policy_staleness` and the grant's predicate age exceeds it, the grant is dead on arrival regardless of signature validity. If the peer does not publish such a bound, the instance must assume a staleness bound of zero and renegotiate. The non-obvious corollary: a broker with a *longer* cache TTL than the peer's staleness bound is structurally incapable of issuing safe grants for that peer, and no amount of signature verification fixes it. The fix is architectural — push policy versions into the grant and require peer-side resolution — not cryptographic. ## Operational Effect Federations that adopt peer-defined staleness bounds and ingress-before-mutation enforcement see orphaned-side-effect rates drop to zero and replace them with a clean, observable failure: `GrantStaleError` at the consumer, triggering renegotiation. The cost is latency — every grant resolution now includes a version check against the peer — and a new failure surface where peers with flapping policy versions cause grant thrash. The trade is correct: a loud, recoverable staleness error is strictly better than a silent, valid-looking grant that corrupts the peer's audit and quota state. Brokers should be configured with cache TTLs strictly below the minimum `max_policy_staleness` across all peers they serve, and that minimum should be treated as a hard federation parameter, not a tuning knob. ```python import time from dataclasses import dataclass class GrantStaleError(RuntimeError): """Raised when a federated capability grant's policy predicate cannot be confirmed current at the peer within the peer-defined staleness bound.""" pass @dataclass(frozen=True) class FederatedGrant: capability: str delegation_chain_valid: bool policy_version: int issued_at: float # monotonic seconds peer_max_staleness: float | None # None => peer publishes no bound def resolve_grant_at_peer( grant: FederatedGrant, peer_current_policy_version: int, now: float, ) -> None: """Resolve a grant at the peer's enforcement boundary, before any side effect. Raises GrantStaleError if the grant cannot be confirmed current. """ if not grant.delegation_chain_valid: raise GrantStaleError( f"delegation chain invalid for capability={grant.capability!r}" ) # Peer publishes no staleness bound => assume zero tolerance. if grant.peer_max_staleness is None: if grant.policy_version != peer_current_policy_version: raise GrantStaleError( f"no staleness bound published; policy version " f"{grant.policy_version} != peer current " f"{peer_current_policy_version} for {grant.capability!r}" ) return age = now - grant.issued_at if age > grant.peer_max_staleness: raise GrantStaleError( f"grant age {age:.3f}s exceeds peer staleness bound " f"{grant.peer_max_staleness:.3f}s for {grant.capability!r}" ) if grant.policy_version != peer_current_policy_version: raise GrantStaleError( f"policy predicate version {grant.policy_version} is stale; " f"peer is at {peer_current_policy_version} for " f"{grant.capability!r}; renegotiate" ) ```