Why Multi-Tenant Agent Clouds Need Hardware Virtualization Boundaries Not Namespace Tricks
Hardware virtualization boundaries, not namespaces, can contain agents executing untrusted code.

Multi-tenant agent clouds need hardware virtualization boundaries because agents run untrusted code and containers make tenants share a host kernel. Firecracker micro-VM isolation for AI agents gives each agent its own guest kernel, with hardware that enforces the boundary. That separation must also cover persisted state, and snapshot-restore makes it practical to give each agent its own environment without keeping it running while idle.
Why namespace isolation was designed for a different threat model
Linux namespaces partition process trees, network views, and filesystem mounts, while cgroups govern resource use. Neither gives a container its own kernel. Every container on a host makes system calls into the same shared kernel, so separate views of the machine do not constitute separate machines. The design assumption behind this model is that the platform controls the code it runs. Its central concerns are resource exhaustion and noisy-neighbor interference, rather than deliberate exploitation by code supplied at runtime.
Traditional multi-tenant SaaS follows that division of responsibility. Separate database rows, API keys, and role-based access controls distinguish customers because the vendor controls the code path end to end. Checks at the application-layer can then keep tenants apart without giving each one its own execution environment. Agents break that assumption when they generate and execute code from customer prompts. The platform controls the service but no longer knows the instructions that service will execute.
Crew Scaler’s MAS security study describes autonomous agents as exercising delegated tool authority, writing and executing code, and managing workflows at production scale. That is a different delegation of power. Partitioning resources is being asked to contain autonomous action by untrusted code.
What changes when agents execute arbitrary, untrusted code
An agent that can write, install, and execute arbitrary code effectively holds a shell inside its environment. The infrastructure that shell can reach is its attack surface. A malicious prompt can direct execution toward resources available there, making the environment’s permissions and isolation boundary critical even when the model itself has safeguards.
Agent Security Bench (ASB, ICLR 2025) reports an average attack success rate of 84.30% across ten real-world agent deployment scenarios. That figure measures the success of agent attacks. Successful manipulation can lead to generated exploit code, execution inside a container and, if an escape succeeds, access beyond the tenant boundary. A shared host kernel makes that last step consequential for co-tenant workloads. Model compromise and infrastructure compromise are distinct, but the execution environment connects them.
The same study from Crew Scaler finds that the frameworks it reviewed have few established ways to counter attack patterns such as prompt injection and policy-level remote code execution through tool coupling. Exploitation is not the only failure path. A runaway agent can also exhaust resources and degrade co-located tenants, turning a local execution failure into a shared service problem. The study identifies data leakage and non-determinism as particularly under-addressed domains, reinforcing why an agent’s behavior cannot serve as its containment mechanism.
Why container escape vulnerabilities keep recurring and cannot be patched away structurally
More available system calls give containers more useful functionality, but also more paths into the kernel responsible for enforcing their separation. Patching a vulnerable path closes that particular opening. It does not remove the shared dependency or change which component receives each tenant’s system calls.
The runc escapes CVE-2019-5736 and CVE-2024-21626 illustrate the recurring failure pattern. Each disclosure creates a period in which affected deployments can expose tenant boundaries to exploitation. These are concrete vulnerabilities, but their recurrence points beyond individual fixes to the architecture around them. Parts of the host remain exposed through the container interface, and new kernel features and runtime capabilities can expose more of the host. Kubernetes’ own documentation describes containers as offering “a weaker isolation boundary” than hardware-based virtual machines.
The OpenClaw agent framework illustrates a related failure at the configuration layer. Its sandbox wrapped agent execution in Docker containers but passed sandbox configuration fields directly into Docker CLI arguments without validation. An attacker able to influence that configuration could inject a bind mount for the Docker daemon’s Unix socket and defeat the intended isolation. No kernel exploit was needed for that path. The example shows why a container’s presence is not evidence that an enforceable tenant boundary has been deliberately constructed.
How do you give each AI agent its own isolated kernel?

