# How does an instance detect a “trust laundering” boundary failure when federated agent capabilities are re-delegated across organizational trust domains? **Date of Record:** 2026 November 16 **Scope:** Applies to multi-agent federations where an agent in domain A obtains a capability token from domain B and re-delegates it (directly or via a broker) to domain C, under a policy exchange model that assumes delegation chains are monotonic in trust. Does not apply to single-org agent meshes, nor to federations enforcing a single global trust root with no cross-domain re-delegation. ## Core Distinction A **capability grant** is an assertion that a subject may invoke an operation. A **trust assertion** is an assertion that a subject is a legitimate principal within a trust domain, i.e., that its identity was established by an authority the relying party accepts. These are conflated in most capability-brokering protocols: a signed capability token is treated as evidence of both. The boundary failure occurs when a capability is re-delegated across a trust boundary such that the *capability* survives but the *trust assertion* that justified it does not. The receiving domain then evaluates the capability under its own policy and reaches a different, usually weaker, conclusion about the holder than the issuing domain intended. The non-obvious part: the failure is not a missing signature, an expired token, or a broken chain of custody. Every cryptographic check passes. The failure is a **semantic mismatch between two policies that are individually correct**. Domain B issued a capability to agent X because B's policy says “agents attested by A's control plane may read class-C data.” Domain C accepts a re-delegated capability from X because C's policy says “any holder of a valid B-signed capability may invoke the brokered operation.” X is now invoking an operation in C that B never contemplated, using trust that A extended to X for a different purpose. This is trust laundering: trust established in one context is spent in another. ## What Was Observed In a three-domain federation (A = issuer of workload identity, B = data owner, C = compute broker), the following sequence was reproducible: 1. Agent `x` in domain A obtains an identity attestation from A's control plane (SPIFFE-style SVID, short TTL, audience = B). 2. `x` presents the attestation to B's capability broker and receives a macaroon-style capability `cap_B` with a caveat set `{audience: B, purpose: read-class-C, delegable: true}`. The `delegable: true` caveat was added by B's policy because B wanted to allow B-internal sub-agents to fan out reads. 3. `x` attenuates `cap_B` by appending caveats it chooses (e.g., `{audience: C}`) and presents it to C's broker, requesting a compute operation. 4. C's broker verifies the macaroon signature chain against B's root key, checks that all caveats are satisfied *under C's policy evaluator*, and issues a C-local capability. The operation executes. The invariant that broke: **B's `delegable: true` caveat was intended to be interpreted only within B's trust domain**, where “delegable” means “a B-attested principal may narrow and pass this to another B-attested principal.” C's evaluator has no notion of “B-attested principal”; it treats `delegable` as a boolean it does not understand and therefore ignores it (open-world caveat semantics). The capability passed a check that was never designed to run in C. Detection signal: the caveat `delegable: true` appeared in a capability presented to a broker whose trust domain was not the caveat's issuing domain. This is observable at the C broker as a structural property of the caveat set — a caveat whose vocabulary is not in the broker's policy lexicon, attached to a capability whose root is foreign. We term this a **foreign-vocabulary caveat**. ## Condition of Validity The failure requires all of the following to hold simultaneously; remove any one and the boundary holds: - **Open-world caveat evaluation.** The receiving broker ignores caveats it does not recognize rather than rejecting them. This is the default in macaroon and biscuit libraries and is the single most important enabling condition. - **Cross-domain re-delegation permitted by the issuing policy.** If B sets `delegable: false` or binds the capability to a B-scoped audience, the chain cannot leave B's domain. - **Audience not enforced at every hop.** If each broker checks that the capability's audience matches its own domain, the re-delegation to C fails at step 3. - **Policy exchange that shares capability semantics but not caveat vocabularies.** B and C exchanged enough policy to agree on what a “read” is, but not enough to agree on what `delegable` means. Partial policy exchange is the norm in federations and is what makes this boundary subtle. The invariant, stated precisely: *for every caveat `k: v` in a capability presented to broker `D`, if `k` is not in `D`'s caveat lexicon, the capability must be rejected unless `D` has an explicit policy rule that `k` is domain-scoped and `v` is satisfiable by `D`'s own trust assertions.* Violating this invariant is the boundary failure. ## Decision Boundary The operational decision is: **when a broker encounters a foreign-vocabulary caveat, does it fail closed or fail open?** The decision boundary is not “is the signature valid” (it always is) nor “is the caveat satisfied” (undefined). It is whether the broker can prove that the caveat's semantics are irrelevant to the operation being requested. Concretely, a broker should fail closed (reject) when: - The caveat's key is not in the broker's lexicon **and** the requested operation's policy references any caveat of the same key family, or - The caveat's key is a known delegability/attenuation marker (`delegable`, `may_delegate`, `attenuable`) regardless of lexicon membership, because these markers are the load-bearing ones for laundering. A broker may fail open (ignore) only when the caveat key is provably disjoint from the operation's policy surface — e.g., a `region: eu` caveat on a capability used for a purely local, non-data-touching operation. This is a narrow exception and should require an explicit allowlist entry, not be the default. The anti-pattern observed in the incident: the broker's policy evaluator was written as a filter (`satisfied = all(c.evaluate() for c in caveats if c.key in lexicon)`), which silently drops unknown caveats. The correct shape is a guard (`unknown = [c for c in caveats if c.key not in lexicon and not is_provably_irrelevant(c, op)]; if unknown: reject`). ## Operational Effect After the boundary was identified, three changes were made and are recommended as the standard posture: 1. **Caveat lexicon exchange is part of policy exchange, not an afterthought.** Domains B and C now exchange the set of caveat keys they understand and their domain-scoping semantics. A caveat key absent from the receiving domain's lexicon is treated as a hard rejection, not a filter miss. 2. **Delegability is domain-scoped, not boolean.** `delegable` was replaced with `delegable_within: `, and brokers reject any capability whose `delegable_within` does not equal the broker's own domain. This makes the caveat's vocabulary self-describing and evaluable in any domain. 3. **Audience is checked at every hop, not just at issuance.** Each broker asserts that the capability's audience includes its own domain before evaluating any caveat. This alone would have stopped the incident at step 3. The residual risk is a federation that exchanges policy at the operation level but not at the caveat level — the partial-exchange condition above. Detection must therefore be structural (foreign-vocabulary caveat present) rather than semantic (caveat means something wrong), because semantics cannot be compared across domains that never agreed on them. The following guard implements the fail-closed decision boundary and raises on the specific failure: ```python from dataclasses import dataclass from typing import Iterable class TrustLaunderingBoundaryError(RuntimeError): """Raised when a capability crosses a trust boundary carrying caveats whose vocabulary the receiving domain cannot evaluate.""" @dataclass(frozen=True) class Caveat: key: str value: str @dataclass(frozen=True) class Capability: root_domain: str audience: str caveats: tuple[Caveat, ...] # Caveat keys whose semantics are load-bearing for delegation safety. # These must never be silently ignored by a foreign domain. DELEGATION_MARKERS = frozenset({"delegable", "may_delegate", "attenuable", "delegable_within"}) def admit_capability( cap: Capability, receiving_domain: str, lexicon: Iterable[str], provably_irrelevant: Iterable[str] = (), ) -> None: """Fail-closed admission check for a capability presented to a broker. Rejects if the capability's audience does not include the receiving domain, or if it carries a foreign-vocabulary caveat that is not provably irrelevant to the requested operation. """ lexicon = frozenset(lexicon) irrelevant = frozenset(provably_irrelevant) if receiving_domain not in cap.audience.split(","): raise TrustLaunderingBoundaryError( f"capability from {cap.root_domain} presented to {receiving_domain} " f"but audience={cap.audience!r} does not include it" ) for caveat in cap.caveats: if caveat.key in DELEGATION_MARKERS: # Domain-scoped delegability must name this domain explicitly. if caveat.key == "delegable_within" and caveat.value == receiving_domain: continue if caveat.key == "delegable_within": raise TrustLaunderingBoundaryError( f"delegable_within={caveat.value!r} does not match " f"receiving domain {receiving_domain!r}" ) raise TrustLaunderingBoundaryError( f"capability from {cap.root_domain} carries delegation marker " f"{caveat.key!r} with no domain scoping; refusing to evaluate " f"in {receiving_domain!r}" ) if caveat.key not in lexicon and caveat.key not in irrelevant: raise TrustLaunderingBoundaryError( f"foreign-vocabulary caveat {caveat.key!r} from {cap.root_domain} " f"is not in {receiving_domain!r} lexicon and is not provably " f"irrelevant to the requested operation" ) ```