Now in beta

Code.Break.Restore.Ship.

Sandboxes with instant snapshots.
Your AI agents break things, roll back in <1ms.

Start Free →View Docs

No credit card • Deploy in 30 seconds

<1ms

restore

100%

state

MIT

license

1import { Sandbox } from 'iris'
2
3const sandbox = await Sandbox.create()
4
5// your agent runs code fearlessly
6await sandbox.exec('python experiment.py')
7
8// something breaks? instantly roll back
9const checkpoint = await sandbox.checkpoint()
10await sandbox.exec('rm -rf /*')  // oops
11await Sandbox.restore(checkpoint)  // 0.8ms later, all good

Works with your agents

Claude Code

Anthropic

Codex

OpenAI

Devin

Cognition

Cursor

Anysphere

Copilot

GitHub

// why speed matters

Checkpoint restore time comparison

Docker Containers

2000-5000x slower2-5s

E2B Sandboxes

200x slower~200ms

VM Snapshots

100-500x slower100-500ms

Iris

Instant<1ms

Faster restore = more experiments per second = faster AI agent iteration

// features

Everything under the hood.

Sandbox VMs

Firecracker
MicroVM isolation in ~125ms boot
Linux kernel
Full syscall compatibility
Isolated network
Private networking per sandbox

Execution

Any runtime
Python, Node, Go, Rust, etc.
Root access
Install anything with apt/pip/npm
Persistent fs
ext4 filesystem, NVMe storage

Checkpoints

Full state
Memory + disk + network captured
Copy-on-write
Instant snapshots, zero overhead
<1ms restore
Resume from any checkpoint

State API

new

Agent memory
Persist knowledge across sessions
Scoped namespaces
local · project · global
Close-to-open
Consistent at every checkpoint

Scale

Parallel forks
Branch from any checkpoint
Warm pools
Pre-warmed sandboxes ready to go
Auto-cleanup
Configurable TTL and GC

// how it works

Four steps to instant state management.

01Create
Spin up isolated VM
const sandbox = await Sandbox.create({
  runtime: 'python:3.11'
})

02Execute
Run any command
await sandbox.exec('pip install numpy')
await sandbox.exec('python train.py')

03Checkpoint
Save full state
const snap = await sandbox.checkpoint()
// snap.id → "chk_8f3a2b"

04Restore
Return in <1ms
await Sandbox.restore(snap.id)
// ✓ restored in 0.84ms

// use cases

Built for developers who need predictable environments.

AI Code Agents

1000x faster iteration

Claude Code explores your codebase, breaks something, restores in 0.8ms. Run 1000+ experiments in parallel.

Parallel Testing

10,000 concurrent tests

Fork sandboxes to test 10,000 permutations simultaneously. Checkpoint winners, discard failures instantly.

Bug Reproduction

100% reproducible bugs

Capture exact state when bugs occur. Restore infinitely while debugging. Share snapshots with team.

// simple api

Three methods. Works with Python, TypeScript, and CLI.

create()→ spin up sandbox

exec()→ run commands

checkpoint()→ capture + flush state

restore()→ return instantly

state.project→ shared agent memorynew

state.local→ sandbox-scoped

1import { Sandbox } from 'iris'
2
3const sandbox = await Sandbox.create({
4  runtime: 'node:20'
5})
6
7await sandbox.exec('npm install')
8const snap = await sandbox.checkpoint()
9await Sandbox.restore(snap.id)

// state api

new

Your agents now remember. Persist structured data across any checkpoint, restore, or fork.

Close-to-open consistency — every session starts with a complete, consistent view of everything prior sessions wrote.

state.localsandbox lifetime

Scoped to this sandbox. Fast, zero overhead. Dies with the sandbox.

state.projectproject lifetime

Shared across all sandboxes in your project. Survives checkpoint and restore.

state.globalforever

Team-wide knowledge base. Persists indefinitely across all projects.

state-api.ts
1import { Sandbox, state } from 'iris'
2
3// Session 1: agent builds knowledge
4const s1 = await Sandbox.create({ runtime: 'python:3.11' })
5await s1.exec('python research.py --topic ml-models')
6await state.project.set('findings', { models: [...], scores: [...] })
7
8// checkpoint flushes state — close-to-open guarantee
9const snap = await s1.checkpoint()
10
11// Session 2: picks up exactly where S1 left off
12const s2 = await Sandbox.restore(snap.id)
13const findings = await state.project.get('findings')
14// findings === everything S1 discovered, guaranteed

The guarantee

01 · close

Checkpoint flushes

All writes are durably flushed to the state store when a sandbox checkpoints or terminates.

02 · store

Consistent snapshot

State is stored atomically. No partial writes. The manifest is updated in a single operation.

03 · open

Next session sees all

Every restore or fork starts with a complete, consistent view. No coordination overhead mid-session.

// built for production

Enterprise-grade infrastructure, developer-first experience

Firecracker VMs

Hardware isolation

MIT Licensed

Open source

99.9% Uptime

Production-ready

<125ms Boot

Cold start time

// pricing

Start free. Pay for what you use.

Hobby

Free

For side projects and experimentation

+$100 free credits
+1 hour max session
+20 concurrent sandboxes
+10 GiB storage
+Community support

ProPOPULAR

$150/mo

For production workloads

+Everything in Hobby
+24 hour max session
+100 concurrent sandboxes
+20 GiB storage
+Custom CPU & RAM
+Priority support

Enterprise

Custom

For teams at scale

+Everything in Pro
+Unlimited sessions
+Unlimited concurrency
+Custom storage
+SLA guarantee
+Dedicated support

+Usage-based pricing

$0.000014/secvCPU

$0.0000045/GiB/secRAM

$0.00001/restoreSnapshot

Billed per second. No minimum. Cancel anytime.

// ready to ship?

Deploy your first sandbox in 30 seconds. No credit card.

Start Free →View on GitHub

$100 free credits • No credit card • Cancel anytime

free tier·MIT license·self-host

1import { Sandbox } from 'iris'

3const sandbox = await Sandbox.create()

5// your agent runs code fearlessly

6await sandbox.exec('python experiment.py')

8// something breaks? instantly roll back

9const checkpoint = await sandbox.checkpoint()

10await sandbox.exec('rm -rf /*') // oops

11await Sandbox.restore(checkpoint) // 0.8ms later, all good

1import { Sandbox } from 'iris'

3const sandbox = await Sandbox.create({

4 runtime: 'node:20'

5})

7await sandbox.exec('npm install')

8const snap = await sandbox.checkpoint()

9await Sandbox.restore(snap.id)

1import { Sandbox, state } from 'iris'

3// Session 1: agent builds knowledge

4const s1 = await Sandbox.create({ runtime: 'python:3.11' })

5await s1.exec('python research.py --topic ml-models')

6await state.project.set('findings', { models: [...], scores: [...] })

8// checkpoint flushes state — close-to-open guarantee

9const snap = await s1.checkpoint()

11// Session 2: picks up exactly where S1 left off

12const s2 = await Sandbox.restore(snap.id)

13const findings = await state.project.get('findings')

14// findings === everything S1 discovered, guaranteed