Browser Agent Isolation With Firecracker Micro-VMs

Firecracker micro-VMs contain compromised browser environments where shared kernels cannot.

· 8 min read
Cover illustration for “Browser Agent Isolation With Firecracker Micro-VMs”
Browser Agent Architecture · October 17, 2026 · 8 min read · 1,860 words

Infrastructure for persistent browser agents must keep browser state through sleep and wake, so each task can use that state instead of starting as a fresh, stateless invocation. Browser agent isolation with Firecracker micro-VMs addresses the other essential requirement, which is containing a compromised browser behind its own hardware-enforced kernel boundary. For agents that visit arbitrary URLs or hold real credentials, that boundary is the minimum viable starting point.

Why the browser is the most dangerous workload to run on shared infrastructure

Johann Rehberger's published demonstration showed Claude Computer Use navigating to a page with a prompt injection payload, downloading and executing a binary, and connecting to a command-and-control server. The chain eventually succeeded on an unisolated host after initial download attempts failed and the payload was simplified. This was agent subversion through the agent's actions. That distinction matters because a browser agent exposes two independent routes to code execution, namely the agent's actions and the browser's processing of hostile content.

Chrome compiles JavaScript written by strangers as it runs and decodes their images, video, and fonts. An agent that visits arbitrary URLs thus handles adversarial input even when it follows its instructions correctly. A renderer exploit followed by a browser sandbox escape can place attacker-controlled code in the environment running the browser. Generated shell commands, package installations, and automation helpers give code more ways to run. Platforms such as Maritime put each agent inside its own Firecracker micro-VM so that an attacker who compromises this environment does not at once reach a kernel shared with other agents.

Why a shared-kernel container cannot contain a browser exploit

A Docker container using the default runc runtime shares the host Linux kernel. Its processes issue syscalls to that kernel, subject to seccomp profiles and capability sets. Chrome's renderer sandbox already assumes that a renderer may be compromised. Once an attacker escapes that sandbox, a container still leaves the attacker facing the same kernel used by every other tenant on the host.

Container escapes through kernel vulnerabilities have a documented CVE history. Seccomp profiles, dropped capabilities, and read-only filesystems reduce the available attack surface, but they do not replace the kernel boundary. A successful host-kernel exploit can affect the entire host. Container hardening is therefore useful defense in depth.

Operational familiarity is the strongest argument for retaining containers. They are fast to deploy, and teams already know how to build and manage their images. But deployment speed does not reduce the blast radius of a kernel compromise or the recovery work that follows it. For a workload that continuously accepts hostile input, the decisive question is which kernel the attacker reaches.

What Firecracker actually does at the hardware level and why that boundary is different

AWS developed Firecracker to power Lambda and Fargate. It creates minimal virtual machines using KVM, with each guest running its own Linux kernel behind a hardware-enforced virtualization boundary. In a container, attacker-controlled processes interact with the host kernel through filtered syscalls. In a Firecracker micro-VM, those processes interact with a guest kernel that belongs to their own workload. Compromising that kernel does not, by itself, compromise the host kernel or another guest.

Firecracker deliberately restricts device emulation to a small set of virtio devices, limiting the interface exposed beyond the guest. Its virtual machine monitor, or VMM, is itself jailed with seccomp and a chroot. These restrictions add defense in depth around the component enforcing the guest boundary. The architecture requires an attack against the virtualization boundary for an escape.

Firecracker's approximately 125ms boot time and under 5 MiB of memory overhead per VM make this boundary practical at session granularity. That changes the containment model for browser agents specifically. A Chrome sandbox escape lands inside a guest that can be discarded, and even a guest-kernel compromise that follows stays behind the virtualization boundary. Reaching a neighboring browser session requires a further break through that boundary.

Diagram: Container vs. Micro-VM: Where the Attacker Lands. Visualizes: Show a two-column comparison of what an attacker reaches after a Chrome renderer sandbox escape in each environment.

Why the micro-VM boundary matters uniquely for programmatically driven browsers

Browser isolation must protect identity as well as execution. A session accumulates cookies, session tokens, downloaded files, screenshots, browser profiles, and potentially saved passwords. Reusing a browser profile across users can turn one session's stored identity into another session's credential. Separate kernels cannot compensate for deliberately reusing those artifacts. The guest lifecycle must therefore match the intended ownership and lifetime of browser state.

AWS AgentCore Browser applies this principle through per-session micro-VM isolation. Its developer guide states that the micro-VM is terminated and its memory sanitized when the session ends, with no execution state, filesystem artifacts, or memory contents persisting between sessions. The browser, automation layer, generated code, and session artifacts consequently share one containment boundary and one disposal lifecycle. This is a concrete production example of treating the browser session as the security unit rather than placing many sessions behind a common kernel.

AgentCore Browser added support for Chrome extensions in January 2026, for proxy configuration in February 2026, and for OS-level interactions in April 2026. Those interactions include mouse operations, print dialogs, native system alerts, and keyboard shortcuts. These interactions need to sit inside the per-session micro-VM because browser automation reaches beyond page scripts into the operating system around them. Vercel Sandbox, which reached GA January 30, 2026, similarly gives each sandbox its own Firecracker microVM with its own filesystem, network, and process space.

What micro-VM isolation does not solve, and what must be handled separately

