The Persistent VM per Agent Standard That Browser-Automation Companies Converge on at Scale
Persistent VMs with snapshot-restore let agents scale without paying for idle time.

Persistent AI agent infrastructure and serverless functions differ in what they keep between requests. A browser agent in production needs an isolated execution environment that keeps its browser state, processes, and dependencies without the cost of running compute all the time. The persistent VM-per-agent model meets those needs through kernel isolation and snapshot-restore, so trust, state, and latency constraints drive the choice of architecture more than a preference for where to host it.
What browser-automation agents actually need from their runtime
A browser-automation demo becomes an infrastructure problem when a developer asks what happens when it runs unattended, at scale, for weeks. Local Chromium can work on a laptop and fail in a headless container because of missing system libraries, sandbox permissions, or GPU flags. Provisioning is only the first operational constraint. Once the browser starts reliably, the runtime must keep the session, keep concurrent jobs apart, and keep the system running when parts fail.
Session persistence begins with authentication, but extends through the workflow. An agent logs in, keeps cookies, and uses the state it has built up across dozens of steps. If its browser disappears when the script exits, the next invocation must reconstruct that context and may repeat authentication that is rate-limited. A runtime organized around individual invocations therefore needs a separate answer for the browser session that spans them.
A demo with one working agent cannot show whether the runtime can handle concurrency. Each agent needs its own isolated browser context, since one page that misbehaves on a shared host can take down the whole process group. Recovery then becomes routine operational work. Crashed browsers need restarting, zombie processes need cleaning up, and sessions need tracking against the jobs that own them. These obligations make the runtime a production system in its own right.
Why shared containers fail at the trust boundary first
Shared execution fails first at the boundary between customers. Agents acting on user-supplied prompts or executing AI-generated code introduce untrusted behavior into the environment. A compromised session in a shared container can persist, read host resources, and reach another customer's run. That is a confidentiality failure. Resource management alone cannot establish who is allowed to see which credentials or alter which state.
Credential leakage gives this boundary a concrete form. Credentials can remain cached beyond a call, propagate to downstream services outside the intended tenant, or appear in logs shared across customers. The Beijing University of Posts and Telecommunications framework treats such consequences as a systems reliability problem. In a live software environment, an agent mistake can become a deleted file, a leaked secret, an unintended transfer, or a persistent misconfiguration. Better model behavior does not replace controls over the authority available to the process.
Strict seccomp profiles and namespacing considerably narrow a container's attack surface. They do not create a separate kernel. Namespace escapes and kernel exploits are still risks because containers are built to share the host kernel. For workloads that need stronger separation, more container configuration cannot give them the same structure as a dedicated guest kernel.
What microVM isolation actually provides that containers cannot
Each agent session in a microVM has its own kernel. An exploit against that guest kernel does not, merely by compromising it, compromise the host kernel shared by other sessions. This changes the boundary that an attacker must cross. The separation comes from the VM architecture rather than from a policy governing processes inside a shared kernel.
The virtual machine monitor, or VMM, is still part of that boundary. Its role is deliberately narrow. Guest code uses a separate operating-system kernel from the host. Compromising the guest and escaping the VM are separate failures.
The agent can install packages, run a browser, and execute arbitrary code without giving sessions next to it the same access to its workspace. The browser and agent can share one machine, which keeps state local and their runtimes together. Anthropic's computer-use API makes clear that the developer must supply the VM or container. The model interface does not supply the isolation boundary, so choosing and operating that boundary remains an infrastructure decision.
Why do long-running AI agents fail on destroy-and-recreate infrastructure?
Per-session VM isolation gives each session its own kernel, but destroying and rebuilding the environment on every request creates another constraint. A minimal microVM takes around 125 ms to reach user-space code from a cold boot. That figure describes a boot milestone, while the agent still needs the execution context required to continue its work. Repeated reconstruction puts that work back on the response path.
Agent products need sub-second wake latency between turns to feel responsive. An environment that takes multiple seconds to resume interrupts the interaction, even if its eventual execution is correct. If each invocation must rebuild the agent's environment, the product repeatedly pays the startup cost and loses continuity unless another system preserves it. A completed request is a poor boundary for destroying an unfinished workflow.
Keeping every VM warm avoids reconstruction but creates an idle-compute bill. Snapshot-and-delete offers a different lifecycle. The runtime captures state, removes the active VM to free the host, and restores the environment when another request arrives. A reusable image needs an initial cold boot, while subsequent spawns restore its snapshot. Persistence then describes the continuity of the agent's environment.
How snapshot-restore changes the economics of idle time

