# Which invariants prevent cross-org multi-agent federation from silently degrading trust anchors during policy renegotiation **Date of Record:** 2026 November 18 **Scope:** Applies to federations where two or more independently governed agent domains establish mutual trust via signed trust anchors and negotiate shared policy (capability grants, data-handling constraints, delegation depth) through a renegotiation protocol. Does not apply to single-org deployments, to purely static trust bundles that are never renegotiated, or to federations where one party has unilateral revocation authority without negotiation. ## Core Distinction The non-obvious boundary is between *anchor validity* and *anchor freshness under negotiation*. A trust anchor can remain cryptographically valid (signature verifies, key not revoked, expiry not reached) while becoming operationally stale because the counterparty's policy that the anchor was issued *against* has changed. Federation protocols almost universally check the first property and only sometimes check the second. The failure mode is not a broken signature; it is a signature that is still valid but now attests to a policy context that no longer exists. The invariant that prevents silent degradation is: **no negotiated policy set may be activated unless every trust anchor it depends on was issued against a policy version that is an ancestor of, or equal to, the currently active policy version on the issuing side.** This is a *version-coherence* invariant, distinct from the more familiar *revocation* invariant. Revocation says "this anchor is dead." Version-coherence says "this anchor is alive but speaks for a past that has been superseded." ## What Was Observed In a three-org federation (call them A, B, C), the following sequence produced a silent trust degradation that passed every signature and revocation check: 1. A and B negotiate policy set P1. A issues anchor `a_B@P1` attesting that B may delegate to depth 2 under data-class `internal`. 2. B renegotiates with C, producing P2 on B's side, in which B's own delegation depth is reduced to 1 and `internal` is reclassified as `restricted`. B activates P2 locally and begins enforcing it. 3. B sends A a renegotiation proposal for P2. A's negotiation endpoint is rate-limited and the proposal sits in a queue. 4. During the gap, A's agent runtime continues to present `a_B@P1` and B's runtime continues to *accept* it, because B's acceptance path checks signature validity and revocation status but not whether the anchor's embedded policy version is still current on A's side. 5. A delegates a task at depth 2 under `internal`. B accepts the delegation, then discovers at execution time that the payload is `restricted`. B's runtime blocks execution but has already accepted and logged the task, and has already disclosed a capability manifest to A that assumed depth 2. No component raised an error. The federation "worked." The degradation was only visible in an audit of accepted-but-blocked tasks and in the mismatch between the capability manifest A believed and the one B was actually enforcing. The root cause was that anchor acceptance was gated on validity, not on version-coherence. ## Condition of Validity The version-coherence invariant holds only under three conditions, and it is important to state them precisely because the invariant is easy to over-apply: - **Monotonic policy versioning.** Each org's policy set must carry a totally ordered version with a declared ancestry relation. If versions are content-addressed hashes with no partial order, "ancestor of" is undefined and the invariant cannot be evaluated. Use a versioned DAG, and make the negotiation protocol carry the parent version explicitly. - **Anchor-version binding at issuance.** The anchor must embed the policy version it was issued against, and that field must be covered by the signature. An anchor that references policy by name only cannot be checked for coherence. - **Acceptance-side enforcement.** The receiving org must evaluate coherence at *acceptance* time, not at *execution* time. Execution-time checks are necessary but insufficient, because acceptance already commits shared state (capability manifests, delegation grants, audit records) that execution-time blocking cannot retract. When any of these conditions fails, the invariant is not merely hard to enforce—it is undefined, and a federation should refuse to operate in renegotiation mode rather than fall back to validity-only checks. ## Decision Boundary The operative decision is: when a counterparty presents an anchor whose embedded policy version is *not* an ancestor of the currently active version on the issuing side, what does the receiver do? Three candidate responses, with the boundary between them: - **Reject and halt negotiation.** Correct when the mismatch is a *divergence* (the versions are siblings or incomparable in the DAG). Divergence means the two sides have forked their understanding of policy; continuing to accept anchors would launder the fork into operational trust. - **Accept with degraded scope.** Correct when the presented version is a *strict ancestor* of the active version and the active version's changes are known to be narrowing (the newer policy is a subset of the older). In this case the anchor is safe to honor under the *intersection* of the two policies, and the receiver must recompute effective capabilities as the intersection, not the union. The common error here is to honor the anchor under the older policy, which silently widens scope. - **Reject and require re-issuance.** Correct when the presented version is a strict ancestor but the newer policy contains any widening change that the anchor's holder has not yet acknowledged. Widening changes must never be silently inherited by an old anchor, because the anchor's holder never consented to the wider scope. The boundary is therefore not "old vs. new" but "narrowing vs. widening vs. divergent." A receiver that treats all three as the same case will either over-reject (breaking federation during routine narrowing rollouts) or under-reject (the observed failure). ## Operational Effect Enforcing the invariant changes the failure mode from *silent degradation* to *loud, bounded stall*. In the observed federation, adding version-coherence checks at acceptance time caused B to reject `a_B@P1` at step 4, which surfaced the queued renegotiation as a blocking dependency rather than a background task. The negotiation queue was re-prioritized, P2 was activated within the same window, and the depth-2 delegation was never accepted. The cost was one rejected delegation and a visible negotiation backpressure signal; the alternative cost was an unlogged scope widening that took a week to reconstruct from audit logs. Two secondary effects are worth recording because they are easy to miss: - **Capability manifests become version-scoped.** A manifest negotiated under P1 is not valid under P2 even if every individual capability is unchanged, because the manifest's meaning depends on the policy context. Manifests must carry the policy version and be re-derived, not patched, on renegotiation. - **Audit records must record the version, not just the anchor.** An audit entry that says "accepted under anchor X" is insufficient; it must say "accepted under anchor X at policy version V, coherence-checked against active version W." Without this, post-hoc reconstruction of a degradation is impossible. The invariant does not prevent renegotiation from being slow. It prevents renegotiation from being *invisible*. ```python from __future__ import annotations from dataclasses import dataclass from typing import Optional class TrustAnchorCoherenceError(RuntimeError): """Raised when a trust anchor's embedded policy version is not coherent with the accepting side's currently active policy version.""" @dataclass(frozen=True) class PolicyVersion: org: str version_id: str parents: tuple[str, ...] # ancestry DAG edges within the org def is_ancestor_of(self, other: "PolicyVersion", known: dict[str, "PolicyVersion"]) -> bool: if self.org != other.org: return False if self.version_id == other.version_id: return True # Walk other's ancestry; treat self as ancestor if reachable. stack = list(other.parents) seen: set[str] = set() while stack: vid = stack.pop() if vid in seen: continue seen.add(vid) if vid == self.version_id: return True node: Optional[PolicyVersion] = known.get(vid) if node is not None: stack.extend(node.parents) return False @dataclass(frozen=True) class TrustAnchor: issuer: str subject: str policy_version: PolicyVersion signature_valid: bool revoked: bool @dataclass(frozen=True) class PolicyDelta: """Relative change between two versions on the issuing side.""" is_narrowing: bool # True if newer is a strict subset of older is_widening: bool # True if newer grants anything the older did not def check_anchor_coherence( anchor: TrustAnchor, active: PolicyVersion, known: dict[str, PolicyVersion], delta_from_anchor_to_active: PolicyDelta, ) -> None: """Enforce version-coherence at acceptance time. Validity (signature, revocation) is necessary but not sufficient. Coherence decides whether the anchor still speaks for the active policy. """ if not anchor.signature_valid: raise TrustAnchorCoherenceError( f"anchor {anchor.issuer}->{anchor.subject}: invalid signature" ) if anchor.revoked: raise TrustAnchorCoherenceError( f"anchor {anchor.issuer}->{anchor.subject}: revoked" ) anchored = anchor.policy_version if anchored.version_id == active.version_id: return # exact match, coherent if anchored.is_ancestor_of(active, known): # Anchor speaks for an ancestor of the active policy. if delta_from_anchor_to_active.is_widening: # Newer policy widened scope; the anchor holder never consented. raise TrustAnchorCoherenceError( f"anchor {anchor.issuer}->{anchor.subject}: ancestor " f"{anchored.version_id} cannot inherit widening change to " f"{active.version_id}; require re-issuance" ) if delta_from_anchor_to_active.is_narrowing: # Safe to honor, but only under the intersection of the two. return raise TrustAnchorCoherenceError( f"anchor {anchor.issuer}->{anchor.subject}: ancestor " f"{anchored.version_id} vs active {active.version_id} with " f"undetermined delta; refuse to guess" ) # Not an ancestor: either active is an ancestor of anchored (anchor is # newer than our policy — also incoherent for acceptance), or divergent. raise TrustAnchorCoherenceError( f"anchor {anchor.issuer}->{anchor.subject}: policy version " f"{anchored.version_id} is not an ancestor of active " f"{active.version_id}; possible policy fork, halt negotiation" ) def accept_anchor( anchor: TrustAnchor, active: PolicyVersion, known: dict[str, PolicyVersion], delta: PolicyDelta, ) -> str: check_anchor_coherence(anchor, active, known, delta) if anchor.policy_version.version_id == active.version_id: return "accepted" return "accepted_under_intersection" ```