Sandboxes

Run code in a real machine.

A headless Linux VM that runs untrusted code, tools, and long tasks, ready in milliseconds from a warm pool. Stateful sessions, a real filesystem, and snapshots you can fork. Each one hardware-isolated, not a shared-kernel container.

Milliseconds to first code 1→16 vCPU per session Snapshot & fork
sandbox.ts
import { SolariClient } from "@solarisdk/sdk";

const pt = new SolariClient({ apiKey: process.env.SOLARI_API_KEY });

// get a sandbox, ready to use
const sbx = await pt.sandboxes.create({ template: "base" });
await sbx.connect();

// first command runs in milliseconds
const r = await sbx.commands.run("python train.py", {
  onStdout: (d) => process.stdout.write(d),
});

// snapshot, then fork independent copies
const snap = await sbx.snapshot("after-setup");
const fork = await pt.sandboxes.create({ fromSnapshot: snap });
How it works

Create, run, snapshot, fork.

Create step 01
Ask for a sandbox and get one back right away, ready to use, with no waiting for a machine to boot.
Run step 02
Your first command runs in milliseconds. Stream stdout, open a PTY, or run a stateful code cell that returns charts and JSON.
Snapshot & fork step 03
Checkpoint a running sandbox, then launch as many independent copies as you need. Idle forks cost almost nothing.
Pause step 04
Idle sessions pause on their own and stop billing. Resume later on any host, right where you left off.
Batteries included

Everything a code agent needs.

Code interpreterSBX

Rich results

Stateful runCode returns typed png / svg / json. Matplotlib figures come back as structured charts.

FilesystemSBX

Real files

Read, write, watch, and search a real filesystem, with signed upload / download for large files.

SizingSBX

1 → 16 vCPU

Grow a machine to the work at hand. The size survives pause and resume, no cold reboot.

Custom imagesSBX

Bring your own

Turn your image into a fast, ready-to-use machine with its own warm pool and your exact toolchain.

Built for agents

Made for how agents actually run.

Quick start

Secure start in ~90 ms

A warm pool hands your agent a ready sandbox in about 90 milliseconds, so there is no waiting for a machine to boot before the first command runs.

Agent native

Made for agents

A stateful code interpreter, a real filesystem, PTYs, and typed results, built for how agents work rather than retrofitted from a human IDE.

Isolation

Secure and isolated

Every sandbox is its own Cloud Hypervisor microVM with a dedicated kernel. Model-written code can never reach the host or another tenant.

Long-running

Runs for hours, persists for days

Idle sessions pause and resume with state fully intact, so a long agent task keeps its place across hours or days. Extended session limits available on request.

Custom images

Bring your own image

Bake your exact toolchain into a custom template with its own warm pool, so every sandbox starts with the tools your agent needs.

Enterprise

Bring your own cloud

Run Solari in your own cloud account, on-prem, or fully self-hosted for enterprise and compliance needs. Talk to us.

Benchmarks

Fastest sandbox, end to end.

The open-source nibzard benchmark runs the same heavy FFT workload on every provider and times the whole lifecycle: create the machine, run the code, tear it down. Solari finishes the round trip faster than any other sandbox.

Full lifecycle

create + run + clean up · seconds · shorter is faster
Solari
8.2s
e2b
10.8s
Modal
11.9s
Daytona
13.6s
CodeSandbox
24.8s
Same FFT test on every provider. Solari is never the slowest on any phase, so the end-to-end total comes out ahead.
8.2s
Full FFT lifecycle
fastest sandbox in the field
1.3×
Faster than the next best
8.2 s vs e2b 10.8 s
Top 2
On every phase
the only provider never slower than second

Broken out by phase, milliseconds, shorter is faster.

  Solari e2b Modal Daytona CodeSandbox
Create869541207022021321
Run code701998686607853117237
Clean up26940132351416234
Total815810810119121358924792

Metric: the open-source nibzard test_fft_performance lifecycle, same harness for every provider. Competitor figures are the benchmark's own published results. Solari run on Solari infrastructure at 1 vCPU / 8 GB (the FFT allocates about 4 GB, so every provider runs it sized to fit); the FFT is single threaded, so this reflects single-core speed. Solari's client is a region away from its gateway, so create and clean up are measured conservatively.

Isolation

Safe to run untrusted code.

Model-generated code is untrusted code. Every Solari sandbox is its own Cloud Hypervisor microVM with a dedicated kernel and a locked-down network. That is the strongest isolation tier there is, matched only by e2b, and a harder wall than a gVisor sandbox or a shared-kernel container.

  SolariMICROVM e2bMICROVM ModalGVISOR DaytonaSYSBOX
Isolation technology Cloud Hypervisor microVM Firecracker microVM gVisor sandbox Sysbox container
Own kernel per session ● Yes ● Yes ○ Userspace ○ No, shared
Boundary for untrusted code Hardware (KVM) Hardware (KVM) Syscall-filtered Shared kernel

Isolation model per each vendor's published architecture. microVM (Solari, e2b) is the strongest tier; gVisor filters syscalls in userspace; Sysbox hardens a container but shares the host kernel.

Get started

Spin up a sandbox in four steps.

One API key. A real, isolated machine, running your code in milliseconds.