Sub-millisecond VM sandboxes, built for the rollout phase.
Collimate spins up a real, hardware-isolated microVM per rollout in under a millisecond, then spins up a thousand more for kilobytes each. Bring any Docker image, branch live trajectories for tree search, and run untrusted agent code at training scale without the environment ever becoming your bottleneck.
A sandbox should not cost more than the work you run inside it. Container and microVM platforms spend tens to hundreds of milliseconds and tens of megabytes booting an environment for every rollout. Collimate boots your environment once, then spawns one on demand, so the marginal cost of another rollout is a fraction of a millisecond and a few kilobytes of RAM.
Run code in a VM
Send code to the hosted API, or to a dedicated deployment in your own cloud. Each call runs in a fresh, throwaway VM spawned from a template.
curl -X POST https://api.collimate.ai/v1/exec \
-H 'Authorization: Bearer col_live_...' \
-H 'Content-Type: application/json' \
-d '{"code":"import numpy as np; print(np.random.rand(3))","template_id":"python"}'from collimate import Sandbox
sb = Sandbox("col_live_your_key")
r = sb.run("import numpy as np; print(np.random.rand(3))", "python")
print(r.stdout) # [0.137 0.521 0.793]
print(r.fork_time_ms) # 0.7import { Sandbox } from "@collimate/sdk";
const sb = new Sandbox("col_live_your_key");
const r = await sb.run("console.log(40 + 2)", "node");
console.log(r.stdout, r.fork_time_ms);Built for the rollout phase
Collimate is environment infrastructure for agentic RL and post-training, not a general-purpose dev sandbox. Everything is tuned for the part of the loop that runs millions of times: spawning, branching, and tearing down isolated environments.
Real microVM isolation per rollout
Every sandbox is a full virtual machine with hardware-enforced (VT-x / AMD-V) memory isolation, rather than a container sharing the host kernel. Run untrusted, model-generated code and tool calls at training scale, with each trajectory contained at the silicon boundary.
Bring any Docker image
Point Collimate at any OCI image (your existing eval harness, a SWE-bench instance, a browser stack) and it becomes a spawnable template. Your image runs unmodified: its entrypoint, environment, and working directory behave exactly like docker run.
Branch live trajectories for tree search
Branch a running rollout mid-trajectory in single-digit milliseconds. Each branch resumes from the exact same state (files, processes, memory), so MCTS and RL tree search explore many continuations from one expensive prefix instead of replaying it.
Extreme memory density
VMs share their template's memory copy-on-write, so each one costs only the pages it actually changes: about 141 KB at a thousand concurrent VMs (and less as you scale). A single host sustains thousands of live rollouts. GRPO-scale fan-out becomes affordable.
Networked rollouts & fleets
Give each VM its own network egress for pip installs, API calls, or driving a live web app, and connect VMs to each other for multi-agent fleets: a coordinator talking to N explorers, all on one host.
Stateful environments for step loops
Hold a VM alive as a session and drive it across many steps (search, edit, test, repeat) with state persisting between calls. This is the exact shape an RL environment's step() loop needs.
How it works
Three phases. You pay the setup cost once; every rollout after that is nearly free.
1. BRING YOUR IMAGE 2. SNAPSHOT ONCE 3. SPAWN ON DEMAND [ docker image ] ─► [ warm template ] ─┬─► VM · rollout 1 <1 ms your env, unmodified booted & frozen, ├─► VM · rollout 2 ~141 KB ready to spawn ├─► VM · rollout 3 └─► VM · rollout N (1,000+) one-time cost per-rollout cost: a fraction of a millisecond
The point: environment startup stops being a line item. The wall-clock and memory you used to spend booting sandboxes goes back into rollouts, exploration, and reward.
By the numbers
Measured against the sandbox runtimes teams actually use for agent workloads.
| Metric | Collimate | Mainstream sandbox runtimes |
|---|---|---|
| Spawn latency (P50) | 0.65-1.2 ms | 27-200 ms |
| Memory per sandbox | ~141 KB | 50-128 MB |
| Concurrent sandboxes / host | 1,000+ tested | ~100-1,000 |
| Spawn speedup | 23-500× faster | baseline |
See Benchmarks & economics for the full measured results, methodology, and per-rollout cost.
Next steps
Get an API key and run your first rollout in five steps.
Start →Branch live rollouts for MCTS and tree search, without the replay tax.
Explore →Turn an existing eval or training environment into a spawnable template.
Learn how →The measured numbers and what a rollout actually costs.
See the data →