Process Isolation vs VM Isolation for Autonomous Browser Agents

Hardware-enforced VM isolation is now essential for multi-tenant browser agent security.

· 11 min read
Cover illustration for “Process Isolation vs VM Isolation for Autonomous Browser Agents”
Sandbox & Runtime · October 10, 2026 · 11 min read · 2,426 words

Autonomous browser agents face a threat surface that traditional sandboxing was never built to stop, because the agent combines arbitrary code execution, live authenticated sessions, and direct exposure to untrusted web content, all inside one process. This piece argues that process isolation, no matter how carefully configured, fails at the exact layer where the agent-specific threats actually land, and that hardware-enforced VM isolation has moved from a nice-to-have to an architectural requirement for anyone running these systems at scale.

Browser Agent Threat Surface vs. Traditional Sandboxing

Browser sandboxing, as it was conceived for human users, solves a specific and well-understood problem: keep malicious JavaScript trapped inside the renderer so it can never reach the host operating system. It's a lateral escape problem, and decades of engineering at major browser vendors have gone into closing it. Autonomous agents inherit all of that same lateral risk: they still run a renderer, still parse untrusted HTML, and still face the possibility that a hostile page tries to break out toward the OS. But agents add something the original model never had to account for: a vertical dimension, where prompt injection at the semantic layer redirects what the agent does next without touching the OS boundary. Multiple production cases now document this pattern, and the common thread is that the attacker never needs an exploit, just language the agent will read and obey. The result is a compound threat surface with three distinct tiers: infrastructure (kernel exploits, container escapes), application (browser sandbox bypass), and semantic (prompt injection). No single isolation primitive closes all three at once, so the rest of this piece works through each tier in turn to show where the boundaries sit.

The Five Isolation Tiers

As of May 2026, five isolation tiers are in active production use, and none of them substitute for one another. Each closes a specific slice of the attack surface and leaves the rest exposed, so understanding the boundary of each is a prerequisite for the architecture arguments that follow.

Tier 1 covers OS process sandboxes, such as Seatbelt on macOS and bubblewrap on Linux. These restrict filesystem writes and constrain which syscalls a process can make, but they do not separate kernels. A process confined by Seatbelt or bubblewrap still has to share the same kernel as everything else on the host.

Tier 2 covers user-space kernels, with gVisor as the standard example. gVisor interposes a user-space kernel between the agent's code and the host, so agent syscalls never touch the host kernel directly. It is stronger than a bare container, but weaker than hardware virtualization. It adds I/O overhead in exchange for that extra separation, but it still achieves higher host density than full hardware virtualization. That density is why it remains attractive for workloads that need more than a container but can't justify a full VM.

Tier 3 covers microVMs, with Firecracker as the reference implementation. Each guest gets a full, dedicated Linux kernel backed by KVM hardware virtualization. A kernel exploit inside a Firecracker guest can't get out of that guest's kernel. It cannot reach the host kernel because the hardware boundary makes it structurally impossible.

Tier 4 covers dev containers, the kind used for local development environments. These exist for reproducibility and filesystem scoping, not for security isolation, and they share the host kernel the same way any ordinary container does.

Tier 5 covers full virtual machines, which offer the strongest isolation of any tier but carry memory and startup overhead heavy enough to make per-agent or per-request instantiation impractical without serious snapshot-restore engineering.

But what actually matters is whether the boundary is enforced by software or by hardware. Tiers 1, 2, and 4 rely on Linux namespaces, cgroups, and user-space interposition, all software controls that run inside the same kernel they're trying to constrain. Tiers 3 and 5 push the boundary into hardware, through KVM, so the guest kernel and the host kernel are genuinely separate. That distinction is the hinge the rest of this argument turns on.

Diagram: Five Isolation Tiers: Software vs. Hardware Boundary. Visualizes: Show five isolation tiers arranged by the strength of their boundary, making the software/hardware divide the central visual axis.

Containers Fail at the Infrastructure Layer for Browser Agent Workloads

Containers still work well if the workload is trusted, single-tenant, and non-hostile, and nothing here argues otherwise. The failure mode under discussion is specific to multi-tenant browser agent fleets, where one tenant's agent session can end up sharing a kernel with another tenant's, something containers were never designed to prevent.

