Serverless Wrappers Versus Real Guest Kernels What Agent Isolation Claims Actually Deliver at Runtime

Guest kernels stop kernel exploits from crossing to neighbors.

· 8 min read
Cover illustration for “Serverless Wrappers Versus Real Guest Kernels What Agent Isolation Claims Actually Deliver at Runtime”
Agent Isolation · November 7, 2026 · 8 min read · 1,840 words

Firecracker micro-VM isolation for AI agents gives each guest its own Linux kernel behind a hardware-virtualized boundary, rather than exposing the host kernel through container namespaces. A kernel exploit compromises one agent’s guest in a microVM but can reach shared infrastructure in a container. Snapshot-restore makes this boundary practical for per-user agents, but it does not prevent prompt injection, data exfiltration, or misuse of credentials available inside the guest.

Why "isolated" means two different things at the kernel level

A container is a process on the host with a modified view of the system. Namespaces change what that process sees, but its system calls still reach the host kernel. A vulnerability in that shared kernel can thus cross a container boundary even when the namespace mechanism itself holds.

A microVM instead runs a guest Linux kernel inside a hardware-virtualized boundary managed by a virtual machine monitor, or VMM. Guest processes send their system calls to that guest kernel. The guest communicates across the host-guest boundary through the VMM and hardware virtualization. A kernel exploit within the guest therefore compromises the guest kernel.

Between ordinary containers and microVMs sits userspace syscall interception, which uses an application kernel to reduce the host syscall surface. This is a stronger separation than namespaces alone, with an application kernel that still runs on the host. The key distinction is ownership of the kernel that processes the workload’s system calls. In a container, kernel code is shared infrastructure. In a microVM, kernel code is per-tenant property.

Why the shared-kernel assumption is breaking down in 2026

The shared-kernel risk is not limited to containers deployed with excessive privileges or incorrect settings. The 2026 vulnerability families Copy Fail and Dirty Frag granted root to unprivileged local users and crossed container boundaries through the shared kernel. Neither required a container misconfiguration. Their significance is structural, because a correctly configured namespace cannot contain privilege escalation in the kernel enforcing it.

Two organizations reached the same AF_UNIX use-after-free and reported it to the kernel security list on the same day, illustrating how independent discovery can converge on the same exploitable weakness. One 2026 patch introduced another exploitable bug. Patching is still needed, but when tenants share a kernel, keeping them separate depends on patching that kernel before an attacker can exploit it.

A microVM changes the consequence of losing that race. Exploiting a guest kernel does not, by itself, cross the hardware virtualization boundary into the host or neighboring guests. That does not remove the need for patches. The distinction becomes especially important when the workload is expected to execute untrusted or LLM-generated code.

Why agent workloads make the shared-kernel problem worse than ordinary serverless

A long-running coding or tool-using agent behaves differently from an ordinary serverless function. It installs packages, starts daemons, opens persistent network connections, writes credentials to disk, and may execute code it generated itself. To do these things, the application needs a substantial operating-system environment beneath it. The execution surface expands with the agent’s work. LLM-generated code is untrusted code, so placing it in a plain container leaves shared infrastructure one kernel exploit away.

Prompt injection can turn that execution surface into an attacker-directed path. An injected instruction may lead the agent to probe the filesystem, read environment variables, or make system calls. The model manipulation can make the agent exercise the infrastructure boundary on an attacker’s behalf. When tenants share a kernel, those calls reach the same kernel that serves neighboring tenants.

Accidental behavior creates a related containment problem. An agent loop can spin, a subprocess can leak file descriptors, and installing a dependency can fill the disk. Containers account for these demands through a shared kernel, while a microVM bounds the workload within the guest’s allocated resources. A coding agent working for hours also needs a real init system and kernel, making a full guest a closer fit than a container borrowing the host environment.

What Firecracker's minimalism actually buys at the host-guest interface

Firecracker reduces the code a guest can reach by emulating very little hardware. Its five emulated devices include a virtio network device, a virtio block device, and a serial console. A traditional VM instead presents a fuller emulated PC, with components such as BIOS, a PCI bus, USB, graphics, and sound. Each emulated interface adds code between the guest and the host. Firecracker’s roughly 100,000 lines of Rust reflect a choice to keep that interface small, and memory safety limits the kinds of VMM bugs attackers can use.

Each microVM has its own VMM process on the host. A compromise of that process therefore does not automatically become a compromise of a VMM serving neighboring guests. The architecture limits what a single failure directly reaches.

gVisor takes a different approach at this interface. Its Sentry application kernel, written in Go, intercepts system calls in userspace and reduces the host kernel surface exposed to a workload. Sentry nevertheless executes on the host, whereas Firecracker keeps the host kernel out of the guest process’s syscall path. Escaping the latter requires crossing the virtualization boundary rather than merely exploiting the guest’s syscall implementation. That stronger separation still has to meet interactive latency and cost requirements.

How snapshot-restore answers the latency and idle-cost objection

Snapshot-restore avoids repeatedly paying the cost of booting and preparing a guest. At suspension, it serializes the guest’s full memory and CPU state. Restore maps that state back into memory and resumes execution from the suspended point, with restores possible in milliseconds. Copy-on-write sharing also lets microVMs restored from the same image share read-only memory pages until a guest writes to them.

