Runtime Isolation Depth Benchmarks for Agent Execution Platforms Below the Syscall Layer
Containers, gVisor, and Firecracker differ most in how much kernel an agent shares.

Firecracker micro-VM isolation for AI agents gives each workload its own kernel behind a hardware-virtualized boundary, rather than sharing the host kernel through containers. What counts is what an agent can reach, corrupt, or escape once it is running.
Why cold-start figures are the wrong benchmark for agent execution platforms
Startup latency describes the boot path. A fast sandbox can still expose the host kernel to the agent’s system calls. Speed answers a different question from containment.
How far a compromise can spread depends on how much of the kernel workloads share, which host devices they can reach, the paths between workloads’ memory, and the routes for privilege escalation. None appears in a cold-start figure. Startup latency belongs in a performance comparison, but it cannot stand in for a security comparison.
What "below the syscall layer" means and why it is the right level of analysis
A syscall is where a program asks the operating system kernel to do work. The isolation architecture determines which implementation receives that request and what stands between it and the host. That is the key dividing line here. “Below the syscall layer” means examining the kernel, memory, device, and privilege boundaries beneath the interface the agent’s code uses.
With runc, the container runtime used by Docker, Linux namespaces and cgroups separate processes and control resources, but workloads share the host kernel. There is no separate kernel to contain a kernel compromise. gVisor instead intercepts and re-implements syscalls in a user-space application, keeping sandboxed programs from calling the host kernel directly. This adds protection but can cause compatibility gaps where it does not fully emulate Linux behavior.
Firecracker and Kata Containers occupy the hardware-virtualized tier. Each workload gets a separate kernel behind KVM hardware virtualization, so exploiting that kernel does not by itself cross into the host. The distinction becomes concrete when an agent installs packages, manipulates file descriptors, or opens arbitrary network sockets. Those actions exercise an operating system.
Why behavioral containment at the model layer cannot substitute for hardware isolation
The ZombAIs case shows why a better system prompt is not a runtime boundary. During a normal browsing task, Claude found a page with hidden prompt injection, downloaded and ran a binary, and connected to an attacker’s command-and-control server. The attack worked on the first try. The failure reached beyond the model’s answer into the environment where its actions ran.
A page or document can supply the hostile instructions while the user asks for legitimate work. Once the agent follows them, containment depends on which permissions and resources the runtime makes available. An isolated environment limits the reach of executed code even when the model has already made the wrong decision.
The OWASP Top 10 for LLM Applications names the related risk Excessive Agency, designated LLM06:2025. It concerns functionality, permissions, or autonomy beyond what a task needs. Behavioral controls can guide an agent, but they cannot create a kernel or memory boundary. Security depends on what the runtime prevents after guidance fails.
What runtime isolation options exist for running untrusted AI agents in production?
runc blocks filesystem and process namespace collisions through namespaces and cgroups. It does not put a separate kernel between workloads. A vulnerability in the shared host kernel therefore remains a route out of the container boundary. Strictly configured containers are suited to trusted, internally written code that has passed CI/CD and unsuited to external or LLM-generated code.
gVisor blocks direct access to the host’s syscall implementation through its user-space kernel, the Sentry. Vulnerabilities in syscall emulation remain possible, while incomplete emulation can break software that depends on particular Linux behavior. This offers stronger containment than runc without the same operational complexity as a full microVM fleet.
Firecracker blocks a guest kernel compromise from crossing VM boundaries through hardware virtualization, with memory and device access mediated by the hypervisor. Each workload has its own kernel and memory space. Security still depends on the hypervisor and on settings that expose host paths or devices. Firecracker reduces that surface by omitting BIOS, PCI, and USB support.
Kata provides another route to dedicated kernels in the hardware-virtualized tier. AWS built Firecracker for Lambda and Fargate, grounding this design in services that execute untrusted workloads. Even where boot times overlap, runc and Firecracker expose fundamentally different kernel surfaces.

