run9 · Sandboxes run.sys9.ai · live

Fork the whole machine in ~50ms.

A serverless, forkable Linux sandbox for agents. Fork the entire OS — data and apt packages included — run up to 1,000,000 in parallel, and pay only while they run. Drive it over SSH like any box. Boot-free: it wakes on a call and sleeps on idle, with sealed secrets attached at the network edge.

Spin up a sandbox Read the docs →

Fork in ~50msUp to 1M in parallelPay only when runningDrive via SSH

fork & shard

Fork the OS. Run a hundred at once.

A fork copies the whole sandbox — filesystem, data, and installed packages — in about 50ms. Spin up 100 in parallel to shard an integration suite, branch the whole stack, or hand each agent its own clean machine. You pay only for the moments they run.

~50ms fork up to 1M in parallel data + apt included

run9

# spin up a sandbox from a base image
$ run9 create --from ubuntu
  ✓ sbx_acme ready · sub-second start

# fork the whole OS — data + apt packages — 100×
$ run9 fork sbx_acme --count 100
  ✓ 100 forks live · ~50ms each

# shard an integration suite across every fork
$ run9 ssh sbx_acme -- pytest -n 100
  ✓ 100 shards passed in 8.2s

drive via SSH · boot-free

It's a real Linux box. Drive it over SSH.

No bespoke API to learn — connect over SSH and run anything: install packages, build, test, exec. Sandboxes are boot-free, so they wake on the next call and sleep when idle. Secrets are sealed and attached at the network edge, never baked into the image.

standard SSH wake on call sealed secrets at the edge

run9

# it's just SSH — drive it like any Linux box
$ run9 ssh sbx_acme
  acme@sbx_acme:~$ apt-get install -y ripgrep
  acme@sbx_acme:~$ ./build.sh && ./run.sh

# boot-free: wakes on call, sleeps on idle
$ run9 ls
  sbx_acme   running   2m
  sbx_q1     sleeping  —     (wakes on next call)

how it works

Create. Fork. Sleep.

A sandbox is a snapshot you can copy in milliseconds. Start one, fork it as wide as you need, and let idle ones sleep — the meter only runs while they do.

01 · Create

Start from any base

Boot a sandbox from a base image with run9 create. Install packages, drop in your repo, set it up once — that whole state becomes the thing you fork.

02 · Fork

Copy it in ~50ms

run9 fork clones the entire OS — data and apt packages included — in about 50ms. Run up to 1,000,000 forks in parallel, each isolated, each a faithful copy of the original.

03 · Sleep

Pay only when running

Boot-free sandboxes wake on a call and sleep on idle. You're billed for active moments, not for capacity sitting around waiting for work.

patterns

What teams build on forks.

The same primitive — a millisecond OS fork — turns into very different workflows.

Sharded integration tests

Fork the prepared environment once per shard and run the suite 100-wide. Sub-second start means the fan-out is the test run, not the setup.

Branch the whole stack

Fork the entire machine — app, services, data — to try a risky change in isolation. Throw the fork away when you're done; the original never moved.

Many agents, one repo

Give every agent its own fork of the same repo and toolchain. They work in parallel without stepping on each other, then merge what survives.

combines with

One substrate. Composes with the rest of sys9.

run9 is the compute layer; pair it with storage, data, hosting, and observability — same agent-native stack.

drive9

get started

Hand an agent a machine it can fork.

run9 is live. Use-first, claim-later — no signup to start. Install the CLI or point your agent at the sys9 skill.

Install the sys9 CLI Read the docs →