Shared Infrastructure Failure Modes That Only Per-Agent VM Boundaries Can Prevent

Four shared-infrastructure risks that session isolation alone cannot stop.

· 9 min read
Cover illustration for “Shared Infrastructure Failure Modes That Only Per-Agent VM Boundaries Can Prevent”
Sandbox & Runtime · November 11, 2026 · 9 min read · 1,949 words

Firecracker micro-VM isolation for AI agents gives each agent its own kernel and machine state. Per-agent virtualized environments provide the compute boundary for containing untrusted agent execution, but trustworthy isolation also requires separate tenancy, controlled network access, and task-scoped credentials. A VM alone does not isolate a shared external memory store, eliminate physical cache sharing, or revoke a copied token.

Why shared infrastructure creates a failure class that software isolation cannot reach

Cross-agent memory corruption, noisy-neighbor resource exhaustion, covert-channel communication through shared caches, and cascading credential exposure are four distinct risks of shared agent infrastructure. They do not all arise at the same layer. Memory poisoning can cross a shared storage boundary, resource exhaustion crosses an unenforced allocation boundary, cache channels exploit shared hardware, and credential exposure follows permissions. The common failure is a boundary drawn somewhere other than where the resource is shared.

Agents bring these risks together in one execution loop. They hold memory, run code, use credentials, and reach the network. A session identifier can separate their records without separating the machinery or authority behind those records. That distinction is the starting point for containment. The Kubernetes project describes agents as stateful, singleton workloads that act as digital workspaces or execution environments, a shape its traditional primitives do not perfectly fit.

LangGraph and CrewAI rely on software-level, session-keyed storage isolation by default. MAF’s Foundry Hosted Agents provide per-session VM-isolated sandboxes, while self-hosted MAF deployments require developers to configure isolation explicitly. A framework can distinguish two conversations without giving their agents separate kernels, resource budgets, or credentials.

How shared memory backends let one agent corrupt every other agent simultaneously

When several agents read the same memory backend, one poisoned write can change the information available to all of them. The failure does not need to pass from agent to agent. Without storage-layer enforcement, agent A can change a value that agents B, C, and D later use as trusted state. Separate session names do not help if they leave that shared value writable.

This is not a race that retries resolve. Retrying a read can return the same corrupted value, and every later reasoning step can build on it. The damage spreads through shared memory, communication paths, and feedback loops even when the other agents behave as designed. Their common source of truth has become the source of the fault.

Stateful Agent Backdoor shows how persistent memory can link the phases of an attack across sessions. The research reports complete cross-session attack programs with mean success rates as high as 94.7% across four models. After an initial trigger, a backdoored agent can write attack state during one session and use it later when the necessary tools become available. The attacker need not remain present throughout the sequence. From outside the memory layer, using memory for normal work can thus look the same as using it to coordinate an attack.

Two agents accessing one backend need not occupy the same process address space to poison each other’s inputs. Their exposure comes from access to the same records. That is why separating execution alone cannot establish the integrity of a memory service both agents can still modify.

How one agent's resource consumption becomes every agent's problem without kernel-level enforcement

A runaway agent does not have to be malicious. With independently unbounded memory and CPU consumption, it can consume resources that neighboring agents need. Memory pressure can look like ordinary workload variation until the host starts swapping or runs out of memory. Other agents then slow down without receiving a clear signal that a neighbor caused the problem.

Session isolation does not allocate a resource budget. Containers can use kernel-enforced cgroup limits, but those limits provide per-agent containment only when each agent has its own enforced allocation. Several framework sessions that share one allocation still compete for what it holds.

Eval and reinforcement learning workloads make this distinction expensive. Hundreds of parallel rollouts can share a batch, so one runaway rollout can delay the training loop and distort the conditions under which its neighbors are measured. Rollouts dominate the wall-clock time of agentic reinforcement learning. Resource interference therefore threatens both throughput and the usefulness of an iteration.

ProRL Agent’s “rollout-as-a-service” model separates rollout execution from training. Each rollout becomes an independent sandboxed environment that can scale and fail without bringing its neighbors with it. The architectural requirement is enforcement at or below the kernel. A VM provides a separate guest kernel, while resource allocation still has to bound what that VM can consume.

Covert channels through shared CPU caches and why namespace boundaries cannot see them

Cache timing exposes a different kind of sharing. Two processes can communicate through patterns of cache use without sharing a file, a network connection, or an application memory record. One process encodes information through cache access patterns. The other measures how long its own accesses take and decodes the resulting timing differences.

The physical placement determines which caches are shared. Processes on the same physical core can share L1/L2 caches, while those on different cores can share the last-level cache. A namespace changes a process’s view of operating-system resources while leaving this physical relationship unchanged. Monitoring files and network packets consequently does not expose the channel as an ordinary transfer.

For agents that handle credentials or sensitive user data, such a channel is a reason to check which hardware they share. It does not establish that every shared-container deployment is being exploited. Software session boundaries do not govern the cache behavior that makes the channel possible.

A separate virtualized hardware view is not the same as a separate physical cache, so a VM boundary alone cannot be described as eliminating all cache-timing channels. Separate kernels remove the risk that comes from a shared kernel, while the physical hardware can still be shared.

