Single-agent deployments are the simpler case. A well-scoped, well-instrumented agent running a defined task against a defined set of tools is a contained problem. Multi-agent workflows are fundamentally different: they compose multiple agents into a coordinated system where each agent can invoke others, pass data through inter-agent messages, and take actions whose authorization was determined by an upstream agent the downstream agent cannot independently verify. The security properties of the system are no longer determined by the security of the weakest individual agent — they are determined by the security of every trust transition in the chain. This chapter describes how to secure those transitions. The underlying risk pattern maps to OWASP Agentic ASI08 (Agent Communication Integrity Failures) and ASI06 (Orchestrator Manipulation), and the controls here build directly on the multi-agent tracing and least-privilege scoping infrastructure from earlier chapters.

Why trust does not transfer automatically between agents

The intuitive assumption in multi-agent systems is that if the orchestrating agent is trusted, its sub-agents can be trusted transitively — the orchestrator was authorized, so the work it delegates must also be authorized. This assumption is wrong in security terms, and the consequences of relying on it are significant. An orchestrator agent can be compromised by prompt injection, manipulated by a rogue peer agent, or simply issue instructions outside its own authorized scope. If the sub-agent that receives those instructions executes them without independent authorization, the sub-agent has effectively laundered the orchestrator's compromise into privileged action. The correct model is that trust does not transfer at agent boundaries: each agent independently verifies the authorization of the instruction it receives, issues its own scoped credentials for the actions it takes, and does not treat provenance from an agent peer as automatically equivalent to provenance from a human principal. This is what Anthropic's model specification describes as agents maintaining safe behavior regardless of the instruction source, including other agents.

61%
of security teams report that inter-agent authorization is their top unresolved challenge in multi-agent AI deployments

The four security primitives for multi-agent systems

1

Agent-to-Agent Authentication

Every inter-agent message should carry a verifiable identity for the sending agent. The Google Agent-to-Agent (A2A) protocol and the Model Context Protocol authentication spec both provide patterns for this. At minimum, the receiving agent should be able to verify that the message came from an agent whose identity is registered, not just trust the claimed identity in the message payload.

2

Scoped Task Delegation

When an orchestrator delegates a task to a sub-agent, it should issue a scoped delegation credential that authorizes the sub-agent to perform only the specific operations needed for that task — not the full scope of the orchestrator's own authorization. This is the agent-to-agent application of the least-privilege principle: the sub-agent receives the minimum permissions necessary for the delegated task, preventing a compromised sub-agent from leveraging the orchestrator's broader privileges.

3

Cascade Failure Circuit Breakers

In a chain of agents, an error or anomaly in an upstream agent can propagate downstream as the error state becomes the input to the next agent. Circuit breakers interrupt this propagation by detecting anomalous outputs from any agent in the chain and refusing to pass them to downstream agents until a human has reviewed the state. The pattern is the same as the circuit breaker in distributed systems engineering: fail closed, recover deliberately, with human oversight at the failure point.

4

Cross-Agent Trace Correlation

The audit infrastructure for a multi-agent system must propagate a single correlation identifier through every agent hop, every tool call, and every inter-agent message, so that a complete execution trace can be reconstructed across all agents in the workflow. Without this, multi-agent tracing produces agent-local logs that cannot be joined into a coherent picture of what the system did. The OpenTelemetry GenAI semantic conventions define the span model for this.

Orchestrator security: the highest-value attack surface

The orchestrator is the highest-value compromise target in a multi-agent system. If an attacker can manipulate the orchestrator — through prompt injection in its context, through a malicious sub-agent sending crafted responses, or through manipulation of the task description it receives — they gain control over the entire downstream workflow. The orchestrator's scope of action is typically the union of all the scopes of its sub-agents, which means a compromised orchestrator has access to the full attack surface of the system. For this reason, orchestrators should apply the same prompt injection defenses as any other agent (provenance-tagged inputs, trust-tier-gated actions), but with heightened vigilance: the orchestrator's context regularly includes outputs from sub-agents, which are themselves a source of potentially injected content. An orchestrator that treats sub-agent outputs as fully trusted inputs is a single-hop escalation path to full workflow compromise.

The defensive principle is to treat sub-agent responses with the same skepticism as any other external content: validate them against expected schemas, apply provenance labels (sub-agent output is not human principal input), and refuse to execute instructions embedded in them without explicit authorization. The Anthropic multi-agent guidance makes this explicit: an orchestrator should not assume that instructions arriving through agentic pipelines are legitimate just because they arrive on an expected channel.

“Trust does not transfer at agent boundaries. Each agent must independently verify the authorization of the instruction it receives — including instructions from an orchestrator.”

Working through these controls yourself? The Skyrelis Agent Checklist condenses this series into a one-page pre-production reference.

Download Free →

Authorization at handoff points

Every point at which one agent passes work to another is an authorization decision point. The three questions to answer at each handoff are: Is the sending agent who it claims to be (authentication)? Is it authorized to request this task (authorization)? Is the task description it is passing consistent with what it was authorized to do (scope validation)? The third question is the one most often skipped: teams verify agent identity and check authorization in general, but don't validate that the specific task being delegated is within the scope of what was approved. An orchestrator authorized to "analyze customer data" should not be able to delegate a task to a sub-agent to "export customer data to an external endpoint" — the delegation has changed the action type, and the authorization decision needs to reflect that change.

