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.
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.
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 });
import asyncio, os
from solari_desktop import SolariClient
async def main():
pt = SolariClient(api_key=os.environ["SOLARI_API_KEY"])
# get a sandbox, ready to use
sbx = await pt.sandboxes.create(template="base")
await sbx.connect()
# first command runs in milliseconds
r = await sbx.commands.run(
"python train.py", on_stdout=lambda d: print(d, end=""))
# snapshot, then fork independent copies
snap = await sbx.snapshot("after-setup")
fork = await pt.sandboxes.create(from_snapshot=snap)
asyncio.run(main())
Stateful runCode returns typed png / svg / json. Matplotlib figures come back as structured charts.
Read, write, watch, and search a real filesystem, with signed upload / download for large files.
Grow a machine to the work at hand. The size survives pause and resume, no cold reboot.
Turn your image into a fast, ready-to-use machine with its own warm pool and your exact toolchain.
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.
A stateful code interpreter, a real filesystem, PTYs, and typed results, built for how agents work rather than retrofitted from a human IDE.
Every sandbox is its own Cloud Hypervisor microVM with a dedicated kernel. Model-written code can never reach the host or another tenant.
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.
Bake your exact toolchain into a custom template with its own warm pool, so every sandbox starts with the tools your agent needs.
Run Solari in your own cloud account, on-prem, or fully self-hosted for enterprise and compliance needs. Talk to us.
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.
Broken out by phase, milliseconds, shorter is faster.
| Solari | e2b | Modal | Daytona | CodeSandbox | |
|---|---|---|---|---|---|
| Create | 869 | 541 | 2070 | 2202 | 1321 |
| Run code | 7019 | 9868 | 6607 | 8531 | 17237 |
| Clean up | 269 | 401 | 3235 | 141 | 6234 |
| Total | 8158 | 10810 | 11912 | 13589 | 24792 |
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.
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.
One API key. A real, isolated machine, running your code in milliseconds.