An agent does not need to escape its VM to misuse a network route already open to it. Access to the public internet, internal metadata services, private APIs, or arbitrary DNS remains a separate security concern. In documented agent escape incidents, agents have used network paths open to them without breaking through the compute isolation primitive. The design requirement is therefore explicit egress control. Firecracker treats guest network traffic as untrusted and expects filtering at the host level.

The platform must also decide which files are mounted, which secrets are present, which packages are trusted, and which tool calls require approval. Hardware virtualization cannot make those policy decisions. Prompt injection and tool poisoning work above the compute boundary and can lead to harmful actions without an exploit. The micro-VM limits where compromised execution can spread, while authorization and tool policy govern what the agent may legitimately do.

Compatibility creates another design obligation. A usable browser environment needs an OS image, language runtimes, package managers, browser dependencies, fonts, certificates, and the SDKs its tasks require. An image stripped too far can break ordinary work, while an unnecessarily broad image increases the attack surface. The platform must balance that image deliberately rather than treat minimalism as a substitute for compatibility.

How snapshot-restore makes per-session micro-VM isolation economically viable

The usual case against a VM for each session is the time it takes to start and the cost of keeping idle machines alive. Snapshot-restore lets an environment go through the costly setup once and then be restored when work resumes. Between periods of work, its saved state can stay in storage without tying up compute the whole time. This changes the economics of persistent isolation without requiring agents to discard their working environment.

Copy-on-write mapping also limits the memory cost of restoring a common template. Multiple restored sandboxes can share the template's RAM on the host until they modify it. A hundred restores therefore do not automatically require a hundred times the template's RAM. The distinction is important when many tenants need the same browser and runtime environment.

AWS AgentCore Runtime V2, launched September 18, 2026, restores sessions from snapshots with a P75 cold start of 1.9 to 2.0 seconds. DigitalOcean MicroVMs, in public preview in October 2026, pause when idle and resume in milliseconds with memory, files, and running processes intact, with no compute charge while paused. Vercel Sandbox takes a different billing approach by charging only for active CPU, excluding time spent waiting for I/O, network requests, or AI model calls. Both approaches address browser agents' substantial waiting time. Costs must therefore be compared for active work and saved state, as well as for containers and VMs that run all the time.

Diagram: Snapshot-Restore Economics: Pay for Active Work, Not Idle Time. Visualizes: Illustrate the cost model contrast between always-on VMs/containers and snapshot-restored micro-VMs for browser agents that spend much of their time waiting.

What a persistent browser agent deployment looks like inside a micro-VM

A persistent browser agent keeps its browser profile, saved cookies, downloaded files, and installed packages on the micro-VM's persistent block device. A snapshot preserves the execution state needed to resume the browser context, while persistent disk retains the filesystem. Together, these primitives allow the agent to return to the same logged-in state, open tabs, and working files. The ownership boundary becomes the persistent guest.

Maritime assembles this topology with an isolated Firecracker micro-VM on bare metal for each agent, a persistent disk, and wake from sleep in under a second. It keeps its browser session, installed packages, and filesystem through sleep. Vercel Sandbox supports sessions up to 24 hours on Pro and Enterprise plans with persistence on by default, while DigitalOcean MicroVMs provide the pause-and-resume model described above in public preview. These options distinguish persistence from a fresh start, although their lifecycle and availability terms differ.

For a multi-tenant product, assigning each user a dedicated micro-VM keeps that user's browser profile and credentials within their own guest. AWS AgentCore supports a silo model for Runtime deployments with dedicated IAM execution roles per tenant as one supported non-default pattern. Browser automation can be exposed through MCP servers using lightweight JSON-RPC 2.0 endpoints. In that architecture, tool calls cross a network boundary where firewalling, rate-limiting, and auditing can be applied. Persistent identity and the tool interface must respect the same tenant boundary as the VM.

How to think about isolation level choices when building a browser agent product

The choice begins with the pages the browser visits, the credentials it holds, and whether users share infrastructure. A hardened container can be a starting point for internal URLs with no user credentials or multi-tenancy, though browser zero-days still pose a risk. With arbitrary public URLs, agent-generated automation scripts, or real user credentials, micro-VM isolation is the minimum needed. Where users' sessions must never share a kernel, each user needs a separate micro-VM. gVisor provides an intermediate user-space kernel boundary, but it does not give each session its own hardware-enforced guest kernel.

The lifecycle decision follows from that trust model. Teams must establish whether a guest is destroyed, preserved for the same user, or recycled, because recycling a browser profile can transfer identity across sessions. They must also establish the available egress controls and where credentials live. Short-lived scoped credentials added when a session starts are safer than a persistent password manager inside the VM. For persistent agents, snapshot and restore support is a requirement distinct from the ability to launch fresh environments.

The distinction between persistent agent infrastructure and serverless functions is consequently not the presence of Firecracker alone, since AWS developed Firecracker for Lambda and Fargate. It is whether the deployment provides the required lifecycle, retained browser context, tenant boundary, and policy controls. Maritime offers the assembled compute and persistence primitives, including a Firecracker micro-VM per agent, persistent disk, real package installation, browser session support, and sub-second wake from snapshot through a single-push deployment. Teams still need to assess egress and credential policy separately.

More in Browser Agent Architecture