[ SANDBOXES ]

Run agent code
in its own microVM

Isolated compute for code, tools, and long-running tasks. Snapshot, fork, and resume in seconds.

Start for Free

View Docs

Install
npm install @solarisdk/sandbox
import { SandboxClient } from "@solarisdk/sandbox"
 
const sandboxes = new SandboxClient({
    apiKey: process.env.SOLARI_API_KEY!,
    baseUrl: "https://api.getsolari.com",
})
 
const sbx = await sandboxes.create({
    template: "base",
})
 
const res = await sbx.commands.run(
    "echo",
    {
        args: ["hello", "world"],
    }
)
 
console.log(
    res.exitCode,
    res.stdout
)
 
await sbx.kill()
One protocol, many clients. Every SDK uses the same REST + control-WebSocket contract, so sandboxes can be created in one language and controlled from another.

[

Benchmarks

]

See how Solari stacks up

Full Sandbox Lifecycle

Solari

8.2s

E2B

10.8s

Modal

11.9s

Daytona

13.6s

CodeSandbox

24.8s

Measured on the open-source Nibzard benchmark, Solari delivers the fastest end-to-end sandbox lifecycle.

8.2s

Full FFT lifecycle

Fastest sandbox in the field

8.2s

Full FFT lifecycle

Fastest sandbox in the field

30%

Faster than the next best

8.2s vs E2B 10.8s

Top 2

On every phase

The only provider never slower than second

Top 2

On every phase

The only provider never slower than second

Solari

E2B

Modal

Daytona

CodeSandbox

Create

869ms

541ms

2,070ms

2,202ms

1,321ms

Run code

7,019ms

9,868ms

6,607ms

8,531ms

17,237ms

Clean up

269ms

401ms

3,235ms

141ms

6,234ms

Total

8,158ms

10,810ms

11,912ms

13,589ms

24,792ms

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.

[

Efficiency

]

Thousands of agents, a fraction of the CPU

Five agents, one CPU core

Each agent waits on the model over 90% of the time

Agent 1

Agent 2

Agent 3

Agent 4

Agent 5

1 CPU core

Running a tool: on the CPUWaiting for the model: paused, CPU and memory freed for other agents

Agents spend over 90% of their time waiting for the model to reply. Solari pauses the sandbox during each wait and gives its CPU and memory to agents that are working, which cuts the CPU cost of running a fleet. In our tests, one 96-core host ran 6,000 agents.

Agents spend over 90% of their time waiting for the model to reply. Solari pauses the sandbox during each wait and gives its CPU and memory to agents that are working, which cuts the CPU cost of running a fleet. In our tests, one 96-core host ran 6,000 agents.

[

BUILT FOR AGENTS

]

Fast. Scalable. Stateful. Built for AI agents

Lightning-Fast Infrastructure

Start executing in milliseconds

Launch a ready sandbox in under 90 ms, with no machine boot delay before the first command.

Isolated Runtime Protection

Protect your infrastructure

Run model-generated code inside a dedicated microVM with its own kernel and hardware-backed isolation.

Massive Parallel Execution

Scale agent workflows instantly

Fork one prepared environment into independent workers for parallel tasks, retries, and evaluations.

[

Capabilities

]

Everything your agent needs

Snapshot and fork

Checkpoint a running sandbox, then launch as many independent copies as you need.

Isolated by design

Every session runs in its own microVM with its own kernel, so a breach in someone else’s never reaches your data.

Stateful execution

Run for hours, pause when idle, and resume exactly where you left off.

Bring your own image

Start every sandbox with your runtime, dependencies, and tools already installed.

Rich outputs

Return structured JSON, charts, images, files, logs, and execution metadata, not just plain text.

Persistent filesystem

Clone repositories, process documents, generate artifacts, and move large files through a persistent filesystem.

Scale on demand

Scale from 1 to 16 vCPUs without rebuilding the environment or losing state.

[

WORKLOAD ISOLATION

]

Keep untrusted code isolated from your infrastructure

Shared kernel

Own kernel per session

Implement in seconds

Change one import line and your existing code, profiles, and sessions keep working exactly as they did.

−from browserbase import Browserbase

+from solari import Solari

Isolated by design, so your data stays yours

Every session runs in its own machine with its own kernel, so a breach in someone else's session never reaches your data.

30% cheaper

Solari costs about 30% less than container-based providers at the same scale, because sessions start in milliseconds and stop billing when the work stops.

SolariMICROVM

E2BMICROVM

ModalGVISOR

