Persistence beats ephemeral

E2B got the sandbox primitive right for 2023. Ephemeral Firecracker VMs, a clean SDK, fast cold boots. For the first generation of AI agents — stateless request-response, small context windows, narrow tasks — ephemeral was the right default. You set it up, you ran it, you threw it away. Each execution was independent. Persistence would have been overhead you didn't need.

2026 is different.

The shape changed

Agents got longer. Tasks that used to be one-shot calls are now multi-hour sessions. A coding agent reads the codebase, writes code, runs tests, reads logs, fixes a bug, tries again. That loop runs for minutes at minimum, sometimes for days. Ephemeral sandboxes make that loop expensive — every setup teardown is tax you pay on every iteration.

Agents got parallel. One task becomes ten attempts, each exploring a different approach. Re-doing the install-setup-seed dance for each fork wastes time that should be spent on the work. The shape you want is fork-from-state — warm environment cloned in milliseconds — and ephemeral primitives don't give you that.

Agents got longer memory. The context a session builds up matters for the work it does. Disk state is part of that memory. When your sandbox resets, your agent loses everything outside its prompt: cached weights, compiled binaries, indexed code, partial progress. The alternative is rebuilding context from scratch every time, which is slow and fragile.

The market noticed

Three signals in the last year:

Daytona pivoted from dev environments to persistent agent sandboxes. They killed their previous product to chase this bet. That's not marketing — it's an engineering call on where the revenue is.

Fly.io shipped Sprites with a tagline that reads like a manifesto: "The age of sandboxes is over." Persistent, resumable, forkable. Same bet as ours.

E2B added pause/resume to their roadmap. They're retrofitting persistence onto an ephemeral primitive. It'll work, but it will always be a retrofit. The architecture below it was built for the old shape.

Persistence changes what agents can do

A persistent machine is a different primitive from an ephemeral sandbox in the same way a laptop is a different primitive from a calculator. Both compute. Only one remembers.

When your agent's environment persists, you can:

• Leave work running. The agent doesn't stop when you close your laptop. Come back tomorrow; it's still there.
• Fork from any state. Not from a container image. From a full running machine — memory, disk, in-flight processes.
• Iterate without rebuilding. Install a dependency once; every future session benefits.
• Run for as long as the work takes. No 24-hour session cap. The machine sleeps when idle, resumes in milliseconds when you come back.

Where this goes

The next few quarters will see every sandbox provider ship persistence. Good — it's the right architecture. The question will be: who built for it, and who bolted it on.

We built for it. Every machine on boxd is persistent by default. Fork captures the whole state. Sleep costs nothing. Resume is sub-millisecond. Not because we added those features — because the primitive was shaped that way from day one.

Ephemeral was right for 2023. Persistent is right for 2026. The companies whose sandboxes forget will spend the next year writing retrofit code. The companies whose sandboxes remember will spend it shipping.

If you're picking a substrate for an agent harness right now, the two products that share this thesis with us are exe.dev and Sprites — see boxd vs exe.dev and boxd vs sprites.dev for honest comparisons.