Why the Host Kernel Is Your Biggest Agent Security Liability and How Micro-VMs Fix It

Separate guest kernels stop LLM-generated code from reaching your host infrastructure.

· 8 min read
Cover illustration for “Why the Host Kernel Is Your Biggest Agent Security Liability and How Micro-VMs Fix It”
Agent Isolation · October 29, 2026 · 8 min read · 1,904 words

Firecracker micro-VM isolation for AI agents replaces a shared host kernel with a separate guest kernel for each workload. For agents executing arbitrary, autonomously generated code, that architectural boundary is stronger than container hardening because a guest-kernel compromise does not itself compromise the host. Micro-VMs sever the direct shared-kernel exploit path, while patching, state isolation, and monitoring address the risks that remain.

Why agents executing autonomous code face a categorically different threat than containerized applications

Langflow CVE-2025-3248 exposed the consequence of executing code without a security boundary. Its /api/v1/validate/code endpoint accepted a Python code string and passed it to exec() without authentication or sandboxing. With a single HTTP request, an attacker could use reverse shells, file exfiltration, and lateral movement. The vulnerability received a CVSS score of 9.8. CISA added it to the Known Exploited Vulnerabilities catalogue on 5 May 2025.

Autonomous agents require trust in both the execution endpoint and the code they produce. Their code is produced at runtime in response to inputs that may be adversarial, then runs before a human reviews it. The code has not passed the vetting assumed for a conventional application. Johann Rehberger’s ZombAI demonstration showed Claude Computer Use downloading and executing an attacker’s binary through a hidden prompt injection on a normal-looking webpage. Earlier wget and curl attempts were blocked, but the final approach succeeded.

Generated code can attempt to read .env files and SSH keys, write outside its assigned directories, or contact arbitrary domains for instructions and exfiltration. Code can also reach secrets through environment variables and /proc. In multi-tenant deployments, the code can target other users’ data too. These are execution threats.

How the shared host kernel turns every container escape into a host compromise

Docker isolates workloads through Linux namespaces, cgroups, and capabilities. Those mechanisms restrict what a process can see and do, but every container on the host still shares the same Linux kernel. A vulnerability reachable through that kernel can undermine the boundary protecting every tenant that depends on it. Hardening narrows access to the shared boundary without replacing it.

A successful container escape, classified as MITRE ATT&CK T1611, reaches beyond the container into the host. November 2025 brought three runc vulnerabilities, CVE-2025-31133, CVE-2025-52565, and CVE-2025-52881, affecting Docker, Kubernetes, containerd, and CRI-O simultaneously. For autonomous execution, that common dependency is especially consequential because the workload itself can produce hostile system actions. A Docker-only boundary cannot contain a successful host compromise.

This is the central liability of sharing a kernel. Filesystem restrictions and reduced capabilities can obstruct particular attacks, but they do not give each workload an independent kernel boundary. Once an escape defeats the container boundary, the architecture provides no separate guest kernel between the attacker and the host. The blast radius is therefore not confined to the agent that initiated the attack.

What runtime isolation options exist for untrusted AI agents in production

The isolation spectrum is a decision framework based on which boundary receives untrusted operations. Level 1 consists of OCI containers such as Docker and Podman, using namespaces and cgroups over a shared kernel. They are fast and lightweight. For internally written code that passed CI/CD, they are probably adequate. They are not an adequate standalone boundary for arbitrary LLM-generated execution.

Level 2 introduces user-space kernels such as gVisor. A user-space application intercepts and reimplements syscalls, so the sandboxed program does not talk directly to the real kernel. This provides stronger separation than containers with less overhead than a full VM. Compatibility is the corresponding cost. Incomplete syscall emulation can prevent some Linux software from working.

