The Sandbox Capability Checklist That Reveals When Your Agent Product Has Structurally Outgrown Serverless
A checklist for spotting when agents need persistent, resumable computers.

Persistent AI agent infrastructure differs from serverless functions in what survives after a request ends. An agent that needs durable sessions, uninterrupted work, or an isolated desktop needs a persistent, resumable computer. This sandbox capability checklist identifies when a product has crossed that line and what execution model its capabilities demand.
Why do long-running AI agents fail on serverless infrastructure?
Serverless functions fit stateless, short-lived request-response work. An inference request has a bounded lifecycle, so autoscaling and cold starts can fit that pattern. An agent session is different. It may run for minutes or hours, call tools in sequence, and accumulate work that the next step depends on. When the invocation ends, the task may still be at a point where it cannot safely stop.
A single-user product can need a process that survives between requests just as much as a multi-tenant platform does. More capacity does not change the process lifecycle. A higher timeout also cannot give an ephemeral function durable memory or let it resume exactly where it stopped.
How to use the capability checklist — each item is a signal, not a feature request
Does the product need state across invocations, a process that must survive interruption, a full operating system, or a stronger isolation boundary? Those needs call for changes to how the system is built. By contrast, a capability that still fits a bounded, stateless request may need only configuration. The distinction belongs at the point where the capability is designed, rather than after its workarounds become part of the product.
The checklist groups capabilities by what teams ship. Its items also build on one another. Persistent sessions introduce continuity, long-running tasks add duration, and untrusted code adds a security boundary that must hold regardless of task length. Later items extend those requirements to desktops, individual users, and parallel rollouts. Each section identifies what must remain true about the environment for that capability to work.
Capability 1 — Session state that survives between invocations
A session becomes a structural signal when the agent must retain working context between invocations without reconstructing it each time. A function’s own state is ephemeral. Teams can store state in a database or cache, but that makes persistence the responsibility of another system. The workaround adds latency, complexity, and another failure surface as the agent moves through tool calls. External storage can keep records even when the running environment is lost.
That distinction becomes sharper as the agent does more. Planning, reading documents, writing to systems, and coordinating with other agents leave tool history, working memory, and partially completed subtasks. The next invocation needs more than the latest message. It needs the context in which those unfinished steps make sense, while a multi-agent workflow spreads that context across parallel model calls. The architectural requirement is a persistent machine that retains memory and filesystem state between tasks, rather than making the agent rebuild its working context from logs.
Capability 2 — Long-running and asynchronous tasks that must not be preempted
Duration creates a separate constraint even when state has somewhere to live. A task can run past a function’s execution limit, and a higher limit on its own does not solve infrastructure preemption. Retrying is not the same as continuing. For an agent deep into a multi-step workflow, interruption can discard substantial work.
RL training makes that cost concrete because GPU jobs are routinely preempted to improve cluster utilization. When rollout execution is tied to the training job, the agent loop can end even though its sandbox state is still there. On resume, the queue, unshipped batch, and running rollouts dispatch before new work.
The infrastructure therefore needs a way to preserve execution across interruption. A function retry cannot supply that on its own. The environment must be able to pause, retain full state, and resume rather than requiring the agent to repeat the workflow from its beginning.
Capability 3 — Sandboxed execution of untrusted or LLM-generated code
Security creates a structural signal even for a short task. An agent that generates and executes code cannot depend on the model’s good behavior as its security boundary. The code may be malicious or manipulated. The sandbox must limit the damage in that case, rather than assume that prompting has made the output safe. This shifts the question from how long execution lasts to what it can reach.
Containers share the host kernel, so a kernel vulnerability can become an escape path affecting other tenants on that host. A separate kernel changes that isolation boundary. Firecracker provides a microVM approach, while gVisor offers strong isolation suitable for most workloads. A VM runtime also supports its own Linux kernel and workloads involving Docker, FUSE, and nested cgroups that containers cannot handle in the same way. These comparisons are limited to execution architecture.
Bounded, known tool calls can use lighter sandboxing, but arbitrary code execution needs the strongest isolation. That choice belongs in task planning. For the latter case, the architectural target is a disposable sandbox with its own kernel, removed with its disk when execution ends, rather than untrusted code sharing a host kernel by default.
Capability 4 — Checkpoint and resume for tasks that pause mid-execution
A pause can happen because a user walks away, infrastructure is preempted, or a dependent service becomes unavailable. Saving files alone does not save the process. Continuing without expensive replay requires a checkpoint of memory and filesystem state, followed by a restore of that environment. Kimi K3’s production deployment uses AgentENV, combining Firecracker, OverlayBD, ublk, and incremental memory and filesystem snapshots. It achieved a minimum 49ms resume and 133ms incremental checkpoint, showing what this architecture makes possible.
A faithful restore still has a correctness problem. The August 2026 arXiv paper describes how restored execution can combine states, assumptions, and external effects that never coexisted in a valid history. The outside world does not rewind with the machine. An email may already have been sent or a payment executed before the agent resumes from an earlier checkpoint. Repeating that step can therefore create a second effect.
For teams adding resume, the lesson is to pair checkpoint logic with application-level idempotency guarantees or side-effect tracking. Incremental snapshots supply continuity of memory and files, while the application must account for actions already taken outside the sandbox.
Capability 5 — Full desktop or browser control, including Windows and legacy app environments
Full desktop control changes what the agent must be given. It needs an operating system with a display it can observe and manipulate. A shell is not a Windows desktop. Healthcare, lending, insurance, and property management include legacy application workflows with no API, or an API that cannot support the whole task. In those cases, the interface itself is part of the execution environment.
OpenAdapt supports RDP and Citrix/VDI, while Microsoft UFO³ coordinates GUI agents across Windows, Linux, macOS, Android, and Web. UFO³ divides complex workflows into dynamic task graphs and runs independent steps in parallel. A healthcare workflow, for example, may require a Windows-only EHR, a web portal, and a phone app in the same session. A Linux container cannot substitute for the Windows environment that one of those steps requires.
The resulting requirement is a full virtual machine with a display, priced by use. When the agent reaches an unexpected state, a person must be able to see the same desktop and intervene without ending the session. Streaming remote desktop access provides that shared view. A log file does not provide control of the running interface.
Capability 6 — Per-user isolation where each end user gets their own environment
Each user needs their own filesystem, sessions, and signed-in services, but reserving an always-on VM for every open session ties cost to idle capacity. Open does not mean actively computing. The product therefore needs machines that can be created, put to sleep, and destroyed independently, with cost tied to actual use.
Pool-and-snapshot architecture addresses that mismatch by letting idle machines sleep and wake in under a second. It depends on fast restoration of the saved environment, which Firecracker microVMs support. A fresh function invocation can restart computation without restoring the user’s in-memory session, leaving the product to reconstruct what was there before. Per-second billing is useful here only when the lifecycle also preserves the session.
Each user’s environment must also be isolated from the others. With a shared host kernel, malicious or buggy code in one user’s environment presents a risk to other tenants through that shared boundary. With its own kernel, the environment no longer shares that particular shared-kernel risk.
Capability 7 — Eval pipelines and RL rollouts that need thousands of parallel environments
Batch workloads expose the same constraints through repetition. An eval pipeline may need thousands of isolated environments that all start in the same state and can each keep their own progress. Parallelism does not make those environments stateless. A rollout still needs to keep its execution context through an interruption, and each rollout must be able to recover on its own without making the whole batch restart.
DeepSeek-V4.1’s DSec infrastructure separates rollout execution from the training job. An agent sandbox hosts the scaffold and tools, while a worker container manages the sandbox. Together they retain the complete rollout state. A preempted GPU job can reconnect and continue without rebuilding execution through command-log replay, removing rollout-state recovery logic from the RL framework. The sandbox lifecycle no longer has to end with the training job.
PrimeIntellect’s approach reaches continuity through per-rollout memory snapshots, allowing rollouts to continue in new sandboxes. At this scale, launch behavior also becomes important. Serverless concurrency limits restrict simultaneous environments, while cold-start overhead accumulates across thousands of launches. The required shape is a swarm of disposable sandboxes launched in milliseconds from snapshots, each with its own kernel and independent recovery, billed per second and deleted when its rollout ends.
What the checklist reveals — the execution model is the constraint, and the architecture follows from the capabilities
Two or three of these signals together describe a coherent machine lifecycle. Batch work adds the ability to launch thousands of consistent environments from a shared base image, while per-user products need sleeping machines that do not incur active-compute charges.
For teams that have reached two or more thresholds, the next step is an execution-model audit. The test is whether the environment supports sleep-and-resume, per-user isolation, full OS environments where needed, and swarm-scale launches.
The agent brings its own logic and keys. The infrastructure supplies the machine, preserves it between periods of work, and isolates it from other users. That separation gives builders a direct way to evaluate their options.


