Persistent Storage

By default a sandbox's /workspace is ephemeral — gone when the sandbox is destroyed. Attach a disk and /workspace becomes durable: it survives the sandbox, snapshots, and forks.

Isorun disks are backed by high-performance Tigris Cloud Disk — blocks live in object storage behind a local NVMe write-back cache: a real block device, not FUSE, not a network filesystem.

Attach a disk

Pass disk to create. /workspace is the disk — formatted ext4 on first use and mounted for you.

const sandbox = await isorun.create({ image: 'node:22-slim', disk: 'api-server' })
// install dependencies into the disk-backed /workspace
await sandbox.exec('npm install')   // node_modules lands on the disk
await sandbox.destroy()             // the disk survives

const again = await isorun.create({ image: 'node:22-slim', disk: 'api-server' })
// /workspace is exactly as you left it — npm install already done

One sandbox holds a disk at a time. Tigris enforces it with a lease; a concurrent attach fails until the first detaches.

Disk snapshots and forks

A snapshot is a point-in-time checkpoint. A fork clones a snapshot into a new, independent disk — copy-on-write, so nothing is copied and only divergent writes cost space.

Restore is a fork from a known-good snapshot — non-destructive, so the broken disk is untouched:

await isorun.snapshotDisk('project', { name: 'green' })   // checkpoint a working state
// ... a migration corrupts the disk ...
const restored = await isorun.forkDisk('project', { snapshot: 'green', name: 'project-fix' })
await isorun.create({ image: 'node:22-slim', disk: 'project-fix' })  // back to 'green'

Fan-out is the same primitive at scale — prepare once, fork N isolated copies:

const disk = await isorun.createDisk({ name: 'rl-env', sizeGb: 500 })
const prep = await isorun.create({ image: 'python:3.12-slim', disk: 'rl-env' })
await prep.exec('pip install torch gymnasium && git clone https://github.com/org/env /workspace/env')
await prep.destroy()
await isorun.snapshotDisk('rl-env', { name: 'ready' })

const runs = await Promise.all(
  Array.from({ length: 100 }, (_, seed) =>
    isorun.create({ image: 'python:3.12-slim', forkFromDisk: 'rl-env', diskSnapshot: 'ready' })
      .then((sb) => sb.exec(`python /workspace/env/train.py --seed=${seed}`)),
  ),
)

Each fork gets its own /workspace; writes in one are invisible to the others. Forking is metadata-only — instant, regardless of disk size.

Manage disks

Disks live independently of sandboxes.

await isorun.createDisk({ name: 'datasets', sizeGb: 250 })
await isorun.listDisks()                                    // your disks
await isorun.snapshotDisk('datasets', { name: 'v1' })
await isorun.forkDisk('datasets', { snapshot: 'v1', name: 'datasets-v2' })
await isorun.deleteDisk('datasets-v2')                      // deletes the disk and its data

Disk names are lowercase letters, digits, and hyphens (≤ 30 chars). You can't delete a disk while other disks forked from it still exist — delete those forked disks first.

How it behaves

• Real ext4. The guest kernel mounts the disk directly — node_modules, git, SQLite, mmap, and file locks behave exactly as on local disk. No userspace filesystem layer.
• POSIX. Fully POSIX-compliant disk.
• Sized like a real disk. df -h /workspace shows the size you provisioned; a full disk returns ENOSPC. You pay for data stored, not size provisioned.
• Durable on fsync. A successful fsync is committed. Writes hit the local NVMe write-log at NVMe latency and drain to Tigris in the background; a clean destroy or hibernate flushes the log before detaching. A host crash loses only the last few un-drained seconds — the filesystem recovers by journal replay, like a power cut.
• Attach is free. A disk-backed sandbox starts as fast as one without.

Billing

$0.02 per GB-month for data stored — you pay for actual data, not provisioned size — plus the usual per-second compute while a disk is attached. No egress fees, no separate Tigris account; it's a line item on your bill. Forks add nothing beyond their divergent writes.

Regions

Disks are global Tigris buckets — a disk's blocks live in Tigris's globally distributed storage, so it attaches from a sandbox in any region. Destroy a sandbox and the disk detaches automatically; attach it to a new sandbox whenever you like, on any machine.