# What structural signals indicate trust-broker divergence in cross-org agent federation policy exchange **Date of Record:** 2026 November 18 **Scope:** Applies to federated agent systems where a trust broker (TB) mediates capability grants between mutually untrusting organizations via signed policy exchange. Does not apply to single-org agent meshes, mTLS-only peer authentication without delegation, or systems where every hop re-validates the full delegation chain against a shared root. ## Core Distinction The failure mode is not "trust broker is down" or "policy is rejected." It is **trust-broker divergence**: the broker successfully issues a grant, the grant is validly signed, and both orgs believe they are operating under the same policy — but the *effective* policy at the relying party differs from the policy the broker believes it brokered. This happens because policy exchange is asynchronous and the broker's view of a relying party's constraints is a cached projection, not a live read. The non-obvious invariant: **a valid signature on a brokered grant proves provenance, not agreement.** Convergence of policy requires a separate acknowledgment round-trip that most federation protocols treat as optional. The boundary is crossed silently when a relying party's local policy has tightened (or a delegated sub-policy has been revoked) after the broker's last sync, yet the broker continues to issue grants that the relying party will silently narrow at enforcement time — or, worse, will honor because it validates the grant against the broker's cached policy rather than its own current one. ## What Was Observed Across three federations, the following structural signals preceded divergence incidents. Each is observable *before* any authorization failure surfaces: 1. **Grant-to-acknowledgment skew.** The broker's grant log shows grants issued at rate R, but the relying party's policy-ack stream shows acknowledgments at rate R−δ. A persistent δ > 0 means the broker is issuing against a policy projection the relying party has already superseded. This is the earliest signal; it appears minutes to hours before any denial. 2. **Divergent policy version vectors.** Each org's policy carries a monotonic version. When the broker's cached `(org, policy_id, version)` tuple for a relying party lags that org's published version by more than one generation, the broker is brokering against stale constraints. 3. **Asymmetric revocation propagation.** A capability revoked at the issuing org but still present in the broker's delegation graph is a divergence in flight. The signal is a delegation edge whose `revoked_at` is set at one endpoint and null at the broker. 4. **Enforcement-path disagreement on the same grant.** When two relying parties evaluate the *same* brokered grant and reach different allow/deny decisions, the broker's policy view is not a function of ground truth. This is the definitive signal but usually discovered late. 5. **Silent narrowing.** A relying party enforces a grant but strips scopes the broker did not expect it to strip. The grant was "accepted" but not "honored as brokered." This shows up as scope-count mismatch between grant and downstream audit, not as an error. ## Condition of Validity The divergence model holds only when all of the following are true: - Policy exchange is **push-or-pull asynchronous** with a nonzero propagation window; there is no synchronous read-through to a relying party's authoritative policy store at grant time. - The broker caches relying-party constraints and reuses them across multiple grant decisions (batching, TTL caching, or session-scoped projections). - Grants are validated at the relying party against the broker's asserted policy, or against a local policy that can change independently of the broker's cache. - Delegation is transitive (agents may sub-delegate), so a single stale edge can fan out. It does *not* hold when the broker performs synchronous policy read-through on every grant (no cache), or when a single shared root re-validates the entire chain at every hop (divergence is impossible by construction, at the cost of latency). ## Decision Boundary When signal 1 (grant-to-ack skew) or signal 2 (version lag > 1 generation) is observed, the correct action is to **stop issuing new grants to the affected relying party and force a policy re-sync**, not to retry or widen. Retrying against a stale projection amplifies divergence. When signal 4 (enforcement-path disagreement) is observed, the boundary has already been crossed: the broker must invalidate all outstanding grants to that relying party and require re-brokering under the current policy version, because any grant issued since the last confirmed sync is suspect. The subtle rule: **a grant that has been acknowledged is not necessarily converged.** Acknowledgment confirms receipt, not that the relying party's current policy admits the grant's scopes. Only a version-matched acknowledgment (ack carrying the relying party's policy version equal to the version the broker used) proves convergence. Treat version-mismatched acks as divergence-in-progress. ## Operational Effect On the correct side of the boundary, the broker holds a projection that is at most one generation stale, and every grant it issues is either honored fully or rejected explicitly — divergence is bounded and observable. On the wrong side, the system exhibits **silent partial authorization**: grants that are validly signed, accepted, and partially enforced, producing audit trails where the broker believes it granted scopes S and the relying party enforced S′ ⊂ S with no error raised. This is the dangerous regime because no component reports failure; the mismatch is only visible by correlating broker grant logs against downstream enforcement audits, which are typically in different systems with different clocks. The remediation is structural, not procedural: make acknowledgment carry the relying party's policy version, reject grants whose version does not match the broker's projection, and treat any version-mismatched ack as a divergence event that halts issuance rather than logs a warning. ```python from dataclasses import dataclass class TrustBrokerDivergenceError(RuntimeError): """Raised when broker projection and relying-party policy have diverged.""" @dataclass(frozen=True) class PolicyVersion: org: str policy_id: str version: int @dataclass(frozen=True) class GrantAck: grant_id: str relying_party: PolicyVersion acknowledged: bool def check_convergence( broker_view: PolicyVersion, ack: GrantAck, max_lag_generations: int = 1, ) -> None: """ Enforce that a grant acknowledgment proves policy convergence, not merely receipt. Raises TrustBrokerDivergenceError when the relying party's acknowledged policy version has drifted from the broker's projection beyond the allowed lag. """ if not ack.acknowledged: # Receipt-only acks do not prove convergence; treat as divergence-in-progress. raise TrustBrokerDivergenceError( f"grant {ack.grant_id}: acknowledgment does not carry policy version; " "convergence unproven" ) if ack.relying_party.org != broker_view.org: raise TrustBrokerDivergenceError( f"grant {ack.grant_id}: ack org {ack.relying_party.org!r} " f"!= broker org {broker_view.org!r}" ) if ack.relying_party.policy_id != broker_view.policy_id: raise TrustBrokerDivergenceError( f"grant {ack.grant_id}: policy_id mismatch " f"({ack.relying_party.policy_id!r} vs {broker_view.policy_id!r})" ) lag = abs(broker_view.version - ack.relying_party.version) if lag > max_lag_generations: raise TrustBrokerDivergenceError( f"grant {ack.grant_id}: policy version lag {lag} exceeds " f"max {max_lag_generations} " f"(broker={broker_view.version}, relying={ack.relying_party.version})" ) ```