Trust Boundaries for Multi-Agent Systems

· 6 min read

A single well-guarded AI agent is a solved-enough problem: scope its tools, deny by default, log everything, and give an operator a kill switch. The Substrate Pattern describes exactly that architecture. The problem that pattern does not solve on its own is what happens when Agent A delegates a task to Agent B, and B calls C — because the safety properties that hold for one agent do not compose automatically once agents start calling each other.

Why single-agent guardrails don’t compose

A tool-scoped, identity-scoped agent is safe because every action it takes is checked against its own scope before it runs. The moment that agent can invoke another agent, the checked action is “invoke Agent B with this task” — and everything B does next happens outside the calling agent’s own scope enforcement. If B has broader tool access than A, or a different identity context, the delegation has quietly widened the blast radius of the original request. This is not a hypothetical: it is the default behavior of most agent-orchestration frameworks, where sub-agents are spawned with their own tool configuration rather than a strict subset of the caller’s.

Three places trust boundaries actually break

Identity dilution. When Agent A acts on behalf of User X and delegates to Agent B, does B’s action get attributed to X, to A, or to B itself? Most frameworks default to whichever identity is easiest to plumb through, which is usually a service identity — at which point the audit trail no longer says who the action was really for. The Substrate Pattern’s identity substrate treats this as the important primitive precisely because it does not survive delegation by default.

Scope escalation. A parent agent scoped to read-only calendar access should not be able to reach a child agent that was independently configured with write access to email, even if the orchestration framework happily wires them together because both speak the same tool protocol. Scope has to be intersected across the delegation chain, not just checked at each hop in isolation — a child’s effective scope is the caller’s scope narrowed further, never the child’s own configuration taken at face value.

Circuit breakers that don’t propagate. Defence in Depth puts a circuit breaker and a kill switch on a single agent’s runtime. In a multi-agent system, tripping the breaker on the orchestrating agent does nothing if the sub-agents it already spawned keep running independently with their own tool access. A kill switch that only stops the top of the call tree is not a kill switch for the system.

A comparison: single-agent vs multi-agent safety properties

PropertySingle agentMulti-agent, naiveMulti-agent, trust-boundary-aware
Tool scopeFixed set, checked per callEach agent has its own scopeChild scope = intersection of caller scope and child’s own configuration
IdentityOne identity per sessionDelegated calls often collapse to a service identityIdentity and delegation chain both carried through every hop
Kill switchStops the one runtimeStops only the top-level agentPropagates to every agent spawned in the call tree
Audit trailOne agent, one log streamFragmented across agents, hard to reconstructSingle request ID threaded through every delegated call

A worked example

Consider a customer-support orchestrator that can delegate refund requests to a specialized “billing agent.” The orchestrator is correctly scoped to read order history and draft (not send) refund requests. If the billing agent it delegates to was independently configured with send-refund permission — because that’s what it needs for a different, legitimate caller — then a compromised or simply over-eager orchestrator can reach refund authority it was never granted, by routing through the billing agent. The fix is not to trust the billing agent’s own scope configuration when it’s invoked in this context; it’s to pass the orchestrator’s narrower scope down and have the billing agent enforce the intersection, refusing to send a refund on behalf of a caller who couldn’t have sent one itself.

A checklist for multi-agent trust boundaries

  • Thread a single request/session identity through every delegated call, not just the first hop.
  • Compute each child agent’s effective scope as an intersection with the caller’s scope, never the child’s standalone configuration alone.
  • Make the kill switch system-wide: stopping the orchestrator must stop or orphan-terminate everything it already spawned.
  • Log delegation edges explicitly (who delegated to whom, with what scope) so an audit can reconstruct the call tree, not just each agent’s local log.
  • Treat “Agent B is also independently used elsewhere with broader permissions” as a design smell, not a convenience — it’s exactly the setup that produces scope escalation.

Limitations

None of this is free. Threading identity and computing scope intersections on every delegated call adds latency and complexity to what was otherwise a simple function call between agents, and it requires the orchestration framework to support it rather than treating sub-agents as black boxes. For low-stakes delegation — a research agent calling a search-summarization agent with no write access anywhere in the chain — this overhead may not be worth it. It matters most exactly where the stakes are highest: financial actions, anything with write access to production systems, or anything acting on behalf of an external user rather than an internal operator.

FAQ

Is this the same problem as prompt injection? No, though the two compound. Prompt injection is about an attacker manipulating what an agent decides to do; trust boundaries are about what an agent (or a sub-agent it delegates to) is structurally able to do even when it decides correctly. A system can be fully injection-resistant and still have a scope-escalation bug in its delegation logic.

Does this apply to tool use, or only agent-to-agent delegation? Primarily agent-to-agent delegation, because that’s where a second, independently configured scope enters the picture. A single agent calling a fixed set of tools is the case the Substrate Pattern already covers.

What’s the simplest mitigation if a full intersection model is too much work right now? Cap delegation depth to one hop, and require every sub-agent invoked from a user-facing agent to be provisioned with a scope no broader than the calling context — even if that means maintaining a separate, more restricted configuration of that sub-agent just for this call path.

Bottom line

Single-agent guardrails are necessary but not sufficient once agents can call other agents: identity, scope, and kill switches all have to be explicitly threaded through the delegation chain, or they silently stop applying past the first hop. Treat multi-agent trust as its own design problem, built on top of — not assumed from — single-agent safety architecture like the Substrate Pattern and Defence in Depth.

Related Articles