Handoff ElementSecurity RequirementFailure Mode if Skipped
Sender identityCryptographically verified against agent registryMessage injection by rogue agent claiming legitimate identity
Delegation credentialScoped to the specific task; issued by orchestrator; short-livedSub-agent executes with orchestrator's full scope; privilege escalation via sub-agent compromise
Task content validationTask description validated against approved action types for the delegating agentInjection via task description causes sub-agent to take unauthorized actions
Response validationSub-agent response validated against expected schema before being used as orchestrator inputMalicious content in sub-agent response hijacks orchestrator's next action
Correlation ID propagationCorrelation identifier from parent trace propagated into sub-agent traceAudit log cannot reconstruct cross-agent execution chain; forensics fails at agent boundary

Human oversight in multi-agent workflows

The human-in-the-loop design principles from the guardrails chapter become more complex in multi-agent systems because the action that needs human review may be several agent hops removed from the human-facing interface. A multi-agent system that routes all interrupts through the orchestrator to a human interface is operationally simpler but may suppress critical signals from sub-agents that have detected anomalies the orchestrator does not know about. The architectural requirement is that any agent in the system can escalate to human oversight directly, not just via the orchestrator, and that escalations from sub-agents include enough context (agent identity, task description, the specific action that triggered the escalation, and enough trace to reconstruct why) for the human to make an informed decision.

Multi-Agent Workflow Security Checklist

Every inter-agent message carries a cryptographically verifiable sender identity checked against the agent registry
Task delegation uses scoped short-lived credentials; sub-agents do not inherit the orchestrator's full authorization scope
Task content validated at each handoff to confirm action type is within the delegating agent's approved scope
Sub-agent responses validated against expected schemas before being used as orchestrator inputs
Cascade circuit breakers fail closed on upstream anomalies; human review required before chain resumes
Single correlation identifier propagated through all agent hops for cross-agent trace reconstruction
Any agent can escalate to human oversight directly, not only through the orchestrator
Orchestrator treats sub-agent outputs with the same trust skepticism as external content, not as fully trusted inputs

See how Skyrelis secures multi-agent coordination

Agent-to-agent authentication, scoped delegation, cascade circuit breakers, and correlated cross-agent traces — in one runtime layer.

Frequently Asked Questions

Why can't sub-agents simply inherit the orchestrator's authorization?
Inherited authorization is the multi-agent equivalent of running every service as root: it works until a single component is compromised, at which point the blast radius is the full scope of the inherited privilege. An orchestrator agent in a production deployment typically has broad authorization — it needs to coordinate across multiple tools and data sources. If a sub-agent inherits that full scope, then compromising any sub-agent (via prompt injection in its input, via a malicious tool response, via a model behavior shift) gives an attacker the orchestrator's full action surface. Scoped task delegation limits each sub-agent to the minimum permissions needed for its specific delegated task, applying the least-privilege principle at the agent-to-agent boundary just as it applies at the agent-to-tool boundary.
What is a cascade failure in a multi-agent system, and how do circuit breakers help?
A cascade failure occurs when an anomalous state in one agent propagates as input to the next agent in the workflow, which then generates its own anomalous output, which propagates further. The multi-agent equivalent of a distributed systems failure loop. In agent terms, this can happen when a prompt-injected orchestrator passes a malicious task description to a sub-agent, which executes it and returns results that the next agent in the chain uses to authorize further escalating actions. A cascade circuit breaker intercepts the flow at each agent boundary, validates the output of the upstream agent against expected schemas and behavioral baselines, and fails closed (halts the chain and escalates to human review) when the output looks anomalous. The intervention happens at the propagation point rather than waiting for a final outbound action to fail.
How does agent-to-agent authentication work in practice?
In practice, agent-to-agent authentication uses the same infrastructure as service-to-service authentication in distributed systems: each agent has a cryptographic identity (typically a short-lived certificate or a signed JWT) issued at registration or at session start. When agent A sends a message to agent B, the message is signed with A's credential, and B verifies the signature against the identity registered for A in the agent registry. The Google A2A protocol defines a task and artifact exchange format with agent identity verification built in. The MCP authentication specification provides a complementary pattern for tool-invocation authentication. Both require the agent registry (described in Chapter 8) to hold the authoritative identity for each agent.
How is multi-agent workflow security different from microservices security?
Multi-agent and microservices security share the same fundamentals — service identity, least-privilege, defense in depth, audit trails — but differ in important ways. Microservices have deterministic behavior: a given input produces a predictable output, defined by the service's code. Agents are non-deterministic: the model's reasoning produces different actions on different runs, and the action space is defined by the tools available, not just by explicit code paths. This means behavioral baselines replace code-defined behavior as the security anchor, and the authorization decisions are semantic (is this action type within the approved scope?) rather than syntactic (is this API call on the allowlist?). The other key difference is that agents can be adversarially manipulated through their inputs in ways that microservices generally cannot — which is why content provenance, prompt injection defenses, and response validation at handoff points are first-class security requirements in multi-agent systems and not in microservice architectures.
What standards cover multi-agent security today?
The primary standards reference today is OWASP's Top 10 for Agentic Applications (2026), which covers agent communication integrity (ASI08) and orchestrator manipulation (ASI06) as named risk categories. The NIST AI Risk Management Framework addresses multi-agent governance under its Govern and Manage functions. At the protocol level, Google's A2A specification and Anthropic's MCP provide interoperability and authentication primitives. The OpenTelemetry GenAI semantic conventions define the observability model. The field is moving fast; the EU AI Act's obligations for high-risk systems implicitly cover multi-agent deployments, and enforcement guidance is expected to clarify the application to agentic architectures by late 2026.