# Which invariants prevent transitive trust escalation across federated policy-exchange boundaries **Date of Record:** 2026 November 15 **Scope:** Applies to multi-agent federations where org A brokers trust to org B, and org B brokers to org C, such that A's agents may invoke C's agents through B without a direct A↔C federation agreement. Does not apply to flat federations with a single shared trust root, nor to purely bilateral peerings with no brokering hop. ## Core Distinction The failure is not *trust propagation* — brokering is supposed to propagate trust. The failure is *policy propagation lag*: trust attributes travel with the delegation chain, but the *constraints* that qualify those attributes (scope limits, rate ceilings, data-classification restrictions, revocation windows) are exchanged out-of-band through a policy-exchange protocol that is eventually consistent. For a bounded window, a downstream agent holds a trust assertion whose qualifying policy has not yet arrived. The system must decide what a trust assertion *means* before its constraints are known. The naive answer — "trust the assertion, apply constraints when they arrive" — is the escalation vector. The correct answer is monotone-default: an unqualified assertion is the *narrowest* interpretation, and only widens as policy evidence arrives. ## What Was Observed Org A issued a scoped delegation to B: `read:telemetry`, `max_rate=50/s`, `no_pii`. B's broker, operating under its own federation policy, re-delegated to C. The re-delegation carried the capability set but the `no_pii` qualifier was encoded as a *policy reference* (`policy://A/telemetry-v3`) rather than an inline constraint — a design choice that kept delegation tokens small. C's policy cache had not yet fetched `telemetry-v3` when A's agent first invoked C's agent through B. The observed behavior: C's authorization layer treated the unresolved policy reference as *unconstrained* rather than *unknown*. A's agent, which had correctly self-limited to `no_pii` upstream, was handed a response containing PII because C's agent saw a capability token with no active restriction. The violation was not malicious on any party's part — every component behaved per its local spec. The invariant that broke was *implicit*: no component owned the statement "an unresolved policy reference is restrictive, not permissive." A second, subtler observation: revocation of B's brokering rights propagated to C within ~4 seconds (push), but the *policy* narrowing that accompanied the revocation took ~90 seconds (pull, batched). During that 90-second window, C honored delegations derived from B that A had already invalidated. The revocation channel and the policy channel had different consistency models and no ordering guarantee between them. ## Condition of Validity The monotone-default invariant is valid — and required — under all of the following: 1. Policy references are resolved asynchronously relative to trust assertions (any pull-based or batched-push policy exchange). 2. Delegation chains can exceed length 2 (i.e., brokering hops exist). 3. The policy-exchange channel and the trust-assertion channel are not transactionally coupled. It is *not* required when policy is inlined into every delegation token (no references), or when trust and policy are delivered in a single atomic exchange with a shared sequence number. In those cases the constraint is already present in the assertion and the invariant is vacuous. ## Decision Boundary The boundary is between **fail-closed-on-unknown** and **fail-open-on-unknown**, and it must be drawn at the *policy resolution layer*, not the trust layer. Concretely: - An assertion referencing an unresolved policy MUST be evaluated against the *intersection* of (a) the capability's declared minimum constraints and (b) the empty set of additional permissions — i.e., it grants nothing beyond the minimum until resolved. - The resolution timeout MUST be shorter than the minimum revocation-propagation window of any upstream broker in the chain. If B revokes in 4s but C's policy TTL is 90s, the 90s is the escalation window; the TTL must be tightened or the revocation must carry an inline narrowing. - A brokering hop MUST NOT re-delegate a capability with a policy reference it cannot itself resolve. B may only hand C a reference to a policy B has cached and validated. The boundary is crossed the moment any of these three is violated. The most common real-world violation is the third: brokers re-delegate references they have never resolved, assuming the origin will be reachable from downstream. Origin reachability is not a federation invariant. ## Operational Effect With the invariant enforced, the federation exhibits *bounded* escalation: an agent can at worst receive the minimum-constrained capability during the resolution window, never more than the origin intended. Throughput of legitimate cross-org calls drops slightly during cold-start (policy fetch latency becomes call latency on first use), which is the intended cost. Without it, the federation exhibits *unbounded* escalation proportional to policy-fetch latency, and — critically — the escalation is invisible to the origin, which sees only a compliant downstream call. Audit logs at A show `no_pii`; audit logs at C show no restriction; the discrepancy is only reconstructable by correlating policy-cache timestamps across three orgs. The operational lesson: when trust and policy travel on different channels, the *slower* channel defines the security boundary, and every hop must treat the unresolved state as the restrictive state. ```python class TrustEscalationError(RuntimeError): """Raised when a delegation would grant more than the origin intended because a referenced policy has not been resolved locally.""" pass def authorize_delegation( capability: str, policy_ref: str, local_policy_cache: dict, max_resolution_window_s: float, revocation_window_s: float, ) -> dict: """Fail-closed authorization for a brokered delegation. Returns the effective constraint set. Raises if the policy reference is unresolved and cannot be safely treated as restrictive. """ if max_resolution_window_s >= revocation_window_s: # The policy channel is slower than the revocation channel: # an upstream revocation could be honored before its narrowing # policy arrives. This is an unbounded escalation window. raise TrustEscalationError( f"policy resolution window ({max_resolution_window_s}s) " f">= revocation window ({revocation_window_s}s); " f"escalation window is unbounded" ) resolved = local_policy_cache.get(policy_ref) if resolved is None: # Unresolved reference: grant only the minimum constraint set. # Do NOT pass the capability through unconstrained. return { "capability": capability, "constraints": {"scope": "minimum", "policy_resolved": False}, "escalation_risk": "bounded", } return { "capability": capability, "constraints": resolved, "policy_resolved": True, "escalation_risk": "none", } def broker_redelegate( capability: str, policy_ref: str, local_policy_cache: dict, downstream_org: str, ) -> dict: """A broker must not re-delegate a reference it cannot resolve.""" if policy_ref not in local_policy_cache: raise TrustEscalationError( f"broker cannot re-delegate unresolved policy {policy_ref!r} " f"to {downstream_org}; resolve locally first" ) return { "capability": capability, "policy_ref": policy_ref, "constraints": local_policy_cache[policy_ref], } ```