Linux namespaces and cgroups partition resources: process trees, network interfaces, filesystem views, CPU and memory limits. None of that touches the kernel itself. Every container on a given host still calls into the same kernel, through the same syscall table, and a vulnerability in that kernel is a vulnerability shared by every container running on top of it. A browser agent that executes arbitrary model-generated code produces a syscall profile that is larger, more dynamic, and harder to predict than a static web service, widening the exposed surface.

Hardened configurations help without closing the gap. Rootless Podman and seccomp profiles reduce the syscall surface a container can reach, but known CVEs against container runtimes have shown practical escape paths in production, making defense-in-depth necessary even with these hardened configurations in place. For a multi-tenant browser agent platform, the concrete failure looks like this: one user's agent session achieves a container escape, and from there it can read another user's filesystem, environment variables, and credentials, the exact material a browser agent accumulates over the course of an authenticated session. So practitioners who study this threat model treat that cross-tenant leakage scenario as disqualifying for container-only isolation. MicroVMs have become the standard response to that threat class, because namespace isolation alone doesn't meet the bar for compliance-sensitive multi-tenant deployment.

What Firecracker's architecture provides that closes the infrastructure gap

Firecracker closes the infrastructure gap because it gives each guest hardware-enforced kernel separation while staying fast enough to spin up per agent session, and its minimalism is a security property in its own right, not just a performance trick.

Every Firecracker microVM runs its own dedicated Linux kernel, backed by KVM. That guest's kernel holds the exploit by construction, not by policy, and tier 5 full VMs give you the same guarantee, but they carry more overhead. Firecracker gets there partly through deliberate restriction: no USB support, no GPU pass-through, and only limited PCI hot-plug (virtio PCI hot-plug is available in Developer Preview as of v1.13). Each of those omissions removes a virtual device that a full QEMU VM would otherwise expose, shrinking the trusted computing base and, with it, the number of paths an attacker could use to escape the guest.

Firecracker starts user-space code quickly, and each microVM runs with a memory overhead under 5 MiB, according to the Firecracker project's own specification. Those numbers let microVM density approach container density, the condition that makes spinning up a fresh VM per agent session economically workable. Tier 3 microVMs dedicate a full Linux kernel per guest for exactly this reason, and Maritime, a cloud infrastructure platform for persistent AI agents, has built its entire deployment model around Firecracker for the same cause: the hardware-enforced boundary is what makes per-agent isolation affordable, with each agent running in its own VM at under 5 MiB of overhead and waking from snapshot in under a second.

None of that comes free. Networking is the part of the Firecracker stack that teams consistently underestimate. Unlike Docker, which hands a working network out of the box, Firecracker requires manual setup of TAP interfaces, IP tables, and routing rules. If teams skip past this step, they tend to end up with isolation that works and connectivity that doesn't, which is the single most common reason self-managed microVM projects stall before reaching production.

Browser-Level Sandboxing at the Application Layer

Securing the infrastructure layer doesn't make the agent's web browsing safe. Browser-level sandboxing, meaning Chromium's site isolation and renderer process separation, was built to stop malicious JavaScript from crossing site boundaries. That model assumes the thing crossing the boundary is unwanted. An autonomous agent breaks that assumption at its foundation: its entire job is to read arbitrary web content and act on what it reads, making the channel between the rendered page and the agent's decision-making the product itself.

Malicious content embedded in a page, whether in a product description, a review, or a URL parameter, doesn't need to escape the renderer to do damage. It only needs to show up in whatever the agent treats as context, where the agent reads it as an instruction. Invisible prompt injections make this worse: content that a human reviewer would never see, because it's styled to be invisible on screen, sits in the DOM where the agent reads it anyway. That technique exploits no browser vulnerability. The HTML is entirely valid, and the browser renders it exactly as written.

Browser sandboxing still does real work: it stops malicious JavaScript from escaping the renderer and reaching host resources. But it was never built to stop an agent from being manipulated by the very content it's designed to read and act on. The defense an infrastructure team deploys for kernel exploits and the defense a product team needs for prompt injection are two different problems requiring two different solutions.

Prompt injection as the live threat that lands above every infrastructure boundary

Prompt injection succeeds by working entirely within the agent's intended behavior, which is what makes it resistant to infrastructure-level defenses no matter how well those defenses are built. The agent is supposed to read page content and act on it. An injection attack just supplies content designed to produce the wrong action, and the agent carries it out because it's functioning exactly as designed.

