Sprites vs Together Code Sandbox
Sprites gives each agent a persistent Linux VM you can sign up for today, which sleeps when idle and wakes on the next request. Together Code Sandbox starts VMs from Docker-image snapshots and can save their memory when they end, but Together has to turn it on for your organization.
The companies and products
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
Together Code Sandbox
Together AI is a cloud for running and training AI models, and Code Sandbox is its product for running code in isolated VMs.
You build a snapshot from a Docker image or Dockerfile on Together's builder, then start sandboxes from it and run commands and file operations through the together-sandbox SDK or CLI. When a sandbox ends you can save its disk, and its memory too, as a new snapshot to start more sandboxes from. It is aimed at model-generated code, agent tool calls and reinforcement learning rollouts, and it must be enabled for your organization by Together. Together also sells Code Interpreter, a separate API that runs Python code in short sessions.
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. “63rd cheapest of 377” means 62 of the other 376 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 | Sprites: price rank | Together Code Sandbox: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both need work for a full-stack build: Sprites has no systemd and one public port, Together does not document Docker inside, and bochka has Docker, systemd, /dev/kvm and up to 50 HTTPS ports. | 66th of 367, with limits $546 a month | 65th of 367, with limits $528 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Sprites pauses about 30 seconds after work stops and Together has no idle detection at all, while bochka keeps an always-on assistant running until you stop it. | 157th of 366, with limits $1,166 a month | 152nd of 366, with limits $1,095 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 Sprites suits short code runs because it bills only real CPU and memory while awake; Together's Code Interpreter runs only Python, billed per 60-minute session. | 93rd of 345, with limits $140 a month | 326th of 345, with limits $2,190 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 Sprites gives each user a private HTTPS URL that wakes the machine, Together makes every port public with preview URLs still coming soon, and bochka adds token-protected URLs on up to 50 ports. | 56th of 361, with limits $428 a month | 234th of 361, with limits $900 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 Together can save a sandbox with its memory and start many copies from it, which suits rollouts that branch from one warm state; Sprites checkpoints restore in place, and bochka forks a running sandbox. | 105th of 360, with limits $6,540 a month | 315th of 360, with limits $21,900 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 | 125th of 364, with limits $545 a month | 258th of 364, with limits $450 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 | 63rd cheapest of 377 $476 a month | 251st of 377, with limits $180 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 wants SSH and systemd; bochka has both, Sprites tunnels SSH through its CLI, and Together offers shells only through its SDK and CLI. | 213th of 368, with limits $27 a month | 210th of 368, with limits $22 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 Sprites nor Together has a desktop or a browser, while bochka streams a 60fps desktop with Chromium in every sandbox. | 85th of 369, with limits $136 a month | 184th of 369, with limits $600 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 | 171st of 367, with limits $122 a month | 301st of 367, with limits $900 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 | 229th of 346, with limits $206 a month | 219th of 346, with limits $180 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 | 141st of 338, with limits $4,113 a month | 124th of 338, with limits $3,600 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 | 210th of 360, with limits $223 a month | 167th of 360, with limits $150 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 | Sprites | Together Code Sandbox | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | A VM per sandbox on Together's infrastructure | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Getting started | Sign up yourself, with $30 of trial credit per organization | The VM SDK and CLI must be enabled for your organization by Together; only Code Interpreter is self-serve | Sign up and start a sandbox from the API, CLI or dashboard |
| Machine size | Fixed 8 vCPU and 100 GB disk; memory set and scaled by the platform | 0.1 to 16 cores, 1 to 8 GB of memory per core; disk size fixed | 2 to 16 vCPU with 2 GB per vCPU, up to 16 vCPU / 32 GB on the $100 plan and above |
| Inside the machine | Root and Docker, with rough edges users report; no systemd, and no /dev/kvm in the docs | Commands run as user 1000 by default, root on request; Docker inside and nested virtualization not documented | Root, Docker, systemd and /dev/kvm for Android emulators and VMs |
| Idle behavior | Pauses about 30 seconds after work stops and wakes on the next request in 100 to 500 ms | Runs until you end it or its time to live, counted from creation, runs out; no idle detection and no wake on request | Runs until you stop it or its time to live ends; a stopped sandbox costs nothing |
| Saving state | Filesystem checkpoints by hand or automatic; restore replaces the current disk in place | End a sandbox with a snapshot of its disk, or disk and memory; new sandboxes resume with processes running | Disk saved every minute and on stop; named snapshots to start new sandboxes from |
| Fork | No fork in the public API or CLI | No live fork: the parent stops, then you start many sandboxes from its snapshot | Fork a running sandbox with its disk; the original keeps running |
| Reaching the sandbox | One HTTPS URL to one HTTP port, private by default; other ports and SSH only through the sprite proxy CLI | All ports public; preview URLs coming soon; an experimental inbound allowlist; no SSH | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6; SSH |
| Outbound rules | Optional DNS-based domain allowlist set from outside; private IPs always blocked | No outbound allowlist documented | Open internet, no provider-side allowlist |
| Keeping keys out of the sandbox | Connectors gateway holds the token for GitHub, Slack or any HTTP API, with path allow and block lists | No credentials proxy documented | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | Run your own agent through execs; a Harbor guide for agent evals | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Desktop and browser | Headless; no desktop or browser product | None; headless command and file access only | 60fps Linux desktop with Chromium, computer use and an embeddable stream |
| Hosted code interpreter | No separate product; run code through exec | Code Interpreter API runs Python in sessions billed per 60 minutes | No separate product; run code through exec in a sandbox |
| Agent platform integrations | Remote MCP server, agent plugins, and backends for Claude Managed Agents and Cursor Cloud Agents | Same account and API key as Together's model inference and fine-tuning | REST API, CLI and SDKs |
Every feature Battleships tracks (43)
| Feature | Sprites | Together Code Sandbox | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | 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 | No | Yes | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | 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 | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | No | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Sprites or Together Code Sandbox: neither is in the hpc-sandbox-benchmarks results we use. bochka did 26.69 runs per second on the Node.js build-and-test test at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Sprites and Together Code Sandbox 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 | Sprites, a month | Together Code Sandbox, 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 | $23 · Pay-as-you-go | $5 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $92 · Pay-as-you-go | $22 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $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 | $1,120 · Pay-as-you-go | $264 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $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 | $314 · Pay-as-you-go · with limits | $900 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · 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,134 · Pay-as-you-go · with limits | $6,000 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $2,000 · $2000/mo · with limits |
Sprites: Sprites bills 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 include fixed CPU, memory and storage allowances that are not credit.
Together Code Sandbox: Together lists Code Sandbox at $0.0446 per vCPU-hour and $0.0149 per GiB-hour, but the VMs must be enabled for your organization, so the tables price Together with Code Interpreter: $0.03 per 60-minute session from prepaid credits, with a $5 minimum.
Together Code Sandbox: Plans start at $20 a month, and the whole fee is usage credit. You pay per second for the size you pick while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
The Together column is Code Interpreter, so it fits none of the scenarios: sessions last 60 minutes, nothing is kept after a session, it runs only Python, and the machine size is not published. Sprites fits the single agent and 50-agent scenarios, but it does not publish how many Sprites can run at once on pay as you go, so 300 sandboxes for your users and 1,000 jobs at once are not confirmed. A Sprite also pauses when idle, so an always-on agent needs a task hold that lasts at most an hour and must be renewed. On bochka the limit that bites is starts: 1,000 short jobs at once need more starts per hour and per day than even the $2,000 plan allows.
| Scenario | Sprites | Together Code Sandbox | 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 Sprites when
you want to start today and your agents or apps sit idle most of the day, wake on a request, and need a domain allowlist on outbound traffic.
- Sleeps when idle, wakes on request. For agents and apps idle most of the day: a Sprite stops billing compute and wakes on the next request.
- Open to sign up today. For teams that want to start now: anyone can create Sprites with a trial credit, while Together's VMs need Together to enable them.
- Outbound allowlist and API connectors. For locked-down agents: limit which domains a Sprite reaches and which API paths a stored token can call.
Use Together Code Sandbox when
you already run models on Together, can get the VMs enabled, and want light sandboxes you save with their memory and branch from, or a simple Python runner.
- Memory snapshots to branch from. For rollouts and test variants: save a sandbox with its memory and start many copies with processes still running.
- Very small machines. For many light jobs: a sandbox can be as small as a tenth of a core, with 1 to 8 GB per core.
- Sandboxes next to your models. For teams already running inference on Together: sandboxes, the Python runner and models share one account and API key.
Where bochka fits
Sprites is built for machines that sleep most of the day, and Together Code Sandbox for sandboxes you save and branch from, once Together turns it on. If your agents do real work for hours, with Docker, services, emulators, a browser and servers other people reach, bochka gives each one a full VM you can start today.
A full machine with systemd and /dev/kvm
Sprites has no systemd and no /dev/kvm in its docs, and Together does not document Docker inside or nested virtualization. Compose stacks and emulator builds then need rewriting or baking into an image, while bochka runs Docker, systemd and /dev/kvm as they are.
Hosting and SSH without a proxy
A Sprite serves one HTTP port, with SSH and other ports only through a CLI tunnel on your machine, and Together makes every port public with no preview URLs yet. bochka gives SSH, raw TCP and token-protected HTTPS on up to 50 ports.
Agents, a desktop and forks built in
Both are headless, and on both you write the code that starts and watches each agent. bochka preinstalls seven coding agents with an API to drive them from outside, streams a 60fps desktop with Chromium, and forks a running sandbox without stopping it.
Use bochka when your agents need a full machine for hours: Docker, systemd, 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 Sprites and bochka vs Together Code Sandbox.
Questions people ask
Is Sprites cheaper than Together Code Sandbox?
Together's only self-serve price is Code Interpreter, which does not fit these scenarios because sessions end after 60 minutes and keep no disk. It looks cheaper for 50 agents, $264 against $1,120 a month on Sprites, but costs more at scale: $900 against $314 for sandboxes for your users, and $6,000 against $1,134 for 1,000 short jobs at once. bochka comes to $317, $200 and $2,000 for those three.
Which is faster, Sprites or Together Code Sandbox?
Neither has a comparable CPU measurement, so we cannot say. A Sprite always has 8 vCPU, while a Together sandbox can be sized from 0.1 to 16 cores. bochka did 26.69 runs per second on the Node.js test at 4 vCPU / 8 GB.
Can Sprites and Together Code Sandbox run Docker?
Users run Docker on Sprites, with some rough edges, but Sprites does not run systemd. Together builds sandboxes from Docker images, but its new SDK does not document Docker inside a sandbox. bochka runs Docker, systemd and /dev/kvm in every sandbox.
Does each keep running when I am not using it?
A Sprite pauses about 30 seconds after activity stops and wakes on the next request; a task hold keeps it awake for up to an hour at a time. A Together sandbox runs until you end it or its time to live runs out, with no idle pause and no wake on request. A bochka sandbox runs until you stop it.
Can I sign up for Together Code Sandbox today?
Only partly. Code Interpreter is self-serve with prepaid credits, but the together-sandbox SDK and CLI for VMs must be enabled for your organization, so you ask Together for access. Sprites and bochka both let you sign up and start right away.
Can either save a sandbox with its memory?
Together can: when a sandbox ends it can save its disk and memory, and new sandboxes come back with their processes running. Sprites keeps memory only while paused and its checkpoints save the filesystem. bochka saves the disk every minute and can fork a running sandbox.
Try bochka
Install the CLI, then run bochka new.
Product preview