For an agent sandbox, “persistent” is incomplete unless you specify what persists: files, process memory, network connections or a reusable image. Those differences determine whether a paused job resumes safely and what you keep paying for while it is idle.
This comparison reads each provider’s current documentation and turns it into a requirement checklist you can run offline. It does not report measured cold starts, workload costs or a provider security audit, and every figure below is the vendor’s own statement, quoted with the condition it was published under.
Compare lifecycle semantics first
The three providers do not use one shared vocabulary. What E2B calls pause, Daytona splits across stopped, paused and archived states, and Blaxel distinguishes standby from archive. Reading only the verb hides the differences that decide the outcome.
| Provider | What the documentation says survives | Documented limit you must plan around |
|---|---|---|
| E2B | Pause/resume keeps the filesystem and the memory, including running processes and loaded variables; a filesystem-only pause mode stores just the disk and reboots on resume | Continuous runtime window of 24 hours on Pro and 1 hour on Hobby; a paused sandbox is kept indefinitely |
| Daytona | Paused VMs keep filesystem and memory; stopped containers keep the filesystem on the runner; archived containers store the filesystem in object storage | Support depends on the sandbox class — see the matrix below |
| Blaxel | Standby snapshots the full state, files and running processes included; archive keeps filesystem changes over the image only | Memory is not restored from an archive, and processes are restarted instead of resumed |
E2B’s persistence guide is explicit that pause captures memory as well as files, and that a paused sandbox is kept with no automatic deletion until it is killed. The same page documents a second mode: “By default a pause saves both the filesystem and the memory. To save only the filesystem — a lighter snapshot that reboots on resume — pass mode: 'filesystem'.” So E2B gives you both a memory-preserving pause and a filesystem-only pause/snapshot, chosen per call, and the filesystem-only form deliberately trades memory for a lighter snapshot and a slower resume. Its sandbox overview adds the runtime window and the timeout behavior: when the timeout expires a sandbox can automatically pause to preserve its state instead of being destroyed, the auto-pause itself can be set to mode: 'filesystem', and pausing resets the runtime window. That last detail changes the arithmetic for a long job — the cap applies to continuous running, not to total lifetime.
Daytona’s lifecycle is per sandbox class
This is the part most comparisons flatten. Daytona publishes a capability matrix rather than one answer, and the default sandbox class is a container, which is the class that cannot pause.
| Lifecycle feature | Container | Linux VM | Windows | GPU |
|---|---|---|---|---|
| Pause / resume | not supported | supported | supported | not supported |
| Stop | supported | supported | supported | supported |
| Archive | supported | not supported | not supported | not supported |
| Fork | not supported | supported | supported | not supported |
| Snapshot, filesystem only | supported | supported | supported | supported |
| Snapshot, filesystem + memory | not supported | supported | supported | not supported |
So “pause my Daytona sandbox” is a question about which class you created, and the two capabilities people usually want together — memory-preserving pause and cheap long-term parking — sit on opposite rows. Its sandbox lifecycle documentation also states that a stopped container keeps its filesystem on the runner while a stopped VM offloads filesystem state to “nearby storage”, without quantifying latency, durability or billing for that storage.
Blaxel separates standby from archive
Blaxel’s sandbox overview documents standby as a warm state: when a sandbox has no active connection it transitions to standby in approximately 15 seconds, after which it waits indefinitely and resumes in the vendor’s stated under 25 milliseconds with memory and processes intact. A WebSocket or TCP connection that stays idle for 15 minutes also triggers standby, which matters if your agent parks on a long-lived socket and assumes the connection itself keeps the sandbox awake.
Archive is a different transition. It stores the filesystem changes the sandbox made over its image and shuts it down; memory is not preserved, and every process that was running is restarted automatically. On billing, the same page states memory is not charged in standby while snapshot and volume storage are, and that active sandboxes are billed for allocated memory with CPU allocated from that allocation rather than billed separately. No rates, currencies or plan totals are asserted here.
That under 25 millisecond figure is a vendor claim about resuming from standby, published without a workload, image size or region. It is not a cold start, not the time to install dependencies, and not comparable to any other provider’s number — including a number measured on your own workload.
Score your own requirements against documented flags
Guessing from marketing pages is avoidable. The fixture in this article’s evidence directory encodes the documented capability flags per provider and class, then reports which options satisfy a workload profile you write yourself. Nothing in it calls a provider, measures latency or guesses a number that a vendor page does not state.
- capability-matrix.json — documented flags with the page each came from, checked 2026-10-28.
- workloads.json — three requirement profiles: interactive coding workspace, short bounded code execution, intermittent agent.
- lifecycle_fit.py — the scorer, standard library only, run with
python3 lifecycle_fit.py. - fit-report.json — output of the recorded run, and fixture-run.txt holds its raw console transcript.
A verdict of meets means the documentation claims every flag the profile requires. verify means nothing contradicts the requirement but the page does not state it — the continuous-session limit is missing for Daytona and Blaxel, for example, so the scorer refuses to invent one. unmet means the vendor states the capability is not supported.
I ran the recorded version locally on 2026-10-28; that is a check of the fixture’s logic against transcribed flags, not a test of any provider. It exited 0 and a second run produced a byte-identical report. In that run 3 of the 18 provider-class/profile pairs met every documented requirement of their profile, and all three were the same option — E2B on Pro, once in each profile. The intermittent-agent profile, which needs a memory-preserving pause and a filesystem-only parking mode on the same sandbox, is the clearest split: E2B documents both pause modes on one sandbox, so it clears the requirement outright, while Daytona puts memory-preserving pause on its VM and Windows classes and its filesystem-only archive on the container class, so every Daytona option lands on one side or the other. Read that against the fixture’s flag definition rather than against any snapshot: archive_filesystem_only tracks the archive lifecycle specifically, so a Daytona VM that documents filesystem-only snapshots still scores unmet here because it documents no archive. Blaxel’s standby-plus-archive combination also documents all three behaviours, but the scorer returns verify rather than meets because its page states no continuous-session limit for the profile’s six-hour session.
That ranking is about documented coverage, not about quality. Where a provider splits these capabilities across classes or modes, the split reflects how the product models durability rather than an accidental gap — the actionable step is to confirm which class or mode you actually get, and what the resume path costs, before you commit a workload to it.
A recovery test for stateful agents
Documented state preservation is a claim about the sandbox, not about your application. Test the application path as well.
Before pausing, store a job ID in durable application storage and have the sandbox record its current step. After resume, confirm the file and process state you expected, then force the external client to reconnect — a preserved process does not keep an external database or HTTP connection alive, so the code that assumes the old socket is still valid is the code that fails.
Retry the last application operation with the same idempotency key and verify it does not create a duplicate result. Then test a lost sandbox: can another environment reconstruct the job from durable state alone? Keep business state outside the execution environment whenever losing that environment would lose work you must retain. A snapshot is a convenience; it should not be the only explanation of how a payment, deployment or customer update recovers.
Build the cost comparison from lifecycle time
Estimate:
monthly cost = active compute + idle retained state + image/snapshot storage + network + operational effort
Use the vendor’s rates for your region, plan and runtime, and record the date you read them. Compute active duration from realistic sessions, including dependency setup, failed attempts and shutdown delay. Retained storage remains billable while active compute is paused — Blaxel’s page says so directly about standby, and it is the reason an “idle” sandbox is rarely free anywhere.
Separate introductory credits from steady-state cost: credits can fund a pilot but do not establish the long-term winner. A workload that needs a warm session all day has different economics from one that runs a few isolated tasks, so compare the two only after you have decided which workload you are actually running.
Selection rule
Choose the service whose lifecycle, authorization and recovery behavior matches the application, then compare the measured cost of accepted jobs. For a coding workspace, check filesystem retention and preview access across many resumes. For short code execution, check bounded runtime and cleanup. For an intermittently active agent, check that memory survives the idle period and that external connections re-establish afterwards.
The Docker/gVisor comparison covers a different question: which execution boundary belongs in your stack. Keep that boundary decision separate from hosted lifecycle economics.
Revision note
Updated October 28, 2026. Added the documented lifecycle capability matrix per Daytona sandbox class, E2B’s continuous runtime window and timeout-pause behavior, Blaxel’s standby-versus-archive semantics and standby billing statements, and a downloadable offline decision fixture. Earlier unsupported startup rankings, price and credit assumptions, and the stateless-versus-stateful split remain withdrawn.
Corrected the same day. A review found one flag wrong, by my transcription rather than by a page change: E2B’s persistence page does document a filesystem-only pause/snapshot that reboots on resume, alongside the memory-preserving pause. The E2B paragraph and table row now say so, the fixture flag is set from the quoted sentence, and the regenerated report reports 3 of 18 pairs with E2B on Pro meeting all three profiles. A sentence claiming Blaxel archives cannot be forked was removed because the cited page does not state it. The URL, publication date, title and description are unchanged.
Primary sources
Checked October 28, 2026: E2B persistence; E2B sandbox lifecycle and timeouts; Daytona sandboxes; Blaxel sandboxes overview.