What the production coding-agent landscape reveals about how isolation choices are actually made
It found a wide spread of isolation choices. Organizational investment, rather than technical constraint alone, shaped that spread.
The study identified OpenAI Codex as the strongest sandboxing investment in its corpus. On Linux, Codex uses Bubblewrap namespace isolation with --ro-bind, --unshare-net, --unshare-user, and --unshare-pid, with Landlock a legacy fallback as of mid-2026. Some other systems had no OS-level isolation at all. A technology’s name therefore tells less than how it is set up, which syscalls it allows, and which host resources it can reach.
There is also a separate deployment boundary. Isolating code execution does not isolate the environment where an agent’s changes are deployed, and a shared deployment path can let a broken change reach production. Production isolation spans five boundaries, namely compute, filesystem, network, identity, and data. A compute sandbox alone does not establish the other four.
How Firecracker snapshots change the economics of per-task isolation without weakening the security boundary
Firecracker can save a running VM’s memory contents, CPU registers, and device state to disk. On restore, it memory-maps the snapshot file, loads CPU state, and resumes execution where the VM stopped. This avoids repeating a cold kernel start.
The restored machine still has its own kernel, memory space, and hardware-enforced separation from the host. Copy-on-write cloning lets sessions that run at the same time start from the same warm snapshot without each paying the full memory cost. That mechanism makes per-task microVMs more practical for parallel agents and evaluations.
Snapshotting still has operational and security limits. Diff snapshots remain a developer preview, while full snapshots are the stable path. Hibernating a VM therefore writes its full memory footprint regardless of how much changed, a constraint for memory-heavy workloads. Research in 2026 also addresses semantic rollback attacks, time-of-check/time-of-use vulnerabilities in checkpoint and restore, and transactional semantics for agent tool calls.
Running evals and RL rollouts at scale: why isolation depth compounds with concurrency
Parallel evaluations need independent environments. SCALECUA’s online RL stage runs hundreds of VM environments concurrently per training batch. If one environment can see or change another’s state, the training signal no longer comes from independent runs. Isolation becomes a condition of result validity.
Per-task microVMs give each rollout a clean kernel state and a separate memory and filesystem environment. This contains guest-level crashes and misbehavior more deeply than a shared-kernel container. Hardware isolation does not, however, replace controls over resource use or agent failure. A documented two-agent loop used up a large share of the budget over eleven days despite running dashboards, and a review afterward found that isolation budgets, rollback triggers, and per-agent failure accounting were missing.
The Holistic Agent Leaderboard ran tens of thousands of rollouts across multiple models and benchmarks. At that scale, contamination can turn into costly reruns. So any money that weaker isolation seems to save must be weighed against the cost of results that cannot be trusted. Warm-snapshot cloning addresses the startup and memory side of that tradeoff without reverting to a shared kernel.
Computer-use agents on Windows, Android, and legacy desktop software add OS-surface isolation requirements that the syscall framing alone does not cover
Desktop agents make the same isolation question broader. Their operating environment includes a code runner, a desktop session, credentials, applications, and network context. The agent-per-desktop pattern gives each agent a desktop from a pre-built snapshot, already signed in and on the right screen. Its credential context is confined to that session.
The operating system changes the exposed surface. Linux desktops can use the microVM boundary already described, while Windows isolation must cover the Win32 subsystem and legacy applications such as EHR or loan origination software. Android adds applications that run only on phones and the context of their sessions. In each case, the question includes whether one agent can reach the host’s network identity or another session.
Citrix’s published architecture as of September 2026 gives each agent a DaaS session presented to the human worker through HDX and seamless windows. That is a session boundary, with different properties from a microVM boundary. AWS launched a public preview on 5 May 2026 for agents operating their own Amazon WorkSpaces desktops to automate legacy applications without APIs. These approaches extend the isolation discussion to the full desktop, where regulated workflows also require actions attributable to a specific agent session.
What isolation depth means for HIPAA, compliance, and regulated-industry deployments
HIPAA’s Security Rule obligations apply to agent workloads that touch ePHI just as they apply to other processes handling that data. Isolation architecture is therefore an input to compliance. It is not certification by itself.
Shared-kernel containers leave cross-tenant exposure possible under kernel-exploit conditions, weakening the case for multi-tenant agent infrastructure handling sensitive data. gVisor narrows direct host-kernel access, but its emulation layer still belongs in the risk analysis. Firecracker and Kata provide hardware-enforced memory separation between sessions, a stronger foundation for compliance.
Clicks, navigation, and form fills must be recorded and attributable to a specific session, which favors an isolated session as the unit of accountability. Regulated teams must also track changes to HIPAA’s Security Rule addressing agentic AI. Regulation (EU) 2026/1744 moved the deadline for standalone high-risk systems under the EU AI Act to 2 December 2027. Colorado’s replacement Automated Decision-Making Technology Act takes effect in January 2027, so teams have another set of rules to meet alongside isolation.
Matching isolation primitive to agent pattern: a decision framework for builders
For builders, the decision starts with code trust, runtime duration, and operating-system surface. Trusted, internally written, short-lived code can use runc with strict namespace and cgroup configuration. That advice ends when the code comes from outside or is LLM-generated. The source of the code changes the threat model.
For ephemeral LLM-generated tasks, gVisor offers a meaningful containment step above containers, subject to syscall compatibility. Firecracker offers the deeper hardware boundary where its constraints fit the workload. User-supplied or adversarial code calls for hardware-virtualized microVMs, whether Firecracker or Kata. Shared-kernel separation is not the appropriate floor for that case.
Long-running autonomous agents call for persistent microVMs with snapshot-resume so state survives without paying idle compute costs. Computer-use agents need per-session isolation across the full OS surface, with session-level audit logging for regulated workflows. Parallel evals and RL rollouts call for per-task microVMs and warm-snapshot cloning.
The final test is what a compromised agent could reach from inside its environment. Boot time cannot answer that question.