A human-in-the-loop task may pause for seconds or hours, during which an always-running guest would consume compute despite doing no useful work. A snapshot-and-restore scheduler can suspend it, release compute, and retain the state needed to continue. Idle agents pay for storage. For a fleet of thousands of agents, the compute bill can therefore track active concurrency.

Aquifer’s snapshot research found that the vast majority of snapshot pages are either zero or cold. Its hotness-based format eliminates zero pages, prepares the hot working set before resume, and demand-pages cold pages asynchronously. The research, still at the research stage, places hot pages in a low-latency CXL pool and cold pages in a cluster-wide RDMA pool, achieving a 2.2× geometric-mean speedup in end-to-end invocation time over baseline Firecracker restore. It shows that restore can get faster, while production services already use suspension and restoration to cut the compute used by idle agents.

How AWS and Google have productized the microVM boundary for agents

AWS Lambda MicroVMs launched June 22, 2026, with an isolated Firecracker VM for each user or session and state that persists for an extended period. The service boots from a snapshot in seconds without users having to manage the infrastructure. At launch, it was available in five regions, including us-east-1, us-east-2, us-west-2, eu-west-1, and ap-northeast-1. In June 2026, the service added support for an interactive shell through CreateMicrovmShellAuthToken. Its exposed environment is a full VM.

AWS AgentCore Runtime provides a more managed environment inside the boundary. Its availability covered 21 commercial regions plus GovCloud US-West, but not GovCloud US-East, as of the source update. In June 2026, it added support for an interactive shell through InvokeAgentRuntimeCommandShell. Shell access does not imply unrestricted OS control. Direct /dev/ptmx access, a Docker daemon inside the guest, and low-level network stack manipulation are outside its managed model and belong in Lambda MicroVMs instead.

Google Agent Compute Engine was announced October 22, 2026, productizing the internal platform running Gemini’s agentic workloads for Google Cloud customers. Each agent runs in a hardware-isolated microVM, with application-aware checkpointing and fast restore preserving files and memory while idle compute is released. It also shares memory copy-on-write across microVMs built from the same image. Pricing was not published as of the source date.

Vercel Sandbox reached general availability January 30, 2026, with a dedicated kernel inside a Firecracker microVM for each sandbox. CPU billing covers only the time spent running code and leaves out time spent waiting on a model. Its credential broker injects credentials into outgoing traffic so secrets never enter the sandbox. Across these four independently designed systems, the convergence is one Firecracker microVM per session. The developer’s choice then turns on what the platform permits inside that boundary and what protections exist outside it.

What the isolation boundary determines at runtime — and what it cannot prevent

A microVM is a kernel escape barrier. A guest-kernel exploit reaches that guest’s kernel, while a runaway process stays within the CPU, memory, and disk resources given to the guest. If prompt injection causes arbitrary shell execution, those commands run against the guest filesystem and network stack. The hardware boundary limits their direct reach. Crossing into the host requires a separate failure at the virtualization boundary.

Data exfiltration through the guest’s network interface follows an allowed network path, and the microVM does not inspect the meaning of that traffic. The model also lives outside the guest, so manipulation of its reasoning happens before generated code reaches the sandbox. Secrets intentionally placed in the guest remain available there. Vercel’s credential-brokering design addresses that exposure by keeping secrets outside the guest entirely.

The comparison with gVisor is therefore about both containment and workload fit. It reduces the host syscall surface and integrates more easily with existing Kubernetes tooling, but lower application compatibility and higher per-syscall overhead can affect syscall-heavy agents installing packages and running subprocesses. A dedicated kernel avoids that compatibility tradeoff, but the agent’s logic can still be untrustworthy. Platform evaluation must distinguish these separate properties rather than treating “isolated” as a complete security guarantee.

How do you evaluate an isolation claim from a platform at runtime

Evaluation must first establish whether each tenant’s code runs against its own kernel or shares the host kernel. A useful answer names the runtime architecture. Firecracker, Cloud Hypervisor, and QEMU microvm identify hardware-virtualized approaches, while Kata Containers supplies a hardware-virtualized container model. Docker or Kubernetes without a Kata or gVisor runtime provides namespace isolation against a shared kernel. The platform’s marketing term may be identical in either case.

One VMM process per microVM preserves a process-level separation that a shared VMM collapses. The evaluation must then establish what the agent can do inside the guest. A managed container within a microVM, as in AgentCore, restricts OS-level operations. A full VM, as in Lambda MicroVMs, permits a Docker daemon, network-stack manipulation, and /dev/ptmx access. These are different operating environments behind a hardware boundary.

For agent-native products, the recommended primitive is one isolated VM per user or tenant, with that tenant’s identity injected at runtime. This fits untrusted code, customer workloads sharing a host, and agents that require a whole OS. Snapshot-restore supplies the economic condition for using it at fleet scale. The platform must pair the dedicated guest kernel with suspension that releases idle compute and restoration that preserves working state. An isolation claim is useful only when it identifies that boundary, its tenant scope, and the capabilities the agent retains within it.

Sources

  1. Aquifer: Hierarchical Memory Pooling with CXL and RDMA for MicroVM Snapshots
Filed underAgent Isolation

More in Agent Isolation