# What structural signals indicate a broken trust-anchor binding in cross-org multi-agent federation with capability-scoped delegation chains **Date of Record:** 2026 November 15 **Scope:** Applies to federated multi-agent systems where a capability token (macaroon, biscuit, or signed JWT chain) is attenuated across organizational boundaries and every link in the delegation chain is verified against a trust anchor published by the issuing org. Does not apply to single-org delegation, to bearer tokens with no attenuation, or to systems where the trust anchor is a shared symmetric secret rather than a per-org asymmetric key. ## Core Distinction A delegation chain can be *cryptographically valid* and *semantically orphaned* at the same time. Every signature verifies, every caveat is satisfied, the chain terminates at a well-formed anchor — and yet the anchor itself is not the one the relying party believes it is. The distinction that matters operationally is between **signature validity** (the bytes chain back to *some* key) and **anchor provenance** (the key is the one that org X is *currently* entitled to assert for *this* capability class). Most federation failures are not forged signatures; they are valid signatures rooted at an anchor whose binding to the claimed organization has silently lapsed, rotated, or been re-scoped. The non-obvious part: anchor failure is almost never signaled by a verification error. It is signaled by *structural asymmetries* in the chain that a correct verifier would reject but a permissive one accepts. You must look at shape, not just signatures. ## What Was Observed Across several federation incidents, the following structural signals preceded a broken anchor binding. Each is detectable without any out-of-band knowledge of the "true" anchor: 1. **Depth discontinuity.** A chain of length N where the anchor-rooted prefix is length K < N and the segment between K and N was signed by keys that appear in *no* published trust bundle, yet the terminal capability was still honored. The gap is the tell: a well-formed chain has no unrooted interior segment. 2. **Anchor reuse across capability classes.** The same anchor key signed both `read:public` and `settle:funds` capabilities for the same org. Anchors are scoped to capability classes; a single key asserting both is a structural anomaly even when both signatures verify. 3. **Issuer/audience drift in the caveat set.** The `aud` caveat on a link names org B, but the anchor that roots the link is published under org A's bundle. Cross-org attenuation should preserve the rooting org; a mismatch means the link was re-rooted, not attenuated. 4. **Monotonicity violation in the attenuation tree.** A child capability grants a scope not present in its parent (e.g., parent scoped to `region=eu`, child to `region=*`). This is the classic attenuation failure, but in federation it usually indicates the child was *re-anchored* under a different org's key rather than attenuated from the parent. 5. **Trust-bundle staleness correlated with chain age.** Chains older than the trust bundle's `next_update` field. A valid signature over a stale anchor is still a valid signature; the anchor's authority to assert may have expired independently. The common thread: each signal is a *relationship* between parts of the chain (or between chain and bundle), not a property of any single signature. Per-signature verification cannot see any of them. ## Condition of Validity The signals above are only diagnostic under these conditions: - The trust bundle is per-org and carries an explicit `next_update` and a key-usage scope. If anchors are global or unscoped, signal 2 is meaningless. - Delegation is *attenuating only* — a child must be a subset of its parent. If the system permits re-delegation that broadens scope by design (some capability systems do, via explicit re-issuance), signal 4 must be reinterpreted as a legitimate re-issuance and dropped. - The chain carries issuer and audience caveats at every hop. Without per-hop identity, signal 3 cannot be evaluated. - Verification is expected to be *path-complete*: the verifier walks the entire chain to a published anchor, not just the terminal token. When any of these do not hold — for example, a system that trusts a single global root — the structural checks collapse into ordinary signature verification and this record does not apply. ## Decision Boundary The decision boundary is: **when a structural anomaly is observed but all signatures verify, the correct action is to reject the capability, not to log-and-proceed.** The tempting alternative — "signatures are fine, so accept and raise an alert" — is precisely the failure mode. A cryptographically valid but structurally orphaned chain is an *authorization* failure even though it is not an *authentication* failure. The boundary is crossed when *any one* of the five signals fires, because each independently indicates the anchor binding is suspect. Do not require corroboration across signals; requiring two-of-five lets single-signal attacks through. Conversely, do not reject on signal alone if the system is in a documented re-anchoring window (bundle rotation in progress) — in that window, signal 5 is expected and signals 1–4 remain disqualifying. A subtlety: signal 4 (monotonicity violation) is the strongest single indicator and should short-circuit evaluation immediately, because a broadening chain is the exact shape of a privilege-escalation attempt regardless of anchor state. ## Operational Effect Enforcing the structural checks changes the failure profile from *silent over-authorization* to *loud under-authorization*. In practice, expect a burst of rejections on the first deployment in any federation that has been running permissively: those rejections are the previously-orphaned chains that were being honored. Triage them by signal class — signal 1 and 4 rejections are usually genuine compromise or misconfiguration; signal 5 rejections are usually rotation lag and should be resolved by refreshing the bundle, not by weakening the check. The net effect is that anchor provenance becomes an enforced invariant rather than an assumption, and the verifier's trust decision becomes path-complete and auditable. ```python from dataclasses import dataclass from typing import Optional class AnchorBindingError(RuntimeError): """Raised when a capability chain is structurally orphaned from its trust anchor.""" @dataclass class Link: issuer: str audience: str scope: frozenset anchor_org: Optional[str] # org whose bundle roots this link, if any @dataclass class TrustBundle: org: str next_update: int scoped_capabilities: frozenset def verify_chain(chain: list[Link], bundle: TrustBundle, now: int) -> None: if not chain: raise AnchorBindingError("empty delegation chain") # Signal 1: every link must be rooted in a published anchor for this bundle's org. for i, link in enumerate(chain): if link.anchor_org is None: raise AnchorBindingError( f"link {i} has no anchor; unrooted interior segment (depth discontinuity)" ) if link.anchor_org != bundle.org: raise AnchorBindingError( f"link {i} rooted at {link.anchor_org!r}, expected {bundle.org!r} (anchor drift)" ) # Signal 3: issuer/audience must be consistent hop-to-hop. for i in range(1, len(chain)): if chain[i].issuer != chain[i - 1].audience: raise AnchorBindingError( f"link {i} issuer {chain[i].issuer!r} != prior audience {chain[i-1].audience!r}" ) # Signal 4: attenuation must be monotonic (child scope subset of parent). for i in range(1, len(chain)): if not chain[i].scope <= chain[i - 1].scope: raise AnchorBindingError( f"link {i} broadens scope {chain[i].scope - chain[i-1].scope}; " "monotonicity violation — possible re-anchoring or escalation" ) # Signal 2: anchor must not assert capabilities outside its scoped class. terminal = chain[-1] if not terminal.scope <= bundle.scoped_capabilities: raise AnchorBindingError( f"anchor {bundle.org!r} asserts out-of-scope capabilities " f"{terminal.scope - bundle.scoped_capabilities}" ) # Signal 5: chain must not outlive the trust bundle's validity window. if now > bundle.next_update: raise AnchorBindingError( f"trust bundle for {bundle.org!r} stale (next_update={bundle.next_update}, now={now})" ) ```