Hardware virtualization gives each workload a guest kernel. The hypervisor controls a hardware memory management unit, or MMU, that separates guest memory and privilege from the host. This changes the boundary being trusted. A container depends on the shared kernel correctly distinguishing tenants, while a microVM places the guest kernel itself inside the isolated environment.
Consequently, root access inside a guest is not host root access. Even when an attacker fully compromises a guest kernel, it stays on the guest side of the virtualization boundary, without automatic control over neighboring workloads. The containment property is a smaller blast radius. A vulnerability in one tenant’s kernel does not itself provide access to another tenant’s environment, because those tenants do not share that kernel.
The remaining security boundary shifts to the hypervisor and virtual machine monitor, or VMM. A minimal VMM presents a smaller, more auditable interface than the broad host-kernel surface exposed to container workloads. Compromising code inside a tenant’s machine is structurally distinct from compromising the mechanism that separates machines, even though virtualization software can contain vulnerabilities. For agents that run arbitrary code, that distinction calls for VM-level separation over more namespace configuration.
How Firecracker made per-tenant microVM isolation practical at cloud scale
Firecracker provides hardware isolation without the startup cost and memory overhead that conventional VMs have had in the past. AWS originally built it for Lambda and Fargate, open-sourced it, and runs it beneath both services. With approximately 125ms boot time and under 5 MiB of memory overhead per microVM, guests that each serve one tenant have costs close to those of containers. These figures address provisioning cost. A host’s ability to launch many microVMs per second makes per-request or per-session allocation practical.
AWS Bedrock AgentCore uses a dedicated Firecracker microVM per agent session for its Code Interpreter and Browser tools. That is a concrete production example of the agent isolation pattern. AWS Lambda MicroVMs became generally available on June 22, 2026, providing dedicated, stateful environments that builders can launch, suspend, resume, and terminate without owning the underlying virtualization layer. Together, these implementations place microVM isolation beyond an architectural proposal.
However, adopting Firecracker directly still leaves substantial infrastructure work. Its networking requires management of TAP interfaces, IP tables, and host routing, while Docker offers a mature CNI plugin experience. Teams must also own the control plane that provisions and manages agent environments. A managed per-agent microVM platform is therefore an engineering option using the same isolation mechanism. It supplies Firecracker-based separation while removing the need to build the networking and lifecycle machinery from scratch.
Why persistent state inside isolated VMs is a requirement, not a feature
An agent often has work that lasts beyond a single execution session. Multi-step work accumulates files, credentials, installed packages, browser sessions, and intermediate state that must survive between turns. Resetting that environment at every wake discards continuity. Stateless execution suits request-response workloads, but on its own it cannot let an autonomous agent return to unfinished work across sessions.
The Crew Scaler study identifies shared persistent memory as a distinct attack surface, including memory poisoning through shared vector databases and cross-session contamination. If a filesystem or memory access flaw lets one tenant read another tenant’s persisted information, the result is a data breach even when the VMs remain separate.
Storage isolation for each tenant must therefore go hand in hand with compute isolation for that tenant. The boundary must encompass the agent’s full lifecycle, including the files and credentials it leaves while inactive, rather than exist only while its CPU instructions execute. Giving an agent a private guest kernel but placing its accumulated state in an inadequately separated shared environment breaks that continuity of protection. Conversely, preserving an isolated environment allows execution to stop without discarding the agent’s work. That persistent, isolated state makes suspension an economic advantage while preserving functionality.
How snapshot-restore makes per-agent VM isolation economically viable at fleet scale

The strongest claim that a VM per agent costs too much assumes that every environment must stay warm. A running VM consumes compute even while its agent has nothing to do, so a large idle population can dominate the bill. When an environment can be suspended and restored in under a second, inactive agents require only storage.
The lifecycle begins by fully booting a microVM and snapshotting its state to disk. Restoring that snapshot brings back the isolated environment, including files, kernel state, and installed packages, without rebuilding it for each turn. Slow provisioning leads teams to keep warm pools to hide the wait, but approximately 125ms boot time makes it practical to create environments on demand. For an agent with accumulated work, suspension preserves that work without requiring an always-running instance.
Memory use can also favor the snapshot model. Restored guests can read shared template pages through copy-on-write, with a private physical page allocated when a guest writes to one. A fleet restored from the same template therefore need not allocate a full separate copy of that template’s RAM upfront. This supports container-class density while retaining VM-level separation.
At fleet scale, most agents are idle at any given moment. A snapshot-aware scheduler lets the compute bill track active concurrency rather than total agent count, including for fleets of thousands of agents. Suspended storage still has a cost and must be planned for. The economic comparison therefore accounts for active compute plus stored environments.
What the multi-tenant isolation decision looks like in practice for teams building agent products
The practical classification starts with who controls the executable code. Containers are sufficient for trusted, platform-authored paths such as internal background jobs and scheduled tasks whose code the platform controls. Under this threat model, agents that write and run code from prompts supplied by users need microVM isolation. A hybrid architecture is legitimate. Code that runs for customers can run in microVMs while trusted internal workloads stay in containers, as long as the team explicitly decides where each belongs based on trust.
OWASP guidance treats LLM-generated code as untrusted user input and calls for validating what it produces. Validation does not replace runtime containment. The 2026 Singapore Consensus places least privilege and traceable identity in design, while treating runtime assurance as an operational and monitoring responsibility. Those principles complement the execution boundary rather than allowing it to be postponed until an incident reveals the need.
For teams choosing to own virtualization, Firecracker provides the underlying mechanism but leaves networking and control-plane engineering with the team. A managed platform trades that ownership for infrastructure that provides each agent with a persistent disk, a real kernel, package installation privileges, and snapshot wake-up in under a second. A flat rate can work because agents that are idle use storage without keeping compute running. The choice is whether virtualization is infrastructure the team wants to build or infrastructure it needs in order to ship its agent product.
Protocol simplification does not change that choice. The 2026-07-28 MCP spec revision removes protocol-level sessions and makes each request self-contained, so MCP servers can sit behind a plain load balancer. That simplifies multi-tenant networking, but it does not contain the code an agent executes. Request routing, application permissions, and execution isolation solve different problems, and only execution isolation places hostile code against a shared host kernel or inside its own hardware-separated guest.


