Bot Perch

FeaturesState and storage

Snapshots, forks and templates

Four jobs hide under “snapshot”: a restore point on one machine, a reusable image for new machines, a copy of a running machine, and a backup that survives losing the host. Ask which one you are getting.

16 providersPrices checked 29 October 2026Sources linked

The idea

A restore point lets you rewind one machine after a bad change. A reusable image lets you start many identical machines from a known-good setup. A fork copies a machine, ideally while it is running, so you can try something without risking the original. A backup survives losing the host or the account.

Memory is the dividing line. A snapshot with memory can resume a half-finished agent turn; a disk-only snapshot cannot. Fork is the same split: a disk fork boots cold, a memory fork resumes mid-task. A “live” fork may still pause the source for a moment, and several providers do exactly that.

Templates are the third axis. They can be a Docker image, a named snapshot, or a fixed catalogue entry. That decides whether you can carry your own setup forward or are choosing from what the provider built.

Where providers split

The claim on the left, the provider's own words on the right

A snapshot with memory is not a backup

E2B, Morph, Lizard, boxd, Blaxel and Runtime all capture memory and processes in at least one snapshot mode. That makes them useful for cloning a working agent. It does not make them disaster recovery: a copy on the same host or cluster can disappear with it.

Boat's snapshots are automatic, disk-only and taken every minute, but only the newest is usable. Agent 37 has no snapshot product at all: a sleep checkpoint that cannot be cloned, a folder backup, and Dockerfile templates.

Fork is not always live

boxd forks memory and disk in 100–200 ms while the source pauses for a fraction of a second. Lizard forks 1–100 copies and pauses the source briefly. E2B pauses the source, captures it, and drops its active connections. Runtime freezes the source while memory is written.

Others fork the disk only. Sandboxer's fork gets a new identity and boots fresh. Agent 37's fork copies the disk while the source keeps running. InstaBox's fork is snapshot-save plus create, which is not instant despite the homepage.

Templates decide what you can carry forward

E2B and Blaxel build templates from Dockerfiles; Agent 37 pins Dockerfile-built images by digest. Sandboxer, Boat, boxd, Lizard and InstaBox use snapshots as their image mechanism. Morph has devbox templates that integrate a secrets manager.

A fixed catalogue is the narrowest case: Lizard's templates are platform images, and a custom upload flow is not documented.

One worked case

The same job at every provider, from the documented defaults

Rewind a bad change, then fan out ten copies

The agent edits a config file, breaks the build, and you want the machine as it was five minutes ago. Then you want ten copies of the working setup to run a test matrix in parallel.

  1. 00:00

    A known-good state exists: a snapshot taken before the edit, or only an automatic one the provider took for you.

  2. 00:05

    The agent breaks the build. You look for a restore point and find out whether older ones exist.

  3. 00:10

    You fork ten copies. Each one either resumes mid-process or boots cold from a disk.

The dividing line is memory. A disk-only restore gives back files and a cold boot; a memory snapshot gives back the process tree. Only some providers let you choose an older point, and several pause the source while forking.

What each provider does

Agent 37
Nothing to rewind to: the nightly backup covers only /home/node and restores in place, and a fork copies the disk but not memory.
Blaxel
A snapshot captures filesystem, processes and memory, but it is in private preview and not recommended for production.
Boat
Snapshots are automatic and disk-only every minute, and only the newest is usable, so there is no older point to rewind to.
boxd
A snapshot keeps memory and disk and boots already running; a live fork copies both in 100–200 ms.
Cloudflare Sandbox
The snapshot saves the root filesystem only: files come back in a new instance, processes do not, and there is no fork.
Daytona
A hot snapshot on the VM class keeps memory; on a container only a cold filesystem snapshot exists, and fork is VM-only.
E2B
A snapshot keeps filesystem and memory while the source keeps running; up to 20 forks, with the source paused and its connections dropped.
InstaBox
Snapshots are disk-only and may stop the machine to take them; a fork is snapshot-save plus create, not an instant clone.
Lizard
A snapshot keeps memory, processes and the whole disk; a fork makes 1–100 copies and pauses the source briefly.
Modal
A filesystem snapshot gives back the files in a new sandbox; the memory snapshot that would keep the process tree kills the source and expires in seven days.
Morph
Snapshots are immutable copies of memory and disk; a branch starts several running instances from one snapshot.
Runtime
A snapshot defaults to memory plus disk; a fork freezes the source while it captures, and a sandbox with a volume cannot be snapshotted.
Sandboxer
Three snapshot kinds, including a stop snapshot with disk and memory; forks are disk-only and boot fresh.
Sprites
Checkpoints snapshot the writable filesystem copy-on-write and restore in place, overwriting current files; there is no live fork.
Vercel Sandbox
Snapshots capture the filesystem and outlive the sandbox, but taking one manually stops the session.
Tensorlake
A memory snapshot warm-starts with its processes running, and copy fans one running sandbox out to N copies in a single call.

