Inter-Agent Communication Security in Multi-Agent Systems
Poisoned messages between agents can trigger cascading failures across isolated systems.

Inter-agent communication security requires controls at every handoff and at the system perimeter. Firecracker micro-VM isolation for AI agents sets the infrastructure boundary by giving each agent its own kernel and hardware-isolated environment, while containers share a kernel. That containment must work with verified identities, scoped delegation, and external authorization, because an isolated agent can still act on a poisoned message.
Why multi-agent systems create attack surfaces that single-agent security cannot address
A poisoned output from Agent A can become a trusted input to Agent B at a routine message handoff. The adversarial instruction comes with data for the legitimate task and crosses a boundary that a local input check may miss. Single-agent security assumes a bounded perimeter around one model, one context window, and one set of controlled inputs. Delegation dissolves that perimeter by moving information and authority between agents.
Context fragmentation makes the handoff harder to defend because downstream agents do not have the evidence from upstream agents, including security-critical validation. A mis-extracted field can therefore propagate through every later step without the context needed to correct it. The Johns Hopkins SoK study shows that benign prompt fragments can cause harm when put together, while reports that are each truthful can lead a group to believe something false. Crew Scaler's NIST response describes this security surface as “behavioral and emergent rather than structural and bounded”. As the network grows, one compromised agent can spread influence across the fleet, making the failure multiplicative.
The nine threat categories that map the MAS attack surface
Crew Scaler's NIST response derives 193 distinct threat items across nine categories from production architectures. The categories are Agent-Tool Coupling, Data Leakage, Injection, Identity and Provenance, Memory Poisoning, Non-Determinism, Trust Exploitation, Timing and Monitoring, and Workflow Architecture. Together, they map where information, authority, state, and execution can go wrong. Identity and Provenance concerns who originated a message, while Trust Exploitation concerns the authority that recipients assign to it. Timing and Monitoring and Workflow Architecture extend the map beyond message content to coordination and execution.
Non-Determinism and Data Leakage are the most under-addressed domains across all sixteen reviewed frameworks. The same orchestration prompt can produce different delegation chains across runs, making assurances conditional on behavior that cannot be fully anticipated at design time. Meanwhile, function-calling JSON and conversation history can carry private information past the agent that first handled it. Injection exploits these crossings by turning data into instructions. Agent-Tool Coupling can turn a manipulated message into policy-level remote code execution, while Memory Poisoning can contaminate every agent that retrieves from a shared vector database.
Six attack mechanisms that exploit multi-agent communication specifically
Indirect prompt injection uses honest agents as relays between attacker-controlled content and privileged actions. A retrieved document or upstream output carries an instruction that a downstream agent treats as actionable. The Johns Hopkins SoK study traces how such content passes through honest specialist agents to reach a privileged tool. The user never sees the injected instruction and cannot step in, while each handoff seems to help with the legitimate task.
Self-replicating prompt infection turns the same messaging infrastructure into a propagation channel. Rather than influencing only one recipient, the payload induces agents to spread it through their own communications. Lee and Tiwari documented this mechanism using GPT-4o, with harmful outcomes including data exfiltration, scam creation, and malware creation across a large share of runs.
Confused-deputy exploitation follows the authority gradient created by delegation. An outer agent acting for a user is manipulated into instructing a more privileged inner agent to perform an unintended action. The attacker does not need direct authorization for the privileged capability. Instead, the delegation chain supplies access that the attacker could not obtain at the original entry point.
Agent-in-the-middle attacks exploit the recipient's inability to verify that an inter-agent message arrived unchanged. A malicious or compromised agent intercepts and modifies communication between legitimate agents. The ESC-CR paper describes an attacker preserving a legitimate interface description while adding an instruction to transmit results to an unauthorized destination. The message remains plausible and well formed, so interface conformity does not establish integrity.
Shared-context data leakage exposes more information when agents share conversation history and function-calling JSON. Information meant to stay within one agent's scope can be seen by every downstream agent that gets that context. The shared history goes to several recipients and crosses their permission boundaries, unlike a single context window. The way agents communicate exposes the information even when no instruction tells an agent to share anything.
Supply-chain poisoning reaches the fleet through deployment infrastructure. Its vectors include container registry compromise, typosquatting, digest-collision bypass, and GitOps automation. Centralized model-serving containers make distribution an amplifier, since a single registry credential compromise can deploy a backdoor across the fleet before human review. This mechanism makes runtime containment a separate requirement from message authorization.
Why existing security frameworks were built for systems MAS is not
Most security frameworks assume deterministic control flow, bounded trust boundaries, stateless execution, and identifiable adversarial inputs. Multi-agent systems violate those assumptions when they vary delegation chains, share persistent memory, and propagate tool authority. Crew Scaler's NIST response scores sixteen frameworks against 193 MAS threat items and finds that no reviewed framework achieves majority coverage in any single category.
The OWASP Agentic Security Initiative covers the most threat items overall and in the design phase in that assessment. The CDAO Generative AI Responsible AI Toolkit leads development coverage and shares strong operational coverage with OWASP ASI, but both leave most threat items uncovered. NIST AI Risk Management Framework addresses AI risks broadly without having been originally scoped to these emergent failures. MITRE ATLAS has been substantially extended, with 139 of 208 technique entries in the September 2026 release, v2026.09, tagged for Agentic AI. Developers choosing a framework need data on what it covers in each category, especially Non-Determinism and Data Leakage, because reputation alone cannot show that coverage.
How the MCP and A2A protocols define the communication layer and where their security models break down
Anthropic's MCP provides authenticated, schema-based interfaces for discovering and invoking external tools within a trust boundary. Google's A2A, contributed to the Linux Foundation in 2025, supports agent-to-agent communication and capability delegation across trust domains through Agent Cards. A2A version 1.0.0, released in March 2026, adds an extension mechanism supporting new data, requirements, RPC methods, and state machines. These facilities define communication behavior, but they do not supply a complete agent trust plane.
MCP's core specification does not define agent-native identity, mutual authentication between agents, or agent-native authorization semantics beyond OAuth 2.1 transport-level delegated flows. A2A's guidance centers on HTTPS and standard HTTP authentication schemes, including OAuth 2.0, OpenID Connect, API keys, and mutual TLS. It sets no standard for agent-native identity, structured delegation chains, or cross-domain trust like that of a dedicated trust plane. A2A leaves credential provisioning out-of-band, although its v1.0 specification requires servers to reject requests with missing credentials. Implementers must therefore distinguish available authentication mechanisms from a completed identity architecture.
That distinction matters at capability discovery, before any delegated work begins. An Agent Card describes what an agent offers, but a malicious agent can misrepresent those capabilities. A compromised agent can ask for sensitive context, use delegation to go beyond the user's authority, or send back poisoned artifacts. Capability discovery therefore needs authenticated claims.
The architectural controls that address the topology of trust, not just the perimeter
Identity is the first architectural decision because network position does not establish who an agent is. Every agent needs its own identity that peers can verify. Agent Cards must have explicit securitySchemes and security fields, since empty or absent schemes describe a public agent wherever it sits on the network. Mutual TLS works for internal agents within one trust boundary, OAuth 2.0 client credentials work for machine-to-machine communication between organizations, and OpenID Connect allows federation between providers. AgentCardSignature verification protects discovery against tampering, though it does not authorize every action a discovered agent requests.
Tool authority must then be enforced outside the model. Each agent needs an explicit tool allowlist enforced by the orchestration layer, so an adversarial message cannot expand its permissions. This limits confused-deputy exploitation only when authorization governs both delegated effects and the outer agent's direct calls. ESC-CR states the rule that inter-agent messages can add information but cannot, on their own, authorize new effects. Stronger message checks are therefore not a substitute for an external authorization boundary.
ESC-CR implements that separation through executable semantic commitments built from trusted tasks, evidence, and policy. Prompt-level provenance labels and instruction hierarchies can guide behavior, but they cannot supply an independent release decision. On a violation, ESC-CR taints the responsible message and rejected artifact, reconstructs clean context from evidence-backed task information, and regenerates under the same policy. Sentinel agents watch communication for policy violations from outside the execution paths of individual agents.
Delegation must likewise pass a scoped credential or capability token. The Johns Hopkins SoK study frames defense through five parts, which are path target, observation, intervention, trust boundary, and recovery. Its hardest challenges are preventing adversarial extension of delegation chains and restoring useful clean state. These semantic controls also need containment between agents. Maritime implements that separation with a Firecracker micro-VM per agent, a dedicated kernel, and persistent disk, providing a stronger boundary against direct cross-agent access than shared-container or process-level isolation.
How to give each AI agent its own isolated kernel with VM-level isolation
Firecracker, AWS open source, uses KVM to create lightweight microVMs with hardware-enforced isolation. Each microVM has its own kernel, memory space, and virtual hardware, unlike containers that share a kernel. A compromised agent cannot use a shared process namespace to read another microVM's memory, file system, or network state directly. The relevant isolation boundary is hardware virtualization and the hypervisor. For untrusted agents in production, this is the distinction between separating processes and separating the kernels those processes depend on.
A poisoned output can still traverse an allowed communication channel, so microVM isolation does not replace external message authorization. When each agent has its own kernels, credential stores, and file systems, as in Maritime's per-agent deployment, a compromised agent has fewer resources to use for lateral movement. The infrastructure control and the policy control address different paths through the same system. Neither is sufficient alone.
Production Firecracker deployments require the jailer wrapper to apply seccomp filters, drop privileges, namespace the VMM process, and chroot it into an isolated directory. Without the jailer, the VMM retains more privilege than necessary for multi-tenant deployment. Firecracker's snapshot-restore API supports restoring a pre-booted microVM from NVMe instead of booting from scratch, making per-request destruction and recreation economically viable. This permits a fresh environment per job or agent step rather than reliance on cleanup within a reused runtime. Persistent disks and shared memory remain separate state boundaries, so fresh execution must not be confused with recovery from poisoned persistent data.
What a defensible multi-agent system looks like when all the controls are composed
A defensible system makes each layer constrain the next. Signed Agent Cards and authenticated channels establish who is communicating, while scoped delegation tokens and orchestration-enforced tool allowlists bound what that identity may do. External release decisions prevent message claims from creating authority, and sentinel monitoring observes violations outside the executing agent. Per-agent microVMs then contain direct resource access if an agent is compromised, with snapshot-restore scheduling making disposable execution practical.
Crew Scaler's coverage data points to OWASP Agentic Security Initiative for design coverage and CDAO Generative AI Responsible AI Toolkit for development and operations, with known gaps in both. Path closure and selective recovery remain difficult, but they do not prevent a concrete starting point. Give every agent an identity, set the scope of every delegation, enforce tool permissions in the orchestration layer, and give each agent its own isolated environment.
Sources
- Security Considerations for Multi-agent Systems** A Crew Scaler (501c3 pending org)’s response to NIST RFI 2026-00206
- Security Considerations for Multi-agent Systems
- SoK: When Safe Agents Fail Together: The Security of Multi Agent LLM Systems
- Policy-Backed Selective Regeneration under Tainted Inter-Agent Communication
- Sentinel Agents for Secure and Trustworthy Agentic AI in Multi-Agent Systems
- Architecture Matters for Multi-Agent Security


