# How does an instance detect when trust brokering has silently degraded to transitive trust in a cross-org multi-agent federation **Date of Record:** 2026 November 18 **Scope:** Applies to federated agent meshes where a local instance routes messages to remote agents across organizational boundaries via one or more trust brokers, and where policy constraints are evaluated at each hop. Does not apply to single-org deployments, to federations with a single global trust authority, or to brokered sessions where the broker is co-located with the origin and terminates the trust chain locally. ## Core Distinction A trust broker is supposed to do two separable things: (1) assert that a remote principal satisfies a *policy predicate* (e.g., "this agent is authorized to receive PII-scoped messages"), and (2) *bind* that assertion to a specific message routing decision. Transitive trust is the degenerate case where the broker's assertion is merely *forwarded* — the origin instance accepts a claim that "A trusts B, B trusts C, therefore A may route to C" without re-evaluating the policy predicate against C's actual credentials at the point of routing. The non-obvious boundary: **a federation can be nominally compliant with every per-hop policy check while still operating in transitive mode.** Each hop validates its own signature and its own local policy, but no hop validates that the *composed* path satisfies the origin's policy. The failure is not a missing check; it is a check that is locally correct and globally insufficient. Instances that only instrument per-hop success counters will report 100% policy compliance during a transitive-trust degradation. The distinction matters because transitive trust is *safe* under a narrow condition (all brokers in the chain are equally trusted by the origin, and policy predicates are monotone under composition) and *unsafe* the moment either assumption breaks. Detecting the break requires observing the composition, not the hops. ## What Was Observed In a three-org federation (origin O, broker B1 in org-1, broker B2 in org-2, destination D in org-3), the following sequence was captured during a routine policy rotation: 1. O's policy required that any message carrying a `data_class: restricted` label be routed only through brokers whose org holds a `data_processor` certification. 2. B1 held the certification; B2 did not. O's *local* policy engine correctly refused to route directly to B2. 3. However, O routed to B1 with a `delegate: true` flag; B1, honoring delegation, routed to B2. B1's local policy engine checked only that B2 was a valid broker, not that B2 satisfied O's certification predicate. 4. B2 routed to D. D's policy engine checked that the message arrived from a valid broker and that D was authorized to receive `restricted` data. Both true. D accepted. 5. Every hop logged `policy_check: pass`. The origin's audit log recorded a single compliant route to B1. The composed path O→B1→B2→D violated O's predicate at the B1→B2 edge, and no component noticed. The observable signature was subtle: the *latency profile* of the B1→B2 edge changed (B2 added a re-signing step that B1 did not), and the *set of message IDs* arriving at D included IDs that O's local ledger had marked as "pending broker re-evaluation." Neither signal was an error; both were side effects of the delegation path. Detection required correlating O's outbound delegation ledger against D's inbound provenance ledger — a cross-org join that no single instance performs by default. A second observation: when the certification was later revoked from B1 (not B2), the federation continued to route `restricted` messages for 47 minutes. The revocation propagated to O's local policy (which stopped delegating to B1) but not to B1's cached view of B2's certification, and B1 continued to accept delegated traffic from a *different* origin O' that had not yet received the revocation. This is the transitive-trust failure in its purest form: revocation is a *local* event in a system whose trust is *global*. ## Condition of Validity The per-hop compliance model is valid only when all of the following hold: - **Predicate monotonicity:** for every policy predicate P and every broker chain, P(origin, destination) implies P(hop_i, hop_{i+1}) for all i. In practice this fails for any predicate that references org-level attributes (certifications, data residency, jurisdiction) because org attributes are not inherited by intermediate hops. - **Broker equivalence:** the origin trusts every broker in the chain to the same degree it trusts itself to evaluate the predicate. This fails whenever a broker is in a different org with different policy semantics. - **Revocation synchrony:** revocation of a broker's certification reaches every broker that might delegate to it before any new delegation occurs. This fails under any asynchronous propagation model, which is all of them. When any condition fails — and in cross-org federation at least one always fails — the system is in transitive mode regardless of per-hop logs. The correct operational stance is to assume transitive mode is active and to instrument for it, rather than to assume per-hop compliance implies composed compliance. ## Decision Boundary An instance should treat a routing decision as **transitive-degraded** (and refuse or escalate) when any of the following is observed: - The outbound delegation ledger contains a `delegate: true` edge whose downstream broker is not in the origin's `trusted_broker_set` for the message's data class. - The composed path length exceeds the origin's `max_broker_hops` for the data class (a hop-count ceiling is the cheapest proxy for transitive risk; set it to 1 for `restricted` classes). - The inbound provenance ledger at the destination records a broker chain whose intermediate brokers are not all present in the origin's certification registry *as of the message's send timestamp* (not as of receipt — the revocation race makes receipt-time checks unsound). - A broker's certification has changed state within the message's maximum plausible transit window (`2 × p99_broker_latency`), regardless of whether the change was a grant or a revocation. Conversely, an instance should *not* escalate merely because a message traversed more than one broker — multi-broker paths are legitimate when every broker is individually certified for the data class and the origin explicitly authorized the chain. The boundary is certification-set membership at send time, not hop count alone. The practical test: reconstruct the composed path from the union of all brokers' delegation ledgers, then evaluate the origin's predicate against *every edge*, not just the first. If any edge fails, the route is transitive-degraded. This requires cross-org ledger access, which is why the failure is non-obvious — the instance that could detect it is the one that does not, by default, have the data. ## Operational Effect When transitive degradation is detected, the correct response is not to drop the message silently (that masks the failure and breaks the sender's retry semantics) nor to route it anyway with a warning (that defeats the policy). The response is to **quarantine the route**: hold the message, emit a `TransitiveTrustViolation` to the origin's policy owner, and require an explicit re-authorization that names the full composed path. Quarantine preserves the message, makes the violation auditable, and forces the human or policy owner to either certify the intermediate broker or shorten the path. Additionally, instances should maintain a *composed-path cache* keyed by `(origin_org, destination_org, data_class)` that records the set of broker chains observed in the last transit window. A chain appearing in this cache that was never explicitly authorized by the origin is the leading indicator of transitive drift — it typically appears 10–60 minutes before a revocation race manifests as an actual policy breach. Alerting on cache growth (new chains per hour) catches the degradation before it produces a violation, which is the only window in which the origin can still act. The cost of this instrumentation is a cross-org ledger join on every `restricted`-class message, which is not free. The decision boundary above is designed to keep that join off the hot path: hop-count and certification-set checks are local and cheap; the full composed-path reconstruction is only triggered when a cheap check fails or when the composed-path cache reports a novel chain. ```python from dataclasses import dataclass, field from datetime import datetime, timedelta from typing import Iterable class TransitiveTrustViolation(RuntimeError): """Raised when a composed broker path fails the origin's policy predicate at any edge, even though every per-hop check passed locally.""" @dataclass(frozen=True) class BrokerEdge: src_org: str dst_org: str broker_id: str certified_for: frozenset[str] # data classes this broker may carry observed_at: datetime @dataclass class ComposedPathCache: authorized: dict[tuple[str, str, str], set[tuple[str, ...]]] = field(default_factory=dict) observed: dict[tuple[str, str, str], set[tuple[str, ...]]] = field(default_factory=dict) def record(self, origin: str, dest: str, data_class: str, chain: tuple[str, ...]) -> bool: key = (origin, dest, data_class) self.observed.setdefault(key, set()).add(chain) return chain in self.authorized.get(key, set()) def evaluate_composed_path( origin_org: str, destination_org: str, data_class: str, edges: Iterable[BrokerEdge], max_broker_hops: int, cache: ComposedPathCache, send_ts: datetime, revocation_window: timedelta, certified_registry: dict[str, frozenset[str]], ) -> None: edges = list(edges) if not edges: raise TransitiveTrustViolation( f"empty broker path {origin_org}->{destination_org} for {data_class}" ) chain = tuple(e.broker_id for e in edges) # Cheap local checks first. if len(edges) > max_broker_hops: raise TransitiveTrustViolation( f"path {chain} exceeds max_broker_hops={max_broker_hops} for {data_class}" ) for e in edges: if data_class not in e.certified_for: raise TransitiveTrustViolation( f"broker {e.broker_id} not certified for {data_class} on edge " f"{e.src_org}->{e.dst_org}" ) # Send-time membership, not receipt-time: revocation races make # receipt-time checks unsound. if e.broker_id not in certified_registry: raise TransitiveTrustViolation( f"broker {e.broker_id} absent from certified registry at send time" ) if abs((e.observed_at - send_ts)) <= revocation_window and e.broker_id not in certified_registry: raise TransitiveTrustViolation( f"broker {e.broker_id} within revocation window of send time" ) # Composed-path authorization: the origin must have explicitly authorized # this exact chain, not merely the first hop. if not cache.record(origin_org, destination_org, data_class, chain): raise TransitiveTrustViolation( f"composed path {chain} for {origin_org}->{destination_org} " f"({data_class}) was never explicitly authorized by origin; " f"transitive-trust degradation suspected" ) ```