Persistent VM per Agent Is the Infrastructure Primitive Serverless Cannot Emulate
Agents need to pause without dying, which functions can't do.

Persistent AI agent infrastructure and serverless functions solve different problems. Serverless fits short tasks that need no live state between runs, while a persistent VM per agent preserves the working environment across long jobs and pauses. The key difference is not faster startup but the ability to stop using active compute without destroying the process, browser session, or unfinished work.
Why serverless was designed around stateless, short-lived functions
Serverless compute was designed for discrete, stateless functions that finish in seconds and leave nothing behind. That contract suits event-driven web workloads. Any instance can handle any request because no instance holds something the next one needs. Resources are allocated when a function is invoked and released when it returns, so the platform does not need to preserve a process that is waiting between tasks.
Traditional VMs make a different trade-off by providing full isolation and a whole machine to work in. That freedom comes with setup costs. Booting and configuring the machine, then suspending and resuming it, can take seconds to minutes. When work takes repeated turns instead of one complete request, that overhead adds up. Agents expose the gap between these two models.
Why long-running AI agents fail on serverless infrastructure
An agent is a process. It calls a model, waits for a response, executes a tool, waits again, and may repeat that cycle across hours or days. A function timeout can cut through that work before the job is finished. Restarting the invocation does not restore the process that was interrupted.
The waiting is the central problem. An agent can be idle without being done. Open files, browser sessions, and computations still in progress may all need to stay as they are until the next step. The serverless assumption that instances are interchangeable breaks because the next invocation needs something the previous environment held. Saving a result is not the same as preserving that environment.
A dedicated, always-on VM preserves the state but spends resources keeping every waiting agent active. That solves one problem by creating another. Bursty workloads make this tension sharper because the agent needs continuity even when it rarely needs compute. Agents need a primitive designed to separate an agent’s lifetime from its active compute time.
What the new primitive actually is — a persistent, hardware-isolated microVM per agent
Each agent gets a hardware-isolated microVM with its own guest kernel, persistent storage, and the ability to checkpoint and resume from a snapshot. Its execution environment belongs to that agent. The architecture separates the harness, which calls the model and decides what happens next, from the sandbox, which runs code, shell commands, and browser sessions. The harness remains outside the execution boundary and dispatches explicit commands into it.
When a tool call finishes, the sandbox signals completion and the host checkpoints the microVM to an encrypted snapshot. The waiting agent then consumes close to zero active compute until the next step. Resume restores the state where it stopped. Persistence no longer requires continuous execution.
Copy-on-write memory sharing reduces the footprint of a fleet. MicroVMs built from the same image share base operating-system and library pages until one modifies them. Combined with checkpointing, it makes this more than a VM with faster startup. The primitive distinguishes working from waiting and schedules and bills accordingly.
Why the security model of a microVM-per-agent is structurally different from a container
Containers share the host kernel, so a container escape or host-kernel vulnerability can expose the host. A microVM has its own guest kernel. The hypervisor boundary separates that kernel from the host, changing where untrusted execution takes place. For agents running model-generated code that no human wrote or reviewed, this boundary is part of correct execution.
The harness-and-sandbox split also keeps backend credentials outside the agent’s execution environment. Secrets do not belong in the box. In this design, traffic passes through a virtio-vsock boundary to an unprivileged local proxy, then through an external gateway that validates request scopes and injects credentials. The sandbox cannot go around that route to make direct internet requests.
The identity design keeps those permissions separate as well. It defines user identity, Delegated Agent on-behalf-of Identity, Agent Workload Identity, and Agent Workforce Identity. Only Agent Workload Identity is used for sandbox traffic, and none gives the sandbox direct API access if stolen. If an inbox contains a hidden instruction to exfiltrate API keys, the sandbox has no backend keys to surrender.
What snapshot-and-resume enables beyond serverless — evals, RL rollouts, and parallel branches
A warm environment can become the starting point for thousands of parallel agent runs. That changes the economics of evaluation and training. Dependencies may already be installed, services running, and part of the task completed before the runs diverge. Forking that microVM through a copy-on-write snapshot preserves the shared baseline without repeating its full boot and setup cost for every branch.
Serverless can run many functions in parallel, but that alone does not give them this shared starting point. A fresh function invocation does not inherit a warm environment with work already in progress, so that environment must be rebuilt for each run. For reinforcement-learning rollouts, the expensive baseline can instead be prepared once and branched many times. The same checkpoint mechanism that keeps waiting agents cheap keeps the cost of these branches down too, with no need for a separate batch mode.
Computer-use agents expose the sharpest problem — a GUI needs live desktop state
A computer-use agent needs to return to the desktop it was using, even if another desktop looks the same. Its browser tabs may still be open, its services signed in, and its applications holding work that is not yet done. A cold boot loses that working context. If the next step is to continue clicking through an interface, starting over is a failure to resume.
Simular’s 2026 platform comparison distinguishes headless Linux VMs, which provide a shell and filesystem, from full graphical desktops streamed over VNC or a browser. Computer-use agents need the graphical layer. Agents also need this graphical layer beyond Linux development environments, for desktop applications that run only on another operating system, Citrix environments, and phone-only applications without an API surface. Those workflows require direct GUI operation and a desktop or device environment the agent can continue using.
Human takeover depends on that continuity too. A person needs to open the same live session and intervene, rather than receive a replacement environment that must be re-established. Snapshotting supports pauses, but intervention itself requires the session to be live. Isolation also becomes more urgent when the agent browses the open web or works through a legacy EHR portal, where a malicious page or corrupted workflow must remain contained.
How the microVM-per-agent primitive handles regulated industries where state and isolation are compliance requirements
In healthcare, lending, and insurance, session continuity and isolation can be operating requirements. Healthcare makes the practical need especially clear. A prior authorization workflow may need to copy data between an EHR system and a payer portal while keeping signed-in sessions open in both. A stateless invocation that re-authenticates from scratch does not preserve that workflow. Visual computer-use agents also avoid some brittleness of fixed pixel locations and rigid selectors when those interfaces change.
The compliance case depends on where processing and data reside. That location determines which safeguards are needed. HIPAA requires appropriate protections for ePHI stored on endpoint local storage, including encryption, access controls, and audit logging. In a VDI-based agent architecture, application execution and data processing occur on session-host VMs, while the endpoint receives only an encrypted video stream. This addresses the endpoint layer without removing the need to protect the session hosts.
The proposed 2026 HIPAA Security Rule update would require critical electronic information systems and data to be restored within 72-hour limits after a loss or cyber incident. Centralized VDI delivery with a golden master image supports that restoration model more directly than distributed endpoint execution. Separately, when the harness sends explicit tool commands, it creates a deterministic record of what the agent did so that its role in clinical decisions can be traced.
Business Associate Agreements are still required with every sub-processor that handles PHI. Credential separation does not erase that obligation. Keeping credentials outside the sandbox leaves them less exposed and can narrow the BAA surface tied to them compared with keeping long-lived credentials on the agent’s machine. The claim for this architecture is that it controls execution, protects state, and keeps actions traceable. It is not a claim that a microVM, by itself, certifies a deployment as compliant.
The honest objection — when serverless is still the right answer
Serverless remains cheaper and simpler when a task fires infrequently, finishes in seconds, and needs no state between runs. That is a legitimate agent workload. At scale, per-hour VM costs compound, and there is no reason to preserve an environment that has nothing useful to preserve. Bursty, asynchronous work does not automatically call for a persistent machine.
The qualifier is whether the work is genuinely stateless. An agent may appear stateless only because each invocation discards its environment and pays to rebuild it next time. External storage can hold all the state needed when it is simple key-value state. It cannot, by itself, restore a running process, an open browser session, or a GUI interaction stopped halfway through.
Checkpointing changes the idle-cost comparison with an always-on VM. The waiting agent consumes close to zero active resources, with its state held in a snapshot that wakes in under a second. The decision turns on whether the work is stateless and fits below the timeout, or instead holds live state, runs long, or needs to resume. Burstiness alone does not settle that question.
Choosing the right machine type for the job — persistent agents, throwaway sandboxes, and swarms

For builders, the first decision is whether useful state must survive the task or pause. If it must, a persistent agent box is a fit. An open browser session, an installed development environment, or a multi-day coding project needs a machine priced for sleeping and waking. For an end-user agent product, cost per user is the measure to use, while an internal tool is judged mainly by its workload. Sleeping idle machines and billing per second make that deployment shape more tractable.
If no state needs to survive, the next question is whether the task needs an isolated place to execute untrusted code. A throwaway sandbox fits that bounded job. The machine and its disk are deleted when execution ends, leaving no residual sandbox state to clean up or audit. This is distinct from the short, genuinely stateless serverless case because isolation is the primary requirement.
If the job instead needs many runs from the same prepared environment, the appropriate shape is a swarm of parallel instances. Evals, RL rollouts, and batch jobs fit here. Forking from a snapshot avoids cold-booting thousands of fresh VMs and repeating the baseline setup.
The interface is a separate choice from the machine’s lifetime. Simular’s comparison distinguishes a headless Linux VM, a full graphical desktop with screenshot, mouse, and keyboard APIs, and a ready computer the agent uses directly. The machine decision also comes before the model decision because the platform runs the computer, while builders bring their own model and keys.