Level 3 consists of micro-VMs, including Firecracker, Kata Containers, and libkrun. Each workload receives its own kernel through KVM hardware virtualization, so compromising that guest kernel does not itself reach the host or neighboring VMs. Level 5, confidential computing, adds hardware-encrypted memory isolation through AMD SEV-SNP or Intel TDX. Its distinct purpose is protection from host and hypervisor access to sandbox data. That protection matters for regulated workloads that use PII, financial data, or healthcare records.

George Andronchik and Pavel Lokhmakov’s comparative study separates micro-VM, user-space-kernel, and OCI-container classes across its architectural measurements. The choice is therefore more than product preference. For bounded LLM-generated tasks, gVisor or micro-VMs provide the required stronger boundary. For arbitrary uploaded binaries or autonomously installed PyPI packages, the defensible assumption is hostile code, requiring hardware virtualization.

Diagram: The Isolation Spectrum: Four Levels of Agent Execution Boundaries. Visualizes: Visualize a ranked progression of four isolation levels for untrusted AI agent code, showing how the security boundary strengthens at each step.

How Firecracker severs the host kernel path through deliberate subtraction

Firecracker removes the workload’s direct dependence on the host kernel by placing a guest kernel behind KVM hardware virtualization. Isolation of the guest from host memory and other VMs changes what a kernel exploit achieves. Root inside the guest remains authority over that guest alone. To get beyond the guest, an attacker must also escape through the virtualization boundary.

Firecracker then reduces the surface exposed at that boundary. Its minimal Rust virtual machine monitor, or VMM, has five device surfaces. Per-thread seccomp filters block unnecessary syscalls from the VMM itself. Cgroups and namespaces restrict resources on the host. These familiar mechanisms become additional containment around a hardware boundary, rather than the sole barrier protecting the host kernel.

The jailer drops privileges and executes Firecracker without root authority. Its restricted chroot has no network access and no view of other host processes, with syscall access restricted to approximately 30–36 calls and per-thread filters ranging from approximately 24 for vCPU threads to approximately 50 for the VMM thread. Even after a VMM escape, an attacker still faces the restrictions on the host.

What Firecracker's CVE history actually shows about micro-VM risk versus container risk

Firecracker has vulnerabilities, including ones involving host-side components. Its public history includes five historical CVEs, while a 2026 cluster includes CVE-2026-5747, an out-of-bounds write in virtio-pci, and CVE-2026-1386, a jailer symlink host-write vulnerability. NVD describes the latter as allowing a local host user to overwrite arbitrary host files through a symlink attack during initialization copying at jailer startup. Guest containment does not excuse host-component patching.

The comparative study places that history against thousands of Linux-kernel CVEs in the same window, orders of magnitude more than all five hypervisor engines combined. Counts alone do not establish exploitability or safety. The study also finds that the strongest measured fuzzing combination, a micro-VM with a continuous public fuzzer, is unoccupied among the products assessed. An engine with no published CVEs, no upstream fuzzer, and no academic study remains structurally unmeasured.

Patch cadence is the sharper operational distinction. The study finds that, for operators, the biggest factor is how downstream products pin versions, even when engine-side fixes come out with coordinated disclosures. A guest-kernel compromise stays inside a micro-VM, while a virtualization or jailer vulnerability needs to be judged by the separate boundary it attacks. Micro-VMs reduce shared-kernel exposure, but they still need maintenance.

The multi-tenant forcing function: why per-user kernel isolation is not optional at scale

Multi-tenant platforms turn containment into a contractual requirement. One user’s agent must not be able to read another user’s data, and namespace separation cannot guarantee that against a successful shared-kernel exploit. That trust model may be enough for low-risk workloads. When autonomous execution must meet compliance rules, it cannot put neighboring tenants at risk. A separate kernel per tenant makes the execution boundary match the required containment boundary.

Persistent state needs an equally explicit boundary. LangGraph’s cluster of vulnerabilities shows why execution isolation cannot take the place of storage isolation. Its official advisories identify CVE-2026-27794 as BaseCache deserialization that may lead to remote code execution and CVE-2026-27022 as RediSearch query injection in its Redis checkpoint package. Another advisory identifies CVE-2026-28277 as unsafe msgpack deserialization during checkpoint loading.

