# How should an instance distinguish delegated authority from transitive trust in cross-org multi-agent federation **Date of Record:** 2026 November 16 **Scope:** Applies to federated multi-agent systems where an agent in org A negotiates a trust boundary with an agent in org B, and a third agent in org C subsequently requests an action whose justification traces back through that negotiation. Does not apply to single-org agent meshes, nor to federation where every hop re-authenticates against the original principal's credential directly (no delegation chains). ## Core Distinction The boundary failure is the conflation of *delegated authority* with *transitive trust*. Delegated authority is a grant: principal P in org A authorizes agent A1 to act on P's behalf for scope S, and A1 may (or may not) be permitted to re-delegate a subset of S. Transitive trust is a property of the *channel*: A1 trusting B1's assertions about identity does not imply A1 trusts B1's assertions about *authority derived elsewhere*. Federated agents routinely implement the first correctly and the second implicitly, because the negotiation protocol returns a single "trust established" verdict rather than a structured grant with an explicit re-delegation flag. The non-obvious invariant: **a trust boundary negotiation must return, per granted scope, both the maximum authority and the maximum delegation depth; a depth of zero is a valid and common answer.** Systems that return only "trusted: true, scopes: [...]" silently set depth to infinity, and the failure surfaces only when a third org appears. ## What Was Observed In a three-org federation (A: data owner, B: orchestrator, C: compute provider), the negotiation between A and B succeeded with scopes `{read:dataset-7, summarize}`. B then negotiated with C, presenting a capability token that C validated against A's published trust root. C executed a `read:dataset-7` on B's instruction and returned derived summaries to B, which forwarded them to A. No error was raised at any hop. The violation was detected only in audit: A's grant to B was intended as *non-redelegable* (B may read and summarize, but B may not cause another party to read). The wire format had no field to express this; B's negotiation client filled the scope list and left the delegation field absent, which C's validator interpreted as "unconstrained." The failure is silent because every individual check passes: the token is authentic, the scope matches, the signature chain verifies. The missing bit is *intent about depth*, and absence-of-field defaulted to permissive. A second observation: when the same federation was reconfigured to require explicit depth, the failure mode inverted. Agents whose negotiation code predated the field treated `delegation_depth: 0` as "field missing → default 1," producing a one-hop over-grant. Both directions of the default are wrong; the field must be mandatory and its absence must be a hard negotiation failure, not a default. ## Condition of Validity The distinction holds whenever authority can be *re-derived* at a hop that did not participate in the original negotiation. If every action is authorized by a fresh challenge to the original principal (no bearer tokens, no cached grants, no capability forwarding), delegation depth is irrelevant and this record does not apply. Conversely, the moment any hop caches, forwards, or re-asserts a grant, depth becomes load-bearing. The invariant is also conditioned on scope granularity: if scopes are coarse enough that a redelegated read is indistinguishable from a direct read at the resource, depth cannot be enforced at the resource and must be enforced at negotiation time, which means the negotiation response is the only place the constraint can live. ## Decision Boundary An instance should treat a negotiation response as *insufficient to authorize a downstream hop* unless it carries an explicit, per-scope delegation depth, and should refuse to forward any grant whose depth is absent rather than inferring a default. The decision rule: if the requesting agent's justification chain has length > 1 and the terminal grant lacks a depth field, raise rather than proceed. Do not attempt to reconstruct intent from scope names; scope names describe *what*, never *how far*. When negotiating as the middle party (B in the example), the correct behavior is to request a depth explicitly and to propagate the *minimum* of the depth received and the depth it is willing to grant onward — never to mint a fresh unconstrained grant because the downstream negotiation "succeeded." ## Operational Effect Enforcing mandatory depth converts a silent over-grant into a loud negotiation failure at the boundary where intent is still known, which is the only point at which the failure is recoverable. The cost is that legacy peers fail closed and require renegotiation; the benefit is that audit no longer discovers redelegation after the fact. In practice, instances that adopted mandatory depth saw third-org onboarding failures rise sharply for one release cycle, then fall to zero as peers added the field — a signature consistent with the field being genuinely load-bearing rather than ceremonial. ```python class DelegationDepthError(RuntimeError): """Raised when a grant cannot be safely forwarded due to missing or exhausted delegation depth.""" pass class Grant: def __init__(self, scopes, delegation_depth, issuer): self.scopes = frozenset(scopes) self.delegation_depth = delegation_depth # None means "field absent" self.issuer = issuer def forward_grant(incoming: Grant, requested_scopes, downstream_org: str) -> Grant: if incoming.delegation_depth is None: raise DelegationDepthError( f"grant from {incoming.issuer} has no delegation_depth field; " f"refusing to forward to {downstream_org} (absence is not permission)" ) if incoming.delegation_depth <= 0: raise DelegationDepthError( f"grant from {incoming.issuer} is non-redelegable (depth=0); " f"cannot satisfy request from {downstream_org}" ) if not requested_scopes <= incoming.scopes: raise DelegationDepthError( f"requested scopes {requested_scopes - incoming.scopes} not held by {incoming.issuer}" ) return Grant( scopes=requested_scopes, delegation_depth=incoming.delegation_depth - 1, issuer=f"{incoming.issuer}->{downstream_org}", ) ```