Anthropic's own internal measurements for Claude for Chrome show this: an unprotected version of the agent obeyed malicious injected commands at a non-trivial rate, and even after mitigations were applied, that rate didn't reach zero. Anthropic says prompt injection is far from a solved problem, but it also expects continued work to keep reducing the risk for high-value tasks. That combination, real progress alongside an open gap, is the honest state of the field right now.

The structural consequence for anyone building agent architecture is direct: an agent holding every one of its active authenticated sessions at once means a single successful injection against one narrow workflow can take action across every connected system the agent has credentials for. The blast radius is set by the agent's permission scope, not by any infrastructure boundary underneath it. This is why platforms built for production deployment pair VM isolation with scoped, persistent credential storage instead of leaning on the kernel boundary alone: the session-continuity problem that stateless or container-based deployments leave exposed needs its own answer.

The mitigation that works alongside isolation is scoped, purpose-built credentials issued per agent session, so a successful injection compromises one sandboxed workflow. That's the default serious production platforms now ship with. VM isolation contributes here even though it can't stop the injection itself: by giving each agent session its own kernel and its own filesystem, a microVM architecture keeps credential material from one session unreadable to another session, even when both have been compromised at the semantic layer. Isolation doesn't prevent the injection, but it keeps the injection's consequences from spreading past the session where it happened.

The Correct Layered Architecture for All Three Threat Tiers

Diagram: Three Threat Tiers, Three Distinct Defense Layers. Visualizes: Show three stacked threat tiers and the distinct defense that addresses each, making clear that no single primitive closes all three.

Defending against all three threat tiers at once, infrastructure, application, and semantic, requires treating microVM isolation as the mandatory foundation rather than an optional hardening pass layered on afterward.

At the infrastructure tier, you set the baseline at one microVM per agent session, so every tenant gets hardware-enforced kernel separation. Stack as many seccomp profiles on top of container isolation as you like, it stays structurally insufficient once the workload is multi-tenant and hostile by assumption, which a browser agent fleet is.

At the application tier, browser process isolation inside the microVM, meaning Chromium's site isolation and renderer sandboxing, still earns its place. It continues to prevent cross-site renderer escapes, and nothing in this argument suggests dropping it. It has to be understood as a second layer sitting on top of the VM boundary, not as the primary defense the whole system depends on.

At the semantic tier, the defenses are different in kind: scoped credentials issued per agent session rather than the user's own identity, input validation at the point where web content enters the agent's context, and tool-call allowlists that limit what an injected instruction could actually execute even if it succeeds. Sandboxing shrinks the blast radius of a successful injection, but the injection itself still happens.

This layered model isn't theoretical. A major cloud provider runs its serverless infrastructure on hardware-virtualized microVMs, and another vendor's sandbox product, which supports configurations up to 32 vCPUs and 64 GB of RAM on its Enterprise tier with session durations extending to 24 hours on Pro and Enterprise plans, is further evidence that hardware-virtualized, per-session isolation is now the direction the industry is actually building toward, not a proposal still being argued over in research papers. The snapshot-restore pattern ties the security case to the economic case: every agent session starts from a clean, pre-initialized microVM snapshot, so there's no persistent state left over for a compromised session to poison on the next turn. The security model and the cost model end up reinforcing each other.

Running browser agents on Maritime: what per-VM isolation looks like as managed infrastructure

Maritime implements this per-agent microVM architecture as managed infrastructure, so a browser agent team gets the hardware-enforced isolation this piece has been arguing for without having to build and operate the Firecracker stack in-house. Each agent on Maritime runs inside its own isolated Firecracker microVM on bare metal, the same kernel-level separation described above, but you get it as a managed service, not a fleet your engineering team has to maintain.

Each VM carries persistent disk, a real kernel, and full package installation privileges, giving a browser agent session the filesystem continuity and environment ownership that stateless serverless runtimes are structurally unable to offer. Maritime's snapshot-restore scheduler lets agents sleep between tasks and wake from snapshot in under a second, meeting the boot-latency bar a responsive agent product needs, and you pay for storage, not idle compute, while an agent isn't running. The shared-kernel vulnerability described earlier in this piece is the reason infrastructure platforms hosting multi-tenant browser agents at scale, Maritime among them, default to hardware-virtualized isolation over container-based approaches: the cost of a single kernel escape and the blast radius it opens up make that architectural choice a requirement.

Sources

  1. Firecracker

More in Sandbox & Runtime