What to watch for

The details that decide the answer in practice

  1. 01

    Whether memory and processes are in the snapshot, and whether the source keeps running.

  2. 02

    Whether a restore is in place and destructive, or creates a separate machine.

  3. 03

    Whether you can choose an older snapshot; Boat cannot.

  4. 04

    Whether snapshots contain credentials; InstaBox's include saved logins.

  5. 05

    Whether a fork inherits the source's TTL; Boat's and Sandboxer's do not.

Compare all 16

Docs read 28 October 2026

Four jobs hide under “snapshot”: a restore point on one machine, a reusable image for new machines, a copy of a running machine, and a backup that survives losing the host. Ask which one you are getting.
ProviderWhat a snapshot keepsDoes it?What that means
Agent 37No snapshots7 backupsPartlyNo snapshot product. Free nightly backups of /home/node with seven restore points, restored in place only; a live fork copies the disk but not memory; templates are Dockerfile-built images.Agent 37 docs: Fork an instance — independent copy with its own id, URLs and billing ↗
Agent 37's own wordsdocs-confirmed
“Every instance's data (/home/node) is backed up nightly into seven rotating slots”
Agent 37docs-confirmed
BlaxelRAM + diskpreviewPartlyA snapshot captures filesystem, running processes and memory, and outlives the sandbox, but it is in private preview and not recommended for production. Fork runs from the snapshot.Blaxel docs: Snapshots and forking ↗
Blaxel's own wordsdocs-confirmed
“A snapshot captures the state of a sandbox at a point in time: its filesystem, its running processes, and its memory.”
Blaxeldocs-confirmed
BoatDisk onlynewest onlyPartlySnapshots are automatic, disk-only and taken every minute, but only the newest is usable: there is no point-in-time restore. Saved snapshots are named and never expire.Boat docs: Resume, fork and restore ↗
Boat's own wordsdocs-confirmed
“Resume and fork always use the newest snapshot. You cannot go back to an older one.”
Boatdocs-confirmed
boxdRAM + diskunder 200 msYesA snapshot keeps memory and disk, is named and versioned, and boots machines already running; a checkpoint is an in-place undo point; backups are disk-only and off-cluster; a fork copies memory and disk in 100–200 ms.boxd docs: Snapshots ↗
boxd's own wordsdocs-confirmed
“up in under 200ms”
boxddocs-confirmed
Cloudflare SandboxFilesystem only30 daysPartlysnapshotContainer() saves the writable root filesystem of a running instance, 20 GB maximum, and expires 30 days after creation or last restore. No memory and no fork. Directory backups to R2 have no expiry.Cloudflare Sandbox docs: Save and restore a sandbox with snapshots ↗
Cloudflare Sandbox's own wordsdocs-confirmed
“A snapshot expires 30 days after it is created or last restored.”
Cloudflare Sandboxdocs-confirmed
DaytonaHot: RAM (VM)cold: diskPartlyCold snapshots capture the filesystem from a stopped sandbox; hot snapshots capture filesystem and memory from a started VM. Containers support cold only. Fork duplicates a Linux VM's filesystem and memory. Snapshots go inactive after 14 days unused.Daytona docs: Snapshots ↗
Daytona's own wordsdocs-confirmed
“Forking creates a duplicate of a Linux VM sandbox's filesystem and memory state in a new sandbox.”
Daytonadocs-confirmed
E2BRAM + disk20 forksYesSnapshots capture filesystem and memory while the source keeps running, and filesystem-only snapshots are available. Up to 20 forks from a running VM, with a brief pause and dropped connections.E2B docs: Sandbox snapshots ↗
E2B's own wordsdocs-confirmed
“With the SDKs and the CLI you can request up to 20 forks at once.”
E2Bdocs-confirmed
InstaBoxDisk onlymay stop sourcePartlySnapshots are disk-only and may stop the machine to take them; a fork is snapshot-save plus create, not an instant clone; snapshots survive deleting the machine and include saved logins.InstaBox docs: Snapshots — save a machine, start new ones from it ↗
InstaBox's own wordsdocs-confirmed
“It is snapshot save plus create, so it takes about as long as those two.”
InstaBoxdocs-confirmed
LizardRAM + disk1–100 forksYesA snapshot captures memory, processes and the whole disk and restores into a new sandbox at the source's size; a fork copies a running sandbox 1–100 times with memory, pausing the source briefly.Lizard docs: Quickstart — pause, resume and snapshots ↗
Lizard's own wordsdocs-confirmed
“Copy a running sandbox 1 to 100 times, memory and processes included”
Lizarddocs-confirmed
ModalFilesystem 30 dmemory 7 dPartlyFilesystem, directory and memory snapshots, plus automatic exit snapshots. Filesystem and exit snapshots last 30 days by default; memory snapshots 7 days and cannot be extended. Fork means several sandboxes from one filesystem image, not a live clone.Modal docs: Sandbox snapshots ↗
Modal's own wordsdocs-confirmed
“Memory Snapshots expire 7 days after creation and cannot currently be extended.”
Modaldocs-confirmed
MorphRAM + diskbranchesYesSnapshots are immutable copies of memory and disk; a branch creates several running instances from one snapshot. Starting a snapshot restores memory, while booting it is a cold boot.Morph docs: Branch ↗
Morph's own wordsdocs-confirmed
“Snapshots are immutable point-in-time copies of both memory and disk state.”
Morphdocs-confirmed
RuntimeRAM + diskYesSnapshots default to memory plus disk, with disk-only opt-in; forks copy files, memory and processes but freeze the source while capturing; a sandbox with a volume cannot be snapshotted.Runtime docs: JavaScript SDK: snapshots and forks ↗
Runtime's own wordsdocs-confirmed
“Snapshots default to mode: "memory". That mode keeps files, memory and running processes.”
Runtimedocs-confirmed
SandboxerDisk + RAM on stopYesThree snapshot kinds: a stop snapshot with disk and memory, continuous disk snapshots every ten minutes, and named disk snapshots used as templates with share codes. Forks are disk-only.Sandboxer docs: Snapshots ↗
Sandboxer's own wordsdocs-confirmed
“Every 10 minutes while a sandbox runs, and at every stop”
Sandboxerdocs-confirmed
SpritesFilesystem onlyPartlyCheckpoints snapshot the writable filesystem, copy-on-write and without interrupting work; they restore in place and overwrite current files. A live fork or create-from-checkpoint is not documented.Sprites docs: Checkpoints ↗
Sprites's own wordsdocs-confirmed
“A checkpoint snapshots the writable filesystem overlay: everything you've added on top of the base image.”
Spritesdocs-confirmed
Vercel SandboxFilesystem onlyPartlySnapshots capture the filesystem and outlive the sandbox; taking one manually stops the session. Fork uses the current snapshot or falls back to a fresh create from the image.Vercel Sandbox docs: Snapshots ↗
Vercel Sandbox's own wordsdocs-confirmed
“You can also snapshot a running sandbox at any time by calling snapshot(), which captures its current filesystem before stopping the session.”
Vercel Sandboxdocs-confirmed
TensorlakeMemory or diskcopy ×NYesTwo snapshot types: filesystem restores with a cold boot, memory captures filesystem, memory and running processes and restores warm. Snapshots outlive the source sandbox and are deduplicated. copy boots one or many sandboxes from a running or suspended source, inheriting image, resources, network policy and exposed ports.Tensorlake docs: Snapshot and Clone — filesystem and memory snapshots, copy a running sandbox ↗
Tensorlake's own wordsdocs-confirmed
“memory: captures filesystem, memory, and running process state and restores with a warm start.”
Tensorlakedocs-confirmed

