CodeSandbox SDK vs smol machines
Both give each sandbox its own microVM with its own kernel. CodeSandbox SDK is strongest at VMs that hibernate with their memory and wake on the next HTTP request, while smol machines is strongest at an open-source engine you can run anywhere, live branches of a running machine and outbound allowlists.
The companies and products
CodeSandbox SDK
CodeSandbox SDK is an API from CodeSandbox, now a Together AI company, that starts sandboxed development VMs on the same infrastructure as the CodeSandbox editor.
Each sandbox is a Firecracker microVM built from a template or any Dockerfile. When it goes idle it hibernates with a memory snapshot, and it resumes or forks from that snapshot in seconds. You drive it from a TypeScript SDK through terminals, commands, files and HTTPS hosts. Together's docs now call it the legacy offering and point new users to its successor, the together-sandbox SDK.
smol machines
smol machines makes fast, isolated Linux microVMs that run the same way on your laptop, in their hosted cloud, or on your own servers.
The core is smolvm, an open-source microVM engine built on libkrun, where each machine has its own guest kernel. smol cloud is the paid hosted service that runs fleets of those machines behind a REST API and Node, Python and Rust SDKs. It is built for developers who want one VM model from local development to production, with live branching of running machines.
- Uptime SLA
- 99.95% on Pro, Startup and Enterprise
Which use cases each one fits
For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “46th cheapest of 345” means 45 of the other 344 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.
| Use case and its workload | CodeSandbox SDK: price rank | smol machines: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both run Docker inside the VM, but neither has SSH or /dev/kvm; bochka has both, plus coding agents you prompt and steer through an API. | 178th of 367, with limits $1,939 a month | 73rd of 367, with limits $604 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 215th of 366, with limits $2,478 a month | 148th of 366, with limits $1,038 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Both fit short code runs well: CodeSandbox SDK wakes hibernated VMs with their memory, and smol machines has a one-minute minimum that branches of a warm machine pay only once. | 46th cheapest of 345 $642 a month | 12th cheapest of 345 $140 a month | 186th of 345, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month smol machines fits up to 300 user sandboxes at once on Startup, while CodeSandbox SDK's Scale plan stops at 250 VMs; bochka fits too and adds a desktop and raw TCP for each user. | 140th of 361, with limits $1,707 a month | 7th cheapest of 361 $531 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Both can fork a running sandbox with its memory, so many rollouts start from one prepared state; bochka forks a running sandbox with its disk. | 348th of 360, with limits $3,861 a month | 111th of 360, with limits $6,978 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 64th cheapest of 364 $1,335 a month | 36th cheapest of 364 $670 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Neither offers nested virtualization on its hosted VMs, so CI jobs that build Android apps or boot VMs need bochka's /dev/kvm. | 92nd cheapest of 377 $860 a month | 66th cheapest of 377 $514 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A box that runs all day is billed by the hour on both, and a stopped smol machine still pays for its disk, while a stopped bochka sandbox costs nothing. | 310th of 368, with limits $240 a month | 216th of 368, with limits $29 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Neither CodeSandbox SDK nor smol machines hosts a desktop, so you build your own stack; bochka streams a Linux desktop at 60fps with computer use built in. | 206th of 369, with limits $691 a month | 90th of 369, with limits $156 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month CodeSandbox SDK has a headless Chromium template and smol machines has a guide for running your own Chromium; bochka ships Chromium on a full desktop. | 251st of 367, with limits $443 a month | 176th of 367, with limits $136 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 281st of 346, with limits $508 a month | 241st of 346, with limits $242 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 193rd of 338, with limits $7,390 a month | 148th of 338, with limits $4,344 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 240th of 360, with limits $326 a month | 252nd of 360, with limits $377 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Can't run it | Can't run it | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Can't run it | Can't run it | Can't run it |
Key features
| Feature | CodeSandbox SDK | smol machines | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | libkrun microVM with its own guest kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Biggest machine | Up to 16 cores / 32 GB on Scale, 64 cores / 128 GB on Enterprise | Up to 32 vCPU / 32 GB on Startup, 16 vCPU / 24 GB on Pro | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Pause and resume | Hibernates with a memory snapshot; an HTTP request wakes it with processes still running; no charge while hibernated | A stop keeps the filesystem and empties /tmp and memory; stopped disk keeps billing; the next command starts it again | Disk is saved every minute and on stop; a stopped sandbox costs nothing; resume boots it again by API |
| Fork | Fork a hibernated sandbox from its snapshot, or a running one sharing its memory | Branch a running machine with its memory and processes; checkpoints capture RAM to a file | Fork a running sandbox with its disk |
| Docker and root | Docker and root; built from any Dockerfile | Docker inside the machine, with its data on the ext4 disk | Docker, systemd and root |
| Nested virtualization | Not documented | Not exposed in the cloud API; a local smolvm flag only | Yes, /dev/kvm for Android emulators and VMs |
| Shell access | Terminals, commands and files through the SDK; no SSH | Command API, sessions and a WebSocket terminal capped at one hour per connection; no SSH | SSH, plus exec and files over the API |
| Inbound access | HTTPS host per port, public by default, signed tokens for private hosts; no raw TCP or public IP | Up to 16 published ports through a returned URL or an authenticated connect route; no dedicated IP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; a dedicated IPv4 or IPv6 |
| Outbound rules | No outbound allowlist | Blocked, open, or an allowlist of hosts and CIDR ranges | Open internet, no provider-side allowlist |
| Desktop and browser | No desktop; a headless Chromium template | No hosted desktop; a guide shows running your own Chromium inside a machine | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Coding agents | Run your own agent through the command API | Registry images with the Codex CLI and the Harbor eval harness, run through the command API | Seven agents preinstalled, including Claude Code and Codex, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets passed in as environment variables | Cloud secrets are environment variables the guest can read; placeholder credential swapping only in self-hosted smolvm | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Regions | A country hint steers scheduling, for example to Europe, but placement is not guaranteed | No region choice in the cloud API | EU only (Germany, Finland, France), with EU data residency |
| Self-hosting | Not offered | Open-source smolvm runs on your laptop or your own servers, with the same .smolmachine artifact | No, hosted only |
Every feature Battleships tracks (43)
| Feature | CodeSandbox SDK | smol machines | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | Yes | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | No | No | No |
| EU data residency | No | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for either CodeSandbox SDK or smol machines: neither was part of the StarSling hpc-sandbox-benchmarks run. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. smol machines publishes a boot time under 200ms for smolvm, which is a start-time figure, not CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. CodeSandbox SDK and smol machines have no published run in this suite yet, so there is no like-for-like number to compare.
Pricing in five scenarios
Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario.
| Scenario | CodeSandbox SDK, a month | smol machines, a month | bochka, a month |
|---|---|---|---|
| One coding agent, workdays 4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days | $193 · Scale | $25 · Standard | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $341 · Scale | $93 · Standard | $26 · $20/mo |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $2,500 · Scale | $1,139 · Pro | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $815 · Scale · with limits | $465 · Startup | $200 · $100/mo × 2 seats |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $1,632 · Scale · with limits | $1,389 · Startup | $2,000 · $2000/mo · with limits |
CodeSandbox SDK: You buy VM credits and each size burns a fixed number per hour, billed per started minute while the VM runs, including the idle time before it hibernates. Scale adds a $170 monthly platform fee that is not usage credit, and a hibernated VM costs nothing.
smol machines: smol cloud charges a base fee for every hour a machine runs, plus the CPU and memory the guest actually uses, with a one-minute minimum and disk billed even while stopped. Pro ($20 a month) and Startup ($150 a month) are fees on top of usage, not credit.
smol machines: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
CodeSandbox SDK's Scale plan allows 250 VMs at once, so 300 user sandboxes and 1,000 short jobs at once do not fit without Enterprise; each VM has a 20 GB disk, and the price for more disk and for egress is not published. smol machines caps machines by plan, 20 on Standard, 100 on Pro and 1,000 on Startup, with stopped machines still holding a slot, so 50 agents needs Pro and 1,000 short jobs needs Startup. bochka has no such cap at those sizes, but at 1,000 short jobs at once even its $2,000 plan queues starts above 90 a minute.
| Scenario | CodeSandbox SDK | smol machines | bochka |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
| None that bite | None that bite |
| 50 agents in parallel |
| None that bite | None that bite |
| Sandboxes for your users |
| None that bite | None that bite |
| 1,000 short jobs at once |
| None that bite |
|
Which one should you use?
Use CodeSandbox SDK when
your sandboxes sleep between visits and should wake on the next HTTP request with their memory intact, and you are fine building on what Together now calls its legacy SDK.
- Hibernation with memory, woken by a request. Good for previews and code runs used in bursts: an idle VM sleeps with its memory and wakes on the next HTTP request.
- Nothing billed while asleep. A hibernated CodeSandbox SDK VM costs nothing, while a stopped smol machine still pays for its disk.
- Very large machines on Enterprise. Teams that need one big machine can get up to 64 cores and 128 GB through Enterprise sales.
Use smol machines when
you want one open-source VM engine from your laptop to your own servers, fan out live branches of a running machine, or must limit outbound traffic to a list of hosts.
- Open source, from laptop to your own servers. Teams that want one VM engine locally, in a hosted cloud and on their own servers can use the open-source smolvm.
- Big bursts and many user sandboxes. Startup holds up to 1,000 machines, so 300 user sandboxes or 1,000 short jobs at once fit where CodeSandbox SDK's Scale stops at 250.
- Outbound allowlists and arm64. Teams that must limit which hosts a machine reaches, or need arm64 images, get both on smol cloud.
Where bochka fits
CodeSandbox SDK and smol machines are both good at small VMs that sleep, wake and fork fast. If what you are really running is agents that work for hours, with Docker, emulators, a browser and servers other people reach, bochka gives each one a whole machine with the agent and its keys already set up.
A whole machine, not just a VM boundary
Neither offers /dev/kvm or SSH on its hosted VMs, so Android emulators and nested VMs cannot start, and every tool goes through an SDK or exec call. smol's terminal also drops each connection after one hour.
Desktop, browser and agents built in
Neither hosts a desktop, so a computer-use agent waits until you build, package and maintain a desktop, Chromium and a screen stream. bochka streams a 60fps desktop and ships seven coding agents you drive from outside by API.
Keys that never enter the sandbox
Both hand secrets to the guest as environment variables, so one prompt injection can leak them. smol's credential swapping works only if you run smolvm on your own servers; bochka's credentials proxy covers any HTTPS API on the hosted service.
Use bochka when your agents do real work for hours: Docker, emulators, SSH, a desktop and a browser, servers on up to 50 ports, coding agents you drive from outside and keys that never enter the sandbox. Compare it one to one: bochka vs CodeSandbox SDK and bochka vs smol machines.
Questions people ask
Is CodeSandbox SDK cheaper than smol machines?
No, smol machines comes out cheaper in all five scenarios on this page. One coding agent on workdays is about $193 a month on CodeSandbox SDK against $25 a month on smol machines, and 50 agents in parallel is $2,500 a month against $1,139 a month. bochka is lower still in four of the five.
Which is faster, CodeSandbox SDK or smol machines?
Neither has a comparable CPU measurement, so there is no fair speed ratio between them. bochka did 26.69 runs per second on the StarSling Node.js benchmark at 4 vCPU / 8 GB. smol machines publishes a boot time under 200ms for smolvm, which measures start time, not CPU speed.
Can CodeSandbox SDK and smol machines run Docker?
Yes, both run Docker inside the VM. smol's guide says Docker data must live on the machine's ext4 disk. Neither exposes /dev/kvm on its hosted VMs, so Android emulators and nested VMs need bochka.
Can I SSH into either one?
No. CodeSandbox SDK connects through its SDK with terminals, commands and files, and smol cloud uses a command API and a WebSocket terminal capped at one hour per connection. Every bochka sandbox has SSH as well as an exec and files API.
Can I self-host either one?
smol machines, yes: the smolvm engine and SDK are open source and run on macOS, Linux and Windows hosts. CodeSandbox SDK does not offer self-hosting, and bochka is a hosted service only.
Is CodeSandbox SDK still maintained?
CodeSandbox is now part of Together AI. Together's docs call the CodeSandbox-based SDK deprecated and name together-sandbox as its successor, while self-serve sign-up still runs through CodeSandbox.
Try bochka
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs CodeSandbox SDK
- bochka vs smol machines
- E2B vs CodeSandbox SDK
- Daytona vs CodeSandbox SDK
- Modal vs CodeSandbox SDK
- Vercel Sandbox vs CodeSandbox SDK
- Cloudflare Sandbox vs CodeSandbox SDK
- Blaxel vs CodeSandbox SDK
- Runloop vs CodeSandbox SDK
- Tensorlake vs CodeSandbox SDK
- Morph Cloud vs CodeSandbox SDK
- CodeSandbox SDK vs Northflank