The hardware boundary confines a guest-kernel compromise, but it does not establish who may read shared checkpoints or whether stored data is safe to deserialize. Persistence is part of the security architecture. For stateful agents, tenant separation must survive sleep, restoration, and subsequent sessions, even after a process stops.

The operational trade-offs developers actually encounter when adopting micro-VMs

Moving from Docker to Firecracker creates real networking work. Docker provides mature CNI plugins, while Firecracker requires manual management of TAP interfaces, IP tables, and host routing. Observability also becomes less convenient. Developers lose the immediate access that docker exec and docker logs give them and need the VM’s serial console, kernel logs through virtio-serial, or SSH into the guest.

The performance comparison is more favorable to micro-VMs. Firecracker boots in under 125ms with under 5MiB of memory overhead and achieves CPU performance very close to bare-metal. It can also create micro-VMs at high density per second per host. Agent inference commonly takes seconds. Against that timescale, the startup cost is not a persuasive reason to retain shared-kernel execution.

When an agent waits, its harness snapshots the full execution state to durable storage and terminates the process, reducing compute consumption to zero. An arriving signal triggers restoration from that snapshot. Most agents are idle most of the time. A persistent per-user VM therefore incurs storage cost while idle, in place of the compute cost of a VM that runs all the time.

What kernel-level syscall evidence adds to agent security monitoring that application telemetry misses

Application telemetry describes prompts, messages, and exposed tools, but not every action that follows from them. Spencer King and colleagues at the University of Georgia and Amazon Web Services examine this gap in On the Effectiveness of Kernel-Level Evidence for Agent Security. Their Agent Cross-Layer Evidence corpus has 4,047 paired sessions that cover 17 threat models, six delivery-vector families, and 14 of the 25 OWASP LLM and agentic threat categories. Some attacks bypass the application evidence boundary. Syscall traces expose mechanics that application telemetry alone misses.

The study finds kernel evidence discriminative on its own. Combining it with application evidence generally outperforms either single-layer view, and the corpus demonstrates generalization to unseen attack families. Model messages provide context that syscalls do not, while kernel traces record system actions that messages may conceal.

Per-agent micro-VMs give that evidence a clean attribution boundary. Each agent has its own kernel and tenant, so its syscall traces are separate from the kernel stream of neighboring workloads. Shared kernels can still provide syscall evidence. Separate kernels keep signals from different tenants apart, so spotting anomalous behavior does not require filtering out noise from other tenants’ workloads.

What building on micro-VM infrastructure looks like in practice for agent-native products

An enterprise agent is a stateful workflow system. Its durable state includes conversation history, tool outputs, approval status, failure context, and retry logic. Resumption must not repeat dangerous work. That requirement connects persistence directly to isolation because one agent’s workflow state must also remain unreadable to another. A per-user VM with its own persistent disk and kernel aligns those requirements.

The infrastructure must keep files, credentials, and installed packages through sleep and redeploy. A real guest kernel lets the agent install software, open browser sessions, and run arbitrary code behind the hardware boundary. Sub-second snapshot wake latency preserves responsiveness. Storage-only billing during idle then makes persistence viable at fleet scale, rather than charging continuously for inactive agents.

These primitives define the production unit as a persistent, isolated agent that can stop consuming compute without losing its place. Operators still have to handle networking, deliver patches, protect state, and monitor across layers. Container hardening alone cannot supply that unit’s independent kernel. Micro-VM infrastructure makes the execution boundary an architectural property of the product rather than a trust assumption about whatever code the model produces next.

Sources

  1. On the Effectiveness of Kernel-Level Evidence for Agent Security
  2. AI Code Sandboxes: A Comparative Security Study. Part 1 of 2 -- Engine-Level Properties (Attack Surface, Leakage, Stackability, CVE History, Patch Cadence, Fuzzing)
Filed underAgent Isolation

More in Agent Isolation