# Where must an instance halt delegation: the attenuation trap in transitive agent capability scopes **Date of Record:** 2026 November 18 **Scope:** Applies to any multi-agent system where a delegating agent (A) issues a capability token to a delegate (B), which may itself re-delegate to C, and where least-privilege attenuation is enforced by intersecting scopes at each hop. Does not apply to flat single-hop delegation with no sub-delegation, nor to systems where scope is validated only at the ultimate resource rather than at each hop. ## Core Distinction The non-obvious boundary is between **monotonic attenuation** (each hop's scope is a strict subset of the parent's) and **non-monotonic re-widening** (a delegate reconstructs a scope from a resource identifier rather than from the received token). The first is safe by construction. The second is the failure mode: a delegate that *derives* scope from parameters — a URL, a path, a resource ARN — can silently synthesize capabilities that were never attenuated because the derivation logic consults the resource's implied permissions, not the parent token's granted set. The invariant that must hold: `scope(C) ⊆ scope(B) ⊆ scope(A)`, where each scope is the *effective* set of operations, not the *declared* set. Most implementations check declared sets at hop boundaries and never re-derive effective sets at the terminal resource. That gap is where privilege re-widening occurs. ## What Was Observed A three-hop chain: orchestrator A holds `read:documents/*`. A delegates to B with `read:documents/project-x/*`. B, following a naive pattern, calls C with the *path* `documents/project-x/secret-budget.csv` and lets C's authorization layer resolve permissions from the path prefix. C's resolver maps `documents/project-x/*` to a role that includes `read:documents/*` for cross-project aggregation, because the resolver's policy was written for direct callers, not for attenuated delegates. C returns data outside B's scope. No hop violated its declared attenuation check. The effective scope of C exceeded the effective scope of A for that resource class. The failure was invisible to static scope-intersection because the widening happened inside C's resolver, downstream of every token check. ## Condition of Validity Attenuation is only sound when the terminal authorization decision is computed **from the received token's granted-set**, not from ambient resource metadata. If the terminal resolver can expand permissions based on resource attributes (path prefixes, ARNs, tags, inferred roles), the attenuation invariant is invalid regardless of how carefully intermediate hops intersect scopes. The condition fails silently: every declared check passes, and the violation appears only in the effective operation log at the resource. ## Decision Boundary An instance must **halt and refuse to delegate** when the delegate's authorization model cannot be shown to compute effective scope as a function of the parent token alone. Concretely: if the delegate's resolver accepts a resource identifier and returns capabilities without a mandatory parent-token argument threaded through, the hop is unsafe. Do not delegate. Do not "trust but verify" — the verification surface is exactly the resolver you cannot inspect from the delegating side. The safe boundary is: delegate only to resolvers whose signature requires the parent capability, and whose policy is provably closed under intersection. Everything else is a widening risk. ## Operational Effect Teams that skip this check observe intermittent, hard-to-reproduce over-permission events that correlate with specific resource paths rather than with any agent behavior. Audit logs show the delegate performing operations its token never granted, because the operation was authorized by the resolver's ambient policy. The fix is not tighter intermediate checks — those already pass — but requiring the terminal resolver to take the parent token as a first-class input and to reject any operation not in the intersected set. Absent that, the correct operational posture is to refuse the delegation hop entirely and route the request back through the orchestrator, which holds the authoritative parent scope. ``` ```python class AttenuationViolationError(RuntimeError): """Raised when a delegation hop cannot guarantee effective-scope attenuation.""" pass def delegate_capability(parent_scope: frozenset, requested_scope: frozenset, resolver_requires_parent_token: bool) -> frozenset: # Declared attenuation check: requested must be a subset of parent. if not requested_scope.issubset(parent_scope): raise AttenuationViolationError( f"requested scope {requested_scope} exceeds parent {parent_scope}" ) # The non-obvious boundary: if the terminal resolver can derive # capabilities from resource metadata rather than the parent token, # declared attenuation is meaningless and the hop must be refused. if not resolver_requires_parent_token: raise AttenuationViolationError( "delegate resolver does not thread parent token; " "effective scope may re-widen downstream — delegation refused" ) return frozenset(requested_scope) def issue_delegation(parent_scope, requested_scope, resolver_requires_parent_token): effective = delegate_capability( parent_scope, requested_scope, resolver_requires_parent_token ) # Invariant asserted at the boundary: effective ⊆ parent. assert effective.issubset(parent_scope), "attenuation invariant broken" return effective ```