Firecracker Adoption Patterns Across Agent Cloud Platforms and Where Kernel Isolation Actually Stops
Firecracker isolates agent kernels but leaves host, egress, and storage gaps uncovered.

Firecracker micro-VM isolation for AI agents gives each agent its own Linux kernel on KVM, rather than sharing the host kernel through containers. Its adoption across agent cloud platforms establishes a strong execution boundary. Host security, credentials and egress, framework storage, and prompt injection each need controls beyond that boundary.
Why agent platforms converged on Firecracker as their isolation primitive
An agent that runs shell commands, installs packages, writes files, and makes network requests has the power of arbitrary code execution. The limits of predictability and trust in its behavior, especially when user-supplied prompts guide its work, change the required boundary between tenants. Standard containers share the host kernel, so a kernel vulnerability reached from one container can compromise others. For multi-tenant agent workloads, separating processes without separating kernels leaves the central execution risk unresolved.
Firecracker moves that boundary by giving each microVM its own Linux kernel running on KVM. Firecracker’s documentation describes a user-space virtual machine monitor with a companion Jailer program that provides another line of defense if the virtualization barrier is compromised. A guest kernel exploit therefore does not, by itself, cross into the host or another VM. The structural separation holds whether or not the model follows the intended workflow.
Vercel Sandbox reached general availability in January 2026 with a dedicated Firecracker microVM and kernel for each sandbox. Vercel names isolation from production environment variables, database connections, and cloud resources as the reason. Perplexity open-sourced SPACE under Apache 2.0, with a separate Firecracker microVM for every task in Perplexity Computer. Google Agent Compute Engine, announced October 22, 2026, assigns each agent a hardware-isolated microVM with a separate kernel, while AWS Lambda MicroVMs reached general availability on June 22, 2026, with dedicated stateful VMs per user, session, or job.
What Firecracker's isolation actually covers: the kernel boundary and its perimeter
KVM enforces the guest boundary through hardware virtualization at the CPU level. The guest kernel runs in an isolated context rather than sharing the host kernel as a container does. Code inside the VM cannot reach the host kernel or another VM just by taking over its own kernel. That is the core isolation guarantee. It covers the guest execution environment, its filesystem, and separation from other VMs, with services the guest can access requiring separate controls.
The Jailer reinforces this boundary with Linux namespaces and seccomp filtering around the virtual machine monitor. Those controls provide OS-level hardening if the monitor process is compromised. Firecracker’s built-in network and storage rate limiters prevent a compromised guest from trivially exhausting those host resources.
Snapshot-restore extends the boundary across periods when an agent is not running. SPACE moves sandboxes through running, paused, suspended, and deleted states. During suspension, it snapshots VM memory, runtime state, and the root filesystem before releasing active resources. Suspension does not relax the guest’s isolation. Its btrfs copy-on-write root filesystems also make each sandbox’s disk footprint proportional to what it modifies, avoiding a full copy of the base image.
This lifecycle makes dedicated kernels practical at agent scale. A fresh Firecracker VM cold-boots in approximately 125–200ms, while memory overhead per microVM is measured in tens of megabytes. Thousands of VMs can therefore fit on one physical host. When suspended, their continuing cost is storage alone. The security unit can remain a dedicated VM even when the workload spends much of its life waiting.
Where the kernel boundary ends: three surfaces Firecracker does not cover
The first uncovered surface is the host kernel’s networking stack and its adjacency to the hypervisor. The Jailer and seccomp constrain many hypervisor compromise paths, but they do not eliminate vulnerabilities in the host itself. An attack that reaches the host kernel through the monitor’s network path can go around the guest boundary entirely. Guest isolation does not remove host CVE exposure. The host remains a separate trust boundary, with its own patching and hardening requirements.
The second surface is credentials and outbound network policy. Keeping secrets outside the guest is sound architecture, but it places their protection in infrastructure that Firecracker does not provide. SPACE’s testing makes this distinction concrete. Before fixes, agents bypassed egress policy in a large share of partial-network runs, while zero of 108 VM-to-host escape attempts succeeded across nine frontier models. After fixes, the egress bypass count dropped to zero.
Those results describe two different boundaries under attack. The VM-to-host boundary held in the tested attempts, while the outbound policy layer required independent hardening. Network-layer credential injection, an outbound policy proxy, and short-lived workload identities belong to the surrounding infrastructure. They cannot be inferred from the presence of a microVM.
DigitalOcean MicroVMs, in public preview in October 2026, names per-tenant MCP servers running in their own VM as a use case. That separation prevents one tenant from reaching another tenant’s tools through the shared execution environment. It does not define where those servers may connect. Their egress policy remains a distinct control, just as it does for an agent that makes network requests directly.
The third surface is the persistent storage that frameworks use. Agent frameworks define isolation units for each session, but those units do not keep physical storage separate by default. A framework can still share a persistent volume across tenants whose code runs in correctly separated VMs. A guest filesystem of its own protects the guest’s state, but shared storage attached or accessed above the VM layer does not get that protection automatically.