An agent can spend more time waiting than computing. It waits for a user, waits for a model, or remains parked between bursts of work. With an always-running VM, those pauses remain standing compute costs even though the agent makes no progress. Idle time becomes the dominant cost.
Snapshotting preserves the working directory, installed dependencies, running processes, and warm page cache. Suspending the captured environment stops its execution without requiring the next turn to reconstruct it. Nothing runs during that parked interval. The remaining cost is storage rather than an active machine, so idle cost trends toward zero without implying that stored state is free. Snapshot-restore separates the lifetime of the workspace from the lifetime of its compute allocation.
Shared, amortized disk storage replaces the assumption that every persistent agent requires a full-time VM rental. Per-user cost becomes a function of active-time compute and marginal storage. Most agents are idle most of the time. Without a mechanism that releases compute during those intervals, the same isolation design would be cost-prohibitive at consumer scale.
What millisecond-level checkpoint and rollback unlock for stateful agents

Fast snapshots also change what an agent can attempt while it is active. DeltaBox research from Shanghai Jiao Tong University and Huawei Technologies reports checkpointing in 14 ms and rollback in ≤6 ms at P95. Its DeltaState abstraction treats filesystem and process memory as a transactional, change-based state pair. DeltaFS and DeltaCR implement that abstraction within a Firecracker microVM. The saved state keeps filesystem and process memory together so they agree when work resumes.
That speed makes branching execution practical within a fixed time budget. Docker-based approaches take substantially longer to checkpoint and still longer to restore, making repeated branching prohibitively expensive in tree-search workloads. Managing state can use up the time set aside for the work itself. Reducing time spent repeatedly reconstructing the environment leaves more time for the agent to explore alternatives.
An agent can consequently checkpoint before a speculative action and roll back if the attempt fails. That restores local execution state rather than merely starting a fresh function invocation. It does not undo every consequence of the action. “Safe to Resume? Breaking Execution Continuity of Agent Execution via Rollback,” an August 2026 paper, identifies five failure modes, including external state mismatch, unrecorded external effects, and internal inconsistencies. Rollback can produce states that never coexisted in any valid execution history. Teams must check external side effects as well as internal state before they can treat resumed execution as safe.
How multi-tenant agent fleets extend the same VM isolation logic to per-user deployments
The unit of isolation expands naturally from a browser session to a deployed agent or user. In an agent-as-tenant model, each deployed agent is a tenant, which fits agents that serve different downstream consumers. In a user-as-tenant model, every end user receives an isolated tenant. That choice costs more to isolate. It also supports consumer products and compliance-sensitive workflows that require per-user audit trails.
The recommended pattern stores each tenant's credentials in a secrets backend with tenant-scoped access policies, fetches them per invocation, passes them through a short-lived context, and clears them on completion. Credentials are never logged or cached beyond a single call. Persistent workspaces do not justify persistent credential exposure. The VM isolates execution, while the secrets policy limits the authority made available during a particular action.
AWS Bedrock AgentCore applies this access-control logic to production multi-tenant agentic applications in 2026. Its policies evaluate tenant context at runtime for allow or deny decisions, restrict MCP server access, and assess quotas and tier-based permissions before tool invocations. Data access also requires tenant isolation. Microsoft Azure AI Foundry introduced user-scoped persistent memory in April 2026, using a scope parameter resolved from authenticated identity through the x-memory-user-id header or a Microsoft Entra token. The agent can access only the authenticated principal's memory.
These controls complement VM isolation rather than demonstrate a particular VM deployment model. MCP servers follow the same access pattern when memory-reading and memory-writing tools require user-scoped credentials and enforce isolation at the persistence layer. Tenants can have different tool sets without changes to the code. The framework likewise treats permission scope and runtime oversight as joint determinants of alignment with user intent. A private VM cannot compensate for a tool that authorizes access to another user's data.
Why serious agent infrastructure provides persistent VM isolation as a managed primitive
The browser-use library, with 108,638 GitHub stars and release 0.13.7 on July 27, 2026, supplies a decision layer distinct from the runtime developed here. Browser provisioning, lifecycle management, and tenant isolation remain separate production obligations when adopting it. A capable agent loop increases the need for dependable infrastructure.
For teams building agent-native products, the practical recommendation is to source persistent VM isolation as a managed primitive, outsourcing operation of a Firecracker fleet. The provider takes care of snapshot scheduling, copy-on-write storage, wake latency, and kernel isolation. That is a distinct infrastructure discipline. Managing it internally consumes time that could otherwise go toward the product's workflows and behavior. The purchasing criterion is the complete lifecycle.
This gives the product an agent with its own isolated VM, persistent disk, installed dependencies, and the ability to wake in sub-second time. Its workspace remains available without requiring its compute to run continuously. Tool permissions and tenant-scoped credentials still need deliberate design. Managed execution removes the need to rebuild the machinery that preserves and isolates the environment. For long-running browser agents, that is the useful dividing line between a persistent runtime and a collection of disposable invocations.