How credential exposure cascades when secrets are scoped to a host rather than to a task

Credential exposure often needs no escape from a sandbox. A prompt-injected agent can use legitimate permissions to reach data belonging to another agent, user, or environment. The attack succeeds because the credential grants too much access. Its blast radius follows the secret’s scope.

A shared .env file puts multiple agents’ tokens within reach of any agent allowed to read it. With a cluster-wide service account, a compromised agent likewise has all the account’s broad permissions. If production credentials are within reach from a preview environment, that reach crosses from one environment to another. Secrets baked into images and tokens left valid after a task ends extend it across time.

Through prompt injection, content an agent reads can redirect its control flow so that it collects or sends information it already has permission to access. The same backdoor research shows how persistent memory can link one chance for file access with a later chance for network access. A credential collected in one session can become material for exfiltration in another.

Credentials must be bound to the task, and where the agent can send them must be constrained. The route to the cloud metadata endpoint at 169.254.169.254 must be blocked because it can expose host-scoped instance credentials. Destroying a task VM removes the environment that held its secrets. It does not, by itself, invalidate a token copied elsewhere. Credential lifetime and scope remain independent requirements.

How do you give each AI agent its own isolated kernel without using containers?

A per-agent VM gives each agent its own guest kernel and machine state. Unlike a namespace inside a shared kernel, it places guest memory isolation under the hypervisor. This removes the shared guest-kernel boundary between agents. It also creates a concrete unit that can be started, paused, resumed, and destroyed with the task.

Firecracker microVMs implement this model with rapid boot and low per-agent overhead. A complete deployment pairs that machine with enforced resource limits, isolated storage access, task-scoped credentials, and network policy. Default-deny egress, FQDN allowlists, and a blocked metadata route govern what the agent can reach beyond its own environment.

AWS Bedrock AgentCore gives each agent session its own microVM. A session can run for up to 8 hours, subject to a default 15-minute idle timeout, before its VM is destroyed. This makes the session a machine-lifecycle boundary. This lets agents keep their execution state for the whole task.

Firecracker’s snapshot mechanism makes pauses practical without keeping an agent actively running. It preserves memory and hardware/device state and can restore them in milliseconds, while block device contents must be managed separately by the operator. An agent can therefore sleep through a human approval delay. The state stays within a defined execution boundary instead of in a workspace that stays shared indefinitely.

Where the VM boundary argument has real limits and what it does not solve

The four boundaries are compute, network, tenancy, and identity. None substitutes for the others, and a VM principally establishes the compute boundary. Machines that are otherwise separate can still be linked through shared external memory. With broad credentials and unrestricted outbound access, even an isolated agent can send out information it is allowed to read.

GPU access introduces a practical constraint of its own. Firecracker has no production GPU passthrough, so workloads requiring GPU-accelerated inference inside the same boundary face a deployment tradeoff. The brief names self-hosted bare-metal and third-party approaches as possible ways to get GPU access with strong isolation. That possibility is not equivalent to native production GPU passthrough in Firecracker.

Startup and persistence also involve operational tradeoffs. Rapid boot still has some startup latency, and with snapshots, the operator still has to manage block devices. A disposable VM still needs a defined disk and credential lifecycle.

Windows-specific containment has its own maturity limits. Microsoft described Microsoft Execution Containers at Build in June 2026 as a cross-platform, policy-driven execution layer for agents on Windows and WSL. Hardware-backed micro-VM isolation and Linux containers through WSL were roadmap capabilities at that time.

Applying the four-boundary model to real agent workloads: coding agents, eval pipelines, and regulated desktop automation

For coding agents, untrusted execution makes compute isolation the immediate concern. A command that looks safe alone can behave maliciously when its surrounding environment has been poisoned, including through environment variables. Static command allowlists therefore cannot stand in for containment. The prescribed boundary is a disposable VM whose disk is deleted when the task ends, with network and identity controls limiting what the executed code can reach.

For eval and reinforcement learning pipelines, independent resource budgets protect the measurement as well as the infrastructure. SCALECUA’s online RL stage uses 600 parallel VM environments per iteration. At that scale, one rollout’s memory spiral must not change the execution conditions of its neighbors. In the rollout-as-a-service pattern, the trainer sends a task description to a service that creates a sandbox, runs the agent, captures its trajectory, and returns it.

For Windows computer-use agents, the biggest concern is the authority a session gives them. An agent automating a Citrix or EHR session inherits that session’s permissions, so a contained desktop gives the work a discrete boundary that can be audited, destroyed, and replayed. Regulated healthcare, lending, and insurance workflows also need a complete audit trail, and another agent’s state must not affect the session. Citrix’s device posture checks, adaptive MFA, and application-level clipboard controls fit that session-based design, but do not replace identity scoping.

Snapshotting lets an agent wait without actively consuming compute, while per-user isolation must keep files, credentials, browser state, and data beyond another user’s reach. These workloads differ in their dominant risk, but all require the four boundaries to hold together. The per-agent VM is the minimum separate-kernel containment unit for untrusted execution and requires the storage, hardware, network, and identity controls that complete isolation.

Sources

  1. Stateful Agent Backdoor
  2. A Survey on Agentic Security: Applications, Threats and Defenses

More in Sandbox & Runtime