Skip to main content

00Cloud computers for AI agents

Always available. Without always-on compute costs.

Give every user their own cloud computer. Preserve the whole writable root filesystem, let it grow automatically, and pause compute between tasks. Resume on demand.

Start BuildingRead the Docs
whole RootFS persistsautomatic RootFS growthmanaged cloud runtime
RootFS persists. Compute on demand.run / pause / resume

Compute while working

alloc/sb-agent-7f29gVisor

The entire writable RootFS stays

System
/usr + /etc
User files
/home + /workspace
Growth
automatic online
Storage
durable + encrypted

Compute when needed

alloc/sb-agent-a914same identity

ROOTFS

Whole filesystem, automatic growth

$0.02 / GiB-month of retained incremental storage; shared base images excluded

BETWEEN TASKS

Pause compute, keep the work

NEXT TASK

Resume the same sandbox

CLOUD COMPUTE

$0.015 / GiB-hour

≈$0.000004167 / GiB-second · billed by the second

01A cloud computer for every user

Keep the whole RootFS. Release idle compute.

An agent's environment includes installed software, system configuration, caches, and user files spread across the filesystem. Sandbox0 preserves that entire writable RootFS across successful checkpoints, while compute can pause between tasks.

01

RUN

A full system for each user.

Let agents install software and write throughout the root filesystem. Keep system configuration, tools, dependencies, and user files across successful checkpoints.

+ the whole writable RootFS

02

PAUSE

Stop paying for paused compute.

Checkpoint the writable RootFS and release compute between tasks. On Sandbox0 Cloud, paused sandboxes incur no compute charges.

+ RootFS kept, compute released

03

RESUME

Wake the same environment.

Resume explicitly, or enable automatic wake-up through supported access paths. Return to the same sandbox and its entire committed writable RootFS.

+ resume on demand

Configure pause and wake-upRootFS snapshotsExplore idle compute savings

Compute billing stops when a Cloud sandbox is paused; an idle sandbox that stays running still accrues compute charges. Default pause/resume preserves files and starts fresh processes. Experimental memory checkpoints can also restore supported process state. Wake-up takes time and depends on available capacity.

02Persistent, automatically growing RootFS

The whole filesystem grows with your agent.

Install tools in /usr/local, change configuration in /etc, and keep data under /home or /workspace. The writable RootFS grows online as it fills. Incremental checkpoints and demand reads keep pause and resume from copying the entire filesystem.

Storage costs $0.02/GiB-month for the changes you keep. Shared base images and platform recovery copies are on us; snapshots and forks count shared data once within your team. How storage billing works →

Automatic online growth

Start small. Grow as needed.

Growth-enabled templates expand the root filesystem as free space runs low, within the configured device limit. The agent keeps running, with the same paths and open files.

Incremental pause

Save the changes, reuse the rest.

Checkpoints publish the writable branch's changes and reuse unchanged blocks from the committed generation. Existing filesystem data does not need another full copy each time you pause.

On-demand resume

Read what the agent needs.

Fresh compute attaches the committed RootFS and fetches blocks as the workload reads them. Your agent can start without downloading the entire accumulated filesystem first.

Automatic growth applies to growth-enabled image imports; existing images and snapshots retain their captured filesystem geometry. Pause and resume avoid full-RootFS copies. Actual time still depends on unpublished writes, metadata, cache state, storage access, and the workload's read working set. Optional memory checkpoints also depend on execution-state size.

How RootFS growth works

03Agent-native workflow

The same controls for humans and agents.

Codex, Claude Code, Cursor, or any shell-capable harness can use the s0 CLI from registration through observability. No dedicated plugin is required.

  1. 01

    Register & authenticate

    Device login, teams, and scoped API keys.

    $ s0 auth login
  2. 02

    Build & operate

    Sandboxes, commands, files, services, templates, and snapshots.

    $ s0 sandbox exec <id> -- npm test
  3. 03

    Observe

    Stream logs and events; query bounded runtime metrics.

    $ s0 sandbox logs <id> --watch
Create Your AccountOpen Quickstart
Cloud quickstartPython 3.9+
$ s0 auth login
$ export SANDBOX0_TOKEN="$(s0 apikey create --name agent --role developer --raw)"
$ pip install sandbox0
import os
from sandbox0 import Client

client = Client(token=os.environ["SANDBOX0_TOKEN"])
with client.sandboxes.open("default") as sandbox:
    result = sandbox.run("python", "print('Hello from Sandbox0')")
    print(result.output_raw, end="")

Agent entry point

/llms.txt

Raw Markdown

/docs/sandbox.md

Built for long-running agents

Build on Sandbox0 Cloud.

Use the APIs, open-source SDKs, templates, and s0 CLI to build on a managed runtime with persistent workspaces and on-demand compute. Self-hosting is no longer supported. Bring Your Own Cloud (BYOC) is planned and is not available yet.

Deployment Options

04Ready when your agent is

Give every user a computer their agent can come back to.

Start on Sandbox0 Cloud. Keep each user's entire writable RootFS, let it grow with their agent, and pay for compute while their sandbox is running.

Start BuildingSee Pricing