The specific capabilities

Each one checked for every provider, with the catch where a version falls short. All capabilities

CapabilityAgent 37BlaxelBoatboxdCloudflare SandboxDaytonaE2BInstaBoxLizardModalMorphRuntimeSandboxerSpritesTensorlakeVercel Sandbox
Snapshots of files
Snapshots with memory
Copy a running machine
Pick an older snapshot
Reusable templates
Automatic backups

YesWith a catchNoNot publishedHover or select a mark to see the catch.

Questions to ask before you sign

Each one targets something the documentation does not answer

  1. Does a snapshot include memory and running processes, and does the source keep running while it is taken?
  2. Can I restore an older snapshot, or only the newest one?
  3. Does a restore happen in place and overwrite the current machine, or create a separate one?
  4. Do snapshots and forks carry credentials, saved logins and packages installed outside the home folder?
  5. Does a fork inherit the source's TTL and network rules, and does it resume memory or boot cold?

Common questions

Answered from the capability checks; each links to the provider-by-provider detail and its sources

Which sandbox providers offer “snapshots of files”?
Save the machine's files at a moment and restore them later. Fully: Boat, Daytona, E2B, InstaBox, Lizard, Modal, Morph, Runtime, Sandboxer, Sprites, Tensorlake, Vercel Sandbox and boxd. With a catch: Agent 37, Blaxel and Cloudflare Sandbox. See each provider's catch
Which sandbox providers offer “snapshots with memory”?
A snapshot also keeps memory and running programs. Fully: E2B, Lizard, Morph, Runtime, Sandboxer, Tensorlake and boxd. With a catch: Blaxel, Daytona and Modal. Not at all: Agent 37, Boat, Cloudflare Sandbox, InstaBox, Sprites and Vercel Sandbox. See each provider's catch
Which sandbox providers offer “copy a running machine”?
Make copies of a machine while it keeps running. Fully: Agent 37, Boat, Daytona, E2B, Lizard, Morph, Runtime, Tensorlake and boxd. With a catch: Blaxel, InstaBox, Sandboxer and Vercel Sandbox. Not at all: Cloudflare Sandbox, Modal and Sprites. See each provider's catch
Which sandbox providers offer “pick an older snapshot”?
Restore any earlier snapshot, not only the latest one. Fully: Blaxel, Daytona, E2B, InstaBox, Lizard, Modal, Morph, Runtime, Sprites, Tensorlake and Vercel Sandbox. With a catch: Agent 37, Boat, Cloudflare Sandbox and Sandboxer. Not at all: boxd. See each provider's catch
Which sandbox providers offer “reusable templates”?
Turn a set-up machine into a template and start many new machines from it. Fully: Agent 37, Blaxel, Boat, Daytona, E2B, InstaBox, Lizard, Modal, Morph, Runtime, Sandboxer, Tensorlake, Vercel Sandbox and boxd. With a catch: Cloudflare Sandbox. Not at all: Sprites. See each provider's catch
Which sandbox providers offer “automatic backups”?
The provider takes backups for you on a schedule. Fully: Agent 37, Runtime and boxd. With a catch: Boat, Cloudflare Sandbox, Sandboxer, Tensorlake and Vercel Sandbox. Not at all: Blaxel, Daytona, E2B, InstaBox, Lizard, Modal, Morph and Sprites. See each provider's catch

Part of State and storage. Next: put two or three providers side by side.