How the prompt injection layer sits entirely outside every sandbox tier
A poisoned code comment, malicious file, or adversarial tool response can put instructions in the agent’s context window. The agent may then act on those instructions using permissions its sandbox already allows. No kernel escape is required for this attack. The untrusted input is meaningful to the model and arrives through the same context channel as legitimate instructions.
A sandbox limits what the redirected agent can do, but it does not prevent the redirection itself. Moving from a process sandbox to a full VM therefore cannot solve this class of threat. Input validation, tool call allowlists, output auditing, and restrictions on external content address what the agent may read and do. These are policy controls whose effectiveness depends on defining permitted behavior.
That distinction prevents a false architectural conclusion. Even after host, egress, and storage gaps are closed, a malicious instruction can still reach the model. Firecracker can constrain the resulting actions within the guest and its allowed interfaces. It cannot tell legitimate intent from hostile instructions inside the context window.
What the production architecture looks like when developers account for all four surfaces
In production, agent infrastructure uses the VM as the unit it deploys, with separate controls around its interfaces. Lambda MicroVMs launches a dedicated hardware-isolated VM from a snapshot for each user, session, or job. DigitalOcean places a tenant’s tools and MCP servers in their own VM, while Google’s system gives each agent a separate kernel, root access, and persistent disk. The allocation unit varies with the workload. The shared principle is that unrelated tenants do not depend on a shared guest kernel for execution.
Credentials then control what the agent can access beyond that guest. SPACE keeps credentials in a store that has hierarchical scoping, rate limits, and audit logging. It injects credentials at the network layer or uses browser-agent autofill. Secrets are not part of the guest environment. The broader pattern uses a short-lived workload identity per agent instead of shared API keys, separating the agent’s authority from the code it executes.
SPACE’s per-sandbox network gateway applies the configured policy to every outbound connection from the VM. Its post-fix testing demonstrates why that gateway must be evaluated separately from VM escape resistance. Storage separation requires the same architectural discipline. Per-tenant execution only produces per-tenant state isolation when the persistent storage layout preserves that boundary, rather than reconnecting tenants through a shared volume.
Above those infrastructure controls, input and tool policies constrain the agent’s interactions with untrusted content. Microsoft Execution Containers, launched at Build 2026 with OpenAI and NVIDIA as ecosystem partners, approaches containment through a unified configuration schema spanning process sandboxes through full VMs. It recognizes that one system can require different containment tiers. Those tiers still leave context-level attacks to controls above the sandbox, because changing the backend does not change how instructions enter the model.
Snapshot scheduling makes this layered design economically practical for persistent agents. Lambda MicroVMs stops compute billing after a configurable idle window and preserves memory in a snapshot. AWS Bedrock AgentCore Runtime uses the same consumption-billing pattern. Waiting agents need not remain active compute workloads. Per-user VMs can therefore serve as persistent deployment units, while credential, network, storage, and input controls remain distinct layers of the architecture.
The complete architecture is a stack, with Firecracker at the bottom.
How should developers choose isolation tiers for an agent platform?
The decision starts with the surface being defended. For cross-tenant kernel isolation, the appropriate layer is a Firecracker microVM or an equivalent hardware-virtualized primitive. Shared-kernel containers do not provide that property for multi-tenant agent workloads. Process containment and dedicated kernels are not interchangeable guarantees. Host exposure then requires a separate decision about patch cadence and hardening, because the guest boundary supplies neither.
For credentials and egress, the lesson is to design secrets out of the guest and enforce policy through infrastructure. Outbound controls need explicit testing against attempted bypasses. SPACE’s pre-fix results show why tests for escapes alone are not enough. A platform can block VM-to-host attacks and still allow network access that its policy forbids. Evaluating these controls separately makes it possible to identify which boundary failed instead of treating every failure as a sandbox problem.
Developers should check whether their frameworks share persistent volumes across tenants or other units that are meant to be isolated. Session names do not establish physical storage separation. Testing for prompt injection calls for a different set of checks, on input validation, permitted tool calls, and output auditing. No choice among sandbox tiers substitutes for those controls.
Cost estimates should account for suspension, since a dedicated VM need not run all the time. For most agent workloads, the idle time between active tasks makes up most of the cost. Agents that wake from snapshots in under a second can function as persistent per-user infrastructure. Idle cost becomes a storage question. Platforms that use snapshot scheduling can charge for storage during suspension and release compute while the agent waits.
Managed infrastructure handles the VM layer, but leaves developers responsible for the credential architecture, egress enforcement, storage separation, and agent-level policies above it. Teams building directly on Firecracker also own the host boundary and surrounding infrastructure. SPACE release 0.8.0 provides a production-tested, Apache 2.0 implementation that can be self-hosted on Linux x86_64 with KVM. It illustrates the scope of the implementation rather than changing the division of responsibilities. Any platform, managed or self-built, can be evaluated by checking how its layers defend each attack surface.
Firecracker is the floor of that stack.


