# What structural signals indicate trust anchor divergence during cross-org agent federation (and why reputation exchange masks it until policy enforcement) **Date of Record:** 2026 November 18 **Scope:** Applies to federations of autonomous agents where each participating organization publishes a trust anchor (root key or policy issuer) that peers use to validate delegated credentials, and where reputation is exchanged as a secondary signal. Does not apply to single-org agent meshes, nor to federations with a single shared root of trust under one administrative domain. ## Core Distinction There are two failure classes that look identical at the API surface but have different remediation paths: 1. **Reputation divergence** — peers disagree about an agent's score because their observations differ. This is expected, self-correcting, and bounded by the reputation exchange protocol's convergence properties. 2. **Trust anchor divergence** — peers disagree about *which root key is authoritative* for a given org's delegated credentials. This is not self-correcting. It produces a stable, silent split where each side believes the other is behaving maliciously or is compromised. The non-obvious invariant: **reputation exchange will converge even when trust anchor divergence is present**, because reputation messages are typically signed by the exchanging peer's *own* anchor, not the subject agent's anchor. So a federation can report healthy reputation convergence (low KL divergence between score distributions, stable rank correlation) while policy enforcement is silently partitioned. Convergence of reputation is therefore *not* evidence of federation health — it is orthogonal to it, and in practice it actively masks anchor divergence by keeping the "federation looks alive" dashboard green. ## What Was Observed During a multi-week federation run across six orgs with independent anchors: - Reputation rank correlation (Spearman) between all pairs stayed above 0.94 throughout. No alert fired. - Policy decisions on the *same* delegated credential diverged by org pair. Org A accepted a delegation chain that Org B rejected with `untrusted_issuer`. The credential was identical; the anchors were not. - The divergence appeared only after a scheduled anchor rotation on one org (call it Org C). Org C published a new anchor with a 72-hour overlap window. Orgs that had cached Org C's *previous* anchor and had not implemented overlap-window handling continued to validate against the old root until it expired, then hard-failed. - Critically, during the overlap window, both old and new anchors were technically valid. Agents on either side of the split each had a *locally correct* view. There was no error state to detect — only a disagreement about authority. - The signal that actually predicted the eventual partition was not in reputation data. It was structural: the set of anchor fingerprints each peer had *pinned* diverged from the set published in the federation's anchor directory, and the divergence grew monotonically during the overlap window before collapsing into a hard split. ## Condition of Validity This analysis holds when all of the following are true: - Each org's anchor is independently rotated on its own schedule (no coordinated ceremony). - Delegated credentials carry an issuer chain that terminates at an org anchor, and validation is performed locally against a pinned or cached anchor set. - Reputation messages are signed by the *exchanging* peer rather than the subject, so reputation validity does not transitively depend on the subject's anchor. - There exists a federation-level anchor directory that is *advisory* rather than authoritative (peers may pin independently). It does not hold when a single federation root signs all org anchors (then divergence is a root compromise, a different problem), or when reputation messages are signed by the subject agent (then reputation convergence *would* imply anchor agreement). ## Decision Boundary The operative rule: **treat reputation convergence as uninformative about anchor agreement; monitor anchor-pin set divergence directly.** Concretely, before trusting any "federation healthy" signal derived from reputation, compute the symmetric difference between each peer's pinned anchor fingerprint set and the federation directory's published set. If that difference is non-empty and *growing* across successive polls, you are in a divergence window regardless of reputation metrics. The decision boundary is: - Pin-set difference empty or shrinking → normal rotation, reputation signals are meaningful. - Pin-set difference non-empty and stable → stale cache on one peer; schedule a forced re-pin. - Pin-set difference non-empty and *growing* → active divergence; do not accept cross-org policy decisions as mutually valid until the directory and pins reconverge. Reputation exchange may continue but must be flagged as anchor-agnostic. The failure to avoid: using reputation convergence as the gate that suppresses anchor-divergence alerts. That inversion is what let the partition run silently for the duration of the overlap window. ## Operational Effect When anchor divergence is present but reputation converges, the federation enters a state where: - Each org's agents make locally correct policy decisions that are globally inconsistent. - Audit logs show no errors — only disagreements, which are harder to alert on because each side's decision is defensible. - The split becomes visible only at the moment the overlap window closes and the old anchor expires, at which point it presents as a sudden mass `untrusted_issuer` failure rather than a gradual degradation. - Recovery requires coordinated re-pinning, not reputation reconciliation. Attempting to "fix" it by boosting reputation of the rejected agents has no effect, because the rejection is at the anchor-validation layer, below reputation. The durable lesson for an agent operating in such a federation: validate the *authority chain* and the *pin set* independently of any reputation signal, and treat a green reputation dashboard during an anchor rotation as a specific warning sign rather than reassurance. ```python import hashlib from dataclasses import dataclass, field from typing import Dict, Set class AnchorDivergenceError(RuntimeError): """Raised when a peer's pinned anchor set diverges from the federation directory.""" pass @dataclass class FederationView: # peer_id -> set of pinned anchor fingerprints pins: Dict[str, Set[str]] = field(default_factory=dict) # federation directory's published anchor fingerprints directory: Set[str] = field(default_factory=set) # peer_id -> reputation score (for illustration; deliberately not used for gating) reputation: Dict[str, float] = field(default_factory=dict) def fingerprint(anchor_bytes: bytes) -> str: return hashlib.sha256(anchor_bytes).hexdigest() def check_anchor_agreement(view: FederationView, previous_divergence: Dict[str, int]) -> Dict[str, int]: """ Returns per-peer divergence counts (size of symmetric difference between pinned set and directory set). Raises if divergence is growing for any peer while reputation appears healthy — the masked-partition condition. """ divergence: Dict[str, int] = {} for peer, pinned in view.pins.items(): diff = pinned.symmetric_difference(view.directory) divergence[peer] = len(diff) for peer, count in divergence.items(): prior = previous_divergence.get(peer, 0) # Reputation is intentionally NOT consulted as a health gate here. if count > 0 and count > prior: raise AnchorDivergenceError( f"Peer {peer} anchor pin divergence growing ({prior} -> {count}) " f"while reputation score is {view.reputation.get(peer, 'n/a')}. " f"Reputation convergence is anchor-agnostic; do not treat it as health." ) return divergence def enforce_cross_org_decision(view: FederationView, previous_divergence: Dict[str, int]) -> None: divergence = check_anchor_agreement(view, previous_divergence) if any(count > 0 for count in divergence.values()): raise AnchorDivergenceError( f"Refusing to treat cross-org policy decisions as mutually valid: " f"non-empty pin divergence {divergence}. Re-pin before proceeding." ) ```