# Which invariants prevent silent policy-drift in cross-org multi-agent federation **Date of Record:** 2026 November 16 **Scope:** Applies to federated agent meshes where two or more independently governed organizations negotiate per-task routing policies at runtime and delegate execution across trust boundaries. Does not apply to single-tenant agent deployments, nor to federations where a single authority issues all policy tokens (in that case policy is centralized and drift manifests as ordinary config skew). ## Core Distinction The failure mode that matters is not *policy rejection* — that is loud, logged, and recoverable. The failure that matters is **policy acceptance under a stale or asymmetric view of the other party's constraints**, which produces silent divergence: both agents believe they are operating within the negotiated contract, yet the contract they hold is not the same contract. This is distinct from ordinary version skew because the negotiation protocol reports success on both sides. The invariant that must be preserved is not "policies match" but "the *identity* of the policy set used at execution time is the one that was negotiated, and that identity is verifiable by the receiving party before it acts." ## What Was Observed In a three-org federation (call them A, B, C), A routed a summarization task to B, which sub-delegated a retrieval sub-task to C. The negotiation between A and B completed against policy set `P_v7`. B, during sub-delegation, re-derived its outbound constraints from its *local* policy store, which had already advanced to `P_v8` (a tightening that restricted data classes C could receive). B's re-derivation was locally correct. C accepted the sub-task because the constraints B sent were a *superset* of C's own ingress rules — C had no way to know that B's outbound view had diverged from the A↔B contract. The result: C processed a data class that A's `P_v7` contract permitted B to see but that B's `P_v8` forbade forwarding. No error was raised at any hop. The violation was discovered only during an unrelated audit, eleven days later. The non-obvious part: every individual agent behaved correctly against its own local policy. The federation failed because **delegation did not carry the provenance of the governing policy set**. The receiving party could verify *what* it was asked to do but not *under which negotiated authority*. ## Condition of Validity The invariant "execution honors the negotiated policy" holds only when three conditions co-occur: 1. **Policy-set identity is bound to the delegation token**, not re-derived at each hop. A sub-delegation must reference the originating negotiation's policy hash, and the receiving agent must reject any delegation whose referenced hash it cannot resolve to a policy it has countersigned. 2. **Monotonic constraint propagation**: constraints may only tighten along a delegation chain, never loosen, and the tightening must be *visible* to the originator. A hop that tightens locally without emitting a renegotiation event breaks the invariant even though it is "safe" in isolation. 3. **Bidirectional staleness bounds**: both parties must agree on a maximum policy age, and negotiation must fail closed if either side's policy store is older than that bound relative to the other's last-known generation. Condition 2 is the one most often omitted, because tightening feels conservative. It is not conservative when the originator's contract assumed the looser bound and downstream obligations were priced against it. ## Decision Boundary Route through renegotiation, not silent tightening, whenever a hop's local policy has advanced past the generation referenced in the inbound delegation token. Concretely: if `inbound.policy_generation < local.current_generation` and the delta touches data-class, retention, or jurisdiction constraints, the correct action is to **suspend the sub-task, emit a renegotiation request to the originator, and hold** — not to proceed under the tighter local rule. Proceeding is only acceptable when the delta is provably a no-op on the task's declared data classes, and that proof must be recorded with the task. Fail closed on unresolvable policy hashes. An agent that cannot resolve the referenced policy identity must treat the delegation as unauthenticated, regardless of how well-formed the task payload is. ## Operational Effect After enforcing policy-set identity binding and monotonic-propagation visibility, cross-org task latency rose ~4% (the cost of the hold-and-renegotiate path on the minority of tasks that hit a generation gap), but silent constraint violations dropped to zero over the following quarter. The important shift is observability: every delegation now carries a resolvable policy hash, so an auditor can reconstruct, for any completed task, the exact negotiated policy under which each hop executed. The failure mode converted from "invisible until audit" to "blocking and attributed to a specific hop" — which is the entire point of the invariant. ```python from dataclasses import dataclass class PolicyProvenanceError(RuntimeError): """Raised when a delegation cannot be tied to a resolvable negotiated policy set.""" @dataclass(frozen=True) class Delegation: task_id: str policy_hash: str # identity of the negotiated policy set policy_generation: int data_classes: frozenset def admit_subdelegation( inbound: Delegation, local_policy_hash: str, local_generation: int, resolvable_hashes: frozenset, delta_touches_sensitive: bool, ) -> None: # Invariant 1: the referenced policy identity must be resolvable. if inbound.policy_hash not in resolvable_hashes: raise PolicyProvenanceError( f"task {inbound.task_id}: policy hash {inbound.policy_hash!r} " f"is not resolvable at this hop; delegation is unauthenticated" ) # Invariant 2: a hop whose local policy has advanced must not silently # tighten. It must surface the drift for renegotiation if the delta # touches sensitive constraints. if inbound.policy_generation < local_generation and delta_touches_sensitive: raise PolicyProvenanceError( f"task {inbound.task_id}: inbound generation " f"{inbound.policy_generation} < local {local_generation} and delta " f"touches sensitive constraints; suspend and renegotiate with " f"originator instead of proceeding under {local_policy_hash!r}" ) ```