CodeSandbox SDK vs Sprites
Both give each sandbox its own Firecracker VM that sleeps when idle and wakes on a request. CodeSandbox SDK lets you build the image from any Dockerfile and fork a running VM with its memory, while Sprites gives you one fixed 8 vCPU machine with coding agents preinstalled and bills only the CPU and memory it really uses.
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.
Sprites
Sprites is Fly.io's product for agents: persistent Linux computers you create by API or CLI, which sleep when idle and wake on the next request.
Each Sprite is a Firecracker microVM with 8 vCPU, memory the platform manages, and a 100 GB ext4 disk that syncs to object storage. It runs one managed Ubuntu image with Claude Code, Codex, Gemini CLI and Cursor preinstalled, gets an HTTPS URL that wakes it, and bills only for the CPU and memory it actually uses while awake. It is built for coding agents, dev environments and user code that sit idle most of the time.
- Isolation
- Firecracker microVM per Sprite
- Regions
- Not selectable for Sprites
- Free start
- $30 trial credit per organization
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 | Sprites: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Sprites ranks well ahead of CodeSandbox SDK for full-stack agent builds, but neither has systemd or /dev/kvm documented, which bochka adds along with SSH and many public ports. | 178th of 367, with limits $1,939 a month | 66th of 367, with limits $546 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 | 157th of 366, with limits $1,166 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 CodeSandbox SDK fits short code runs best of the three here: VMs hibernate with their memory and wake on the next request, while Sprites is cheaper but only a partial fit. | 46th cheapest of 345 $642 a month | 93rd of 345, with limits $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 Both wake a user's sandbox on their next HTTP request; CodeSandbox SDK stops at 250 VMs at once on Scale, and Sprites does not publish its cap. | 140th of 361, with limits $1,707 a month | 56th of 361, with limits $428 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 CodeSandbox SDK can fork a running VM with its memory, which suits branching rollouts, but its per-started-minute billing and 250-VM cap push its cost to $3,861 a month here. | 348th of 360, with limits $3,861 a month | 105th of 360, with limits $6,540 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 CodeSandbox SDK fully fits agent evals and can fork a warm VM per run, while Sprites only partly fits, with no fork and one fixed image. | 64th cheapest of 364 $1,335 a month | 125th of 364, with limits $545 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 Both fit CI runners; Sprites comes out cheaper at $476 a month against $860, and bochka adds /dev/kvm for Android and VM image builds. | 92nd cheapest of 377 $860 a month | 63rd cheapest of 377 $476 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A 24/7 dev box costs $27 a month on Sprites and $240 on CodeSandbox SDK, and bochka adds SSH and systemd for $26. | 310th of 368, with limits $240 a month | 213th of 368, with limits $27 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 Computer-use agents need a screen, and both CodeSandbox SDK and Sprites are headless, while bochka streams a 60fps desktop with Chromium. | 206th of 369, with limits $691 a month | 85th of 369, with limits $136 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 | 251st of 367, with limits $443 a month | 171st of 367, with limits $122 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 | 229th of 346, with limits $206 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 | 141st of 338, with limits $4,113 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 | 210th of 360, with limits $223 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 | Sprites | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | Firecracker microVM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | 2 to 16 cores self-serve, up to 32 GB on Scale; up to 64 cores and 128 GB on Enterprise | Fixed 8 vCPU; memory set and scaled by the platform | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Image | Built from a template or any Dockerfile | One managed Ubuntu 25.10 image; you install on top of it | Named snapshots to start new sandboxes from |
| Disk | 20 GB per VM; price for more not published | Fixed 100 GB disk that syncs to object storage | Disk saved every minute and on stop; a stopped sandbox costs nothing and keeps it |
| Idle and wake | Hibernates with a memory snapshot after an idle timeout of up to one day; an HTTP request wakes it | Pauses about 30 seconds after activity stops; a request wakes it in 100 to 500 ms with memory, or 1 to 2 s after a cold stop | Runs until you stop it or its time to live ends; resume boots the machine again |
| Fork | Fork a hibernated sandbox from its snapshot, or a running one sharing its memory | No fork in the public API or CLI; checkpoints restore in place | Fork a running sandbox with its disk into a new one |
| Inside the machine | Root and Docker; nested virtualization not documented | Root and Docker (with rough edges users report); no systemd, and no /dev/kvm in the docs | Root, Docker, systemd and /dev/kvm for emulators and VMs |
| Reaching the sandbox | Terminals, commands and files through the SDK; an HTTPS host per port, public by default; no SSH or raw TCP | One HTTPS URL to one HTTP port, private by default; other ports and SSH only through the sprite proxy CLI | SSH, HTTPS URLs for up to 50 ports, token-protected; raw TCP; a dedicated IPv4 or IPv6 |
| Outbound rules | No provider-side allowlist | Optional DNS-based domain allowlist set from outside; private IPs always blocked | Open internet, no provider-side allowlist |
| Keeping keys out of the sandbox | Secrets passed in as environment variables | Connectors gateway holds the token for GitHub, OpenRouter, Slack or any HTTP API, with path allow and block lists | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Run your own agent through the command API | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Desktop and browser | No desktop; a headless Chromium template | Headless; no desktop or browser product | Linux desktop streamed at 60fps, Chromium and computer-use tools |
| Integrations and status | TypeScript SDK; Together now calls it the legacy SDK and points new users to together-sandbox | Remote MCP server, agent plugins, and backends for Claude Managed Agents and Cursor Cloud Agents | REST API, CLI and SDKs |
| Regions | A country hint steers scheduling, for example to Europe, but placement is not guaranteed | Region not selectable | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | CodeSandbox SDK | Sprites | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | No | 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 | Yes | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | Yes | No | 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 | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | 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 | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | No | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for CodeSandbox SDK or Sprites: neither is in the hpc-sandbox-benchmarks results we use. bochka did 26.69 runs per second on the Node.js build-and-test benchmark at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. A Sprite always has 8 vCPU, so a fair test would need a matching shape.
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 Sprites 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 | Sprites, 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 | $23 · Pay-as-you-go | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $341 · Scale | $92 · Pay-as-you-go | $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,120 · Pay-as-you-go | $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 | $314 · Pay-as-you-go · with limits | $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,134 · Pay-as-you-go · with limits | $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 platform fee each month that is not usage credit, and a hibernated VM costs nothing.
Sprites: Sprites bills measured CPU time at $0.0385 per CPU-hour and actual memory at $0.021875 per GB-hour, only while the Sprite is awake, plus storage on the bytes you write. Optional plans buy fixed CPU, memory and storage allowances that are not credit.
Sprites: 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 sandboxes for your users and 1,000 jobs at once do not fit without Enterprise, and each VM has a 20 GB disk with no published price for more or for egress. Sprites does not publish how many can run at once on pay as you go and creates 10 a minute without a plan, so those two scenarios are not confirmed either. bochka has no session cap on paid plans, but at 1,000 short jobs at once even its $2,000 plan queues starts above 90 a minute.
| Scenario | CodeSandbox SDK | Sprites | 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 |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use CodeSandbox SDK when
you need your own Dockerfile image, forks that carry a running VM's memory, or machines bigger than 8 vCPU, and you are fine building on what Together now calls its legacy SDK.
- Your own image. Teams with a specific stack can build each sandbox from any Dockerfile instead of installing on top of a fixed image.
- Forks that share memory. Good for branching many runs from one warm state: fork a running VM, and the copy starts with its memory.
- Bigger machines when you need them. You pick from 2 to 16 cores self-serve, and Enterprise goes up to 64 cores and 128 GB.
Use Sprites when
your agents sit idle most of the day and should wake on a request, you want coding agents preinstalled, or you need a domain allowlist on outbound traffic.
- Pay for what the machine really uses. Sprites bills measured CPU time and actual memory only while awake, so a mostly idle agent costs little.
- Agents and limits ready to go. Claude Code, Codex, Gemini CLI and Cursor come preinstalled, with a domain allowlist and API connectors that keep tokens outside.
- Plugs into agent platforms. Teams on Claude Managed Agents or Cursor Cloud Agents can use Sprites as the machine behind them, next to the rest of Fly.io.
Where bochka fits
CodeSandbox SDK and Sprites are both built around sandboxes that sleep between bursts of work. If your agents work for hours on one machine, need SSH, systemd, emulators, a screen or servers others can reach, and you want to drive them from your own code, look at bochka.
A full machine that stays up
bochka runs systemd, Docker, SSH and /dev/kvm and keeps going until you stop it. CodeSandbox SDK has no SSH or documented nested virtualization, and a Sprite has no systemd and pauses 30 seconds after work stops unless a task hold, renewed every hour, keeps it awake.
Agents you drive from outside
bochka preinstalls seven coding agents and lets you prompt, steer and follow them through one API, with keys kept in a credentials proxy. On CodeSandbox SDK you build the harness and pass keys as environment variables; on Sprites you run agents through exec and watch them yourself.
A screen for computer use
Every bochka sandbox has a 60fps Linux desktop with Chromium and computer-use tools. Both CodeSandbox SDK and Sprites are headless, so you would install a display server, a browser and a streaming layer yourself before a computer-use agent can see anything.
Use bochka when your agents need a full machine for hours: systemd, Docker, emulators, SSH, many ports, a desktop and browser, forks, and an API to drive the agents inside from outside. Compare it one to one: bochka vs CodeSandbox SDK and bochka vs Sprites.
Questions people ask
Is CodeSandbox SDK cheaper than Sprites?
Not in the scenarios we priced. One coding agent on workdays is $193 a month on CodeSandbox SDK, $23 on Sprites and $20 on bochka; one agent that never stops is $341 against $92, and 50 agents in parallel are $2,500 against $1,120, with bochka at $317.
Which is faster, CodeSandbox SDK or Sprites?
Neither has a comparable CPU measurement in the benchmark we use, so we cannot say. Sprites' docs say a paused Sprite wakes in 100 to 500 ms with its memory; bochka did 26.69 runs per second at 4 vCPU / 8 GB.
Can CodeSandbox SDK and Sprites run Docker?
Both run Docker inside the VM, and CodeSandbox SDK can build the whole sandbox from any Dockerfile. On Sprites, users report that docker exec fails for containers whose main process is not root, and there is no systemd. bochka runs Docker, systemd and /dev/kvm.
Can I fork a sandbox on either?
CodeSandbox SDK can fork a hibernated sandbox from its snapshot or a running one sharing its memory. Sprites has no fork; its checkpoints restore the disk in place. bochka forks a running sandbox with its disk into a new one.
Can I SSH into CodeSandbox SDK or Sprites?
CodeSandbox SDK connects through its SDK clients with terminals, commands and files, with no SSH. On Sprites you install an SSH server yourself and tunnel it through the sprite proxy CLI. Every bochka sandbox has SSH, raw TCP and a dedicated IP.
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 Sprites
- 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