DaytonaCONTAINER OR VM

DockerCONTAINER

Isolation technology

Cloud Hypervisor microVM

Firecracker microVM

gVisor sandbox

Linux container (default) or VM

Docker container

Dedicated kernel per session

Yes

Userspace kernel

VM sandboxes only

Untrusted code boundary

Hardware virtualization (KVM)

Syscall filtering

Container by default, VM optional

Shared Kernel

Security

★★★★★

★★★★☆

★★★☆☆

★☆☆☆☆

Isolation model per each vendor's published architecture. microVM (Solari, E2B) is the strongest tier; gVisor filters syscalls in userspace; Daytona runs containers by default and offers VM sandboxes with their own kernel; a standard Docker container also shares the host kernel.

Run model-generated and untrusted code without putting the rest of your infrastructure at risk. Each Solari sandbox gets its own microVM and dedicated kernel, creating a clear boundary between workloads.

[

FAQ

]

Before you deploy. Everything you need to know

A hardware-isolated microVM with its own kernel, ready in about 90 ms. Agents run commands, write files and install packages inside it without ever touching your systems.

Solari sandboxes execute untrusted, AI-generated code on hardware-isolated microVMs, fully separated from your systems. Each sandbox has its own kernel, so nothing it does can reach another workload or your infrastructure.

Yes. Idle machines pause automatically instead of shutting down, allowing you save states. The machine stops counting against your plan, and it picks up right where it left off on the next connect. Any running machine can also be snapshotted, rewound, or forked into independent parallel copies from one prepared starting point.

Yes. You can create a custom template with the image builder by picking a base OS, adding apt and pip packages, running your own setup commands, and setting environment variables. You can also snapshot a machine you set up by hand. Any machine launched from that template starts in about a second with your tools already in place.

Scale from 1 to 16 vCPUs with matching memory on demand, without rebuilding the environment or losing state. 20 GB of running disk is included.

Yes. Snapshot any running machine and launch independent copies from it in parallel, so one prepared environment becomes a fleet of identical workers in seconds.

We support TypeScript, Python, Go, Rust, and C++.

Yes. Team and Enterprise customers can deploy Solari in their own VPC on AWS, Google Cloud or Azure, or on their own hardware, including air-gapped networks. Details are on the Enterprise page at getsolari.com/enterprise.

[

FAQ

]

Before you deploy. Everything you need to know

A hardware-isolated microVM with its own kernel, ready in about 90 ms. Agents run commands, write files and install packages inside it without ever touching your systems.

Scale from 1 to 16 vCPUs with matching memory on demand, without rebuilding the environment or losing state. 20 GB of running disk is included.

Yes. Snapshot any running machine and launch independent copies from it in parallel, so one prepared environment becomes a fleet of identical workers in seconds.

We support TypeScript, Python, Go, Rust, and C++.

[

FAQ

]

Before you deploy. Everything you need to know

A hardware-isolated microVM with its own kernel, ready in about 90 ms. Agents run commands, write files and install packages inside it without ever touching your systems.

Scale from 1 to 16 vCPUs with matching memory on demand, without rebuilding the environment or losing state. 20 GB of running disk is included.

Yes. Snapshot any running machine and launch independent copies from it in parallel, so one prepared environment becomes a fleet of identical workers in seconds.

We support TypeScript, Python, Go, Rust, and C++.

Give every agent
a place to work

Browsers, sandboxes and desktops from one API. Start free and scale when you need to.

Start for Free

CONTACT SALES

Run agent codein its own microVM

See how Solari stacks up

Measured on the open-source Nibzard benchmark, Solari delivers the fastest end-to-end sandbox lifecycle.

8.2s

Full FFT lifecycle

8.2s

Full FFT lifecycle

30%

Faster than the next best

Top 2

On every phase

Top 2

On every phase

Thousands of agents, a fraction of the CPU

Agents spend over 90% of their time waiting for the model to reply. Solari pauses the sandbox during each wait and gives its CPU and memory to agents that are working, which cuts the CPU cost of running a fleet. In our tests, one 96-core host ran 6,000 agents.

Fast. Scalable. Stateful. Built for AI agents

Everything your agent needs

Snapshot and fork

Isolated by design

Stateful execution

Bring your own image

Keep untrusted code isolated from your infrastructure

Implement in seconds

Isolated by design, so your data stays yours

30% cheaper

Before you deploy. Everything you need to know

Before you deploy. Everything you need to know

Before you deploy. Everything you need to know

Run agent code
in its own microVM