Sprites vs OpenAI Containers

Sprites gives each agent its own Linux VM with root, Docker and a 100 GB disk that stays, and it sleeps when idle. OpenAI Containers are short-lived boxes inside OpenAI's model API, where the model runs code until the box expires after 20 minutes without use.

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.

Company: Fly.io, which also sells Fly Machines and Managed Postgres
Isolation: Firecracker microVM per Sprite
Machine shape: Fixed 8 vCPU and 100 GB disk; memory is set and scaled by the platform
Image: One managed Ubuntu 25.10 image; you install on top of it
Regions: Not selectable for Sprites
Compliance: SOC 2 Type II; HIPAA package with a pre-signed BAA on paid plans
Free start: $30 trial credit per organization

OpenAI Containers

OpenAI Containers are the sandboxes OpenAI runs for its own model tools: Code Interpreter, Hosted Shell and the Agents API's hosted sandbox.

This is a different kind of product from bochka: a tool inside OpenAI's model API, not a machine you rent. You create a container through the API or let a Responses call make one, and the model runs Python or shell commands in it on a fixed Debian 12 image without sudo, until it expires after 20 minutes without use. It is built for apps that already call OpenAI models and want them to run code, read files and make charts without running any servers.

Isolation: Each container is described as a fully sandboxed virtual machine; the hypervisor is not named
Runtime: Debian 12 with Python 3.11, Node.js 22.16, Java 17, PHP 8.2, Ruby 3.1 and Go 1.23; commands do not run with sudo
Sizes: Picked by memory: 1 GB (default), 4 GB, 16 GB or 64 GB; vCPU per size not published for Responses containers
Lifetime: A container expires after 20 minutes without use, and its data is discarded
Billing: By the minute with a 5-minute minimum per session, on top of model tokens
Regions: Code Interpreter processing in the United States or Europe; the Agents API supports data residency only in the US
Compliance: API Platform audited for SOC 2 Type 2; HIPAA BAA on request

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	OpenAI Containers: price rank	bochka: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent that keeps a repo for days needs a disk that stays: Sprites keeps one, an OpenAI container discards its data when it expires, and bochka adds systemd and /dev/kvm.	66th of 367, with limits $546 a month	356th of 367, with limits $17,371 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant keeps its files on Sprites but its open connections drop on every pause; an OpenAI container is deleted after 20 idle minutes; bochka just keeps running.	157th of 366, with limits $1,166 a month	341st of 366, with limits $13,140 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 Running model-written code is what OpenAI Containers are built for, with no machine to manage; Sprites also fits, since it sleeps about 30 seconds after the last command and bills only real CPU and memory.	93rd of 345, with limits $140 a month	194th of 345, with limits $6,000 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 persistent VM with an HTTPS URL that wakes it, while an OpenAI container has no inbound access at all; bochka adds SSH, raw TCP and up to 50 HTTPS ports.	56th of 361, with limits $428 a month	361st of 361, with limits $3,780 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	105th of 360, with limits $6,540 a month	191st of 360, with limits $30,000 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	360th of 364, with limits $5,760 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 CI needs Docker, root and open internet: Sprites has all three, OpenAI documents no Docker or root, and bochka also exposes /dev/kvm for Android and VM builds.	63rd cheapest of 377 $476 a month	345th of 377, with limits $1,728 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Neither Sprites nor OpenAI Containers give direct SSH, and only Sprites keeps a disk; bochka has SSH, systemd and a disk saved every minute.	213th of 368, with limits $27 a month	362nd of 368, with limits $1,051 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 OpenAI's Agents API has a hosted browser for computer use and Sprites is headless; bochka streams a full 60fps desktop with Chromium that you can embed.	85th of 369, with limits $136 a month	351st of 369, with limits $5,280 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 OpenAI's hosted browser is driven by its own Codex harness, on Sprites you install a headless browser yourself, and bochka ships Chromium on a desktop you can watch.	171st of 367, with limits $122 a month	328th of 367, with limits $1,440 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	328th of 346, with limits $1,755 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	311th of 338, with limits $35,100 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	308th of 360, with limits $870 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	OpenAI Containers	bochka
What it is	A persistent Linux computer for agents that you create by API or CLI	A sandbox tool the model uses inside OpenAI's API	A cloud VM you create, keep, stop and reach from outside
Isolation	Firecracker microVM with its own kernel	Described as a fully sandboxed virtual machine; hypervisor not named	Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts
Root and Docker	Root and Docker (with rough edges users report); no systemd, no /dev/kvm in the docs	Commands do not run with sudo; no Docker or /dev/kvm documented	Root, systemd, Docker and /dev/kvm on every machine
Machine size	Fixed 8 vCPU and 100 GB disk; memory managed and scaled by the platform	1, 4, 16 or 64 GB of memory; vCPU not published for Responses containers	4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB
Files after the session	100 GB disk that stays, synced to object storage	Data is discarded when the container expires; Agents API keeps only files in /workspace/outputs	Disk saved every minute and on stop; a stopped sandbox costs nothing and comes back
Idle behavior	Pauses about 30 seconds after activity stops and wakes on the next request in 100 to 500 ms	Expires after 20 minutes without use; Agents API sandboxes after an hour without activity	Runs until you stop it or its time to live ends; no session cap on paid plans
Snapshots and fork	Filesystem checkpoints that restore in place; no fork	No snapshots and no fork	Named snapshots, and fork of a running sandbox with its disk
Custom image	One managed Ubuntu image; you install on top of it	Fixed Debian 12 image; you upload files or skills into each container	Named snapshots of a set-up machine, reused as templates
Inbound access	One HTTPS URL to one HTTP port; other ports and SSH only through the sprite proxy CLI	None; you reach the container only through the API	SSH, HTTPS URLs for up to 50 ports, raw TCP, dedicated IPv4 or IPv6
Outbound internet	Open by default, with an optional DNS-based domain allowlist set from outside	Code Interpreter and Hosted Shell: off until an admin sets an org domain allowlist; Agents API sandboxes open by default	Open internet on every plan; no provider-side allowlist
Keeping keys out of the sandbox	Connectors gateway holds the token for any HTTP API, with path allow and block lists	domain_secrets: a sidecar adds the real header for approved domains	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	Agents API (beta) drives a managed Codex harness from outside, with steering and events	Seven agents preinstalled, with a prompt, steer and events API to drive them from outside
Desktop and computer use	Headless; no desktop or browser product	Hosted browser for the Agents API computer_use tool	60fps desktop and Chromium, computer use, embeddable stream
Regions	Region not selectable	US or EU processing for Code Interpreter; Agents API data residency only in the US	EU only (Germany, Finland, France), with EU data residency

Every feature Battleships tracks (43)

Feature	Sprites	OpenAI Containers	bochka
Full VM (own kernel)	Yes	Yes	Yes
Docker inside	Yes	No	Yes
Nested virtualization	No	No	Yes
Root	Yes	No	Yes
Systemd	No	Not published	Yes
Desktop GUI	No	Yes	Yes
Browser	No	Yes	Yes
Computer-use API	No	Yes	Yes
SSH	No	No	Yes
Persistent disk	Yes	No	Yes
Pause/resume	Yes	No	Yes
Automatic snapshots	Yes	No	Yes
Fork/clone	No	No	Yes
Live fork (no pause)	No	No	Yes
Memory fork	No	No	No
Custom image (Docker or snapshot)	Yes	No	Yes
≥24 h sessions	Yes	Yes	Yes
Idle auto-stop	Yes	Yes	No
Wake on request	Yes	No	No
HTTPS preview URLs	Yes	No	Yes
Raw TCP inbound	No	No	Yes
Public IPv4	No	No	No
Egress allowlist	Yes	Yes	No
Secret proxy	Yes	Yes	Yes
Secret proxy for any API	Yes	Yes	Yes
Preinstalled agents	Yes	No	Yes
Agent harness API	No	Yes	Yes
MCP server	Yes	No	No
GPU	No	No	No
Windows	No	No	No
Arm64	No	No	No
Self-hosting	No	Yes	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	Yes	Yes	No
EU data residency	No	Yes	Yes
Zero data retention	Not published	Not published	Yes

Performance

SpritesNot measured

OpenAI ContainersNot measured

bochka26.69 runs/s

Neither Sprites nor OpenAI Containers has a comparable measurement: neither is in the hpc-sandbox-benchmarks results we use, and OpenAI does not publish how many vCPU each Responses container size gets. bochka did 26.69 runs per second on the Node.js build-and-test loop 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 OpenAI Containers 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	OpenAI Containers, 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	$228 · API pay as you go · 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	$1,051 · API pay as you go · 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	$11,405 · API pay as you go · 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	$1,620 · API 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,134 · Pay-as-you-go · with limits	$6,000 · API pay as you go · 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-hour, memory-hour and storage allowances that are not credit.

OpenAI Containers: OpenAI bills each container session by the minute for the memory size you pick, with a 5-minute minimum, and model tokens are billed on top. The scenarios use the 16 GB size for 8 GB needs and the 4 GB size for 4 GB needs, since vCPU is not published.

OpenAI Containers: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.

Limits in those scenarios

OpenAI Containers do not fit any of the five scenarios as written: no persistent disk, no Docker, no internet in Code Interpreter and Hosted Shell until an admin allows domains, and no published vCPU. 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 user sandboxes and 1,000 jobs at once are not confirmed; OpenAI publishes no container concurrency cap either. On bochka, the 1,000-job burst queues starts above 90 a minute even on the $2,000 plan.

Scenario	Sprites	OpenAI Containers	bochka
One coding agent, workdays	None that bite	no open internet: sandboxes reach only an allowlist (domains your org admin adds to the allow list) missing persistent disk machine size not published different kind of product: code interpreter	None that bite
One agent that never stops	None that bite	no open internet: sandboxes reach only an allowlist (domains your org admin adds to the allow list) missing persistent disk machine size not published different kind of product: code interpreter	None that bite
50 agents in parallel	how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)	no open internet: sandboxes reach only an allowlist (domains your org admin adds to the allow list) missing persistent disk, Docker inside machine size not published different kind of product: code interpreter	None that bite
Sandboxes for your users	not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)	no open internet: sandboxes reach only an allowlist (domains your org admin adds to the allow list) machine size not published different kind of product: code interpreter not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)	None that bite
1,000 short jobs at once	not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)	no open internet: sandboxes reach only an allowlist (domains your org admin adds to the allow list) machine size not published different kind of product: code interpreter not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)	max 2,400 starts/day (needs ~6,667) max 600 starts/hour (needs ~1,000) bursts above 90 starts/min are queued (a burst of 333 takes ~4 min to start)

Which one should you use?

Use Sprites when

your agent needs its own Linux machine with root, Docker and a disk that stays, and should sleep when idle and wake on the next request.

A machine that keeps its files. For agents that work over days: a Sprite keeps a 100 GB disk, its installs and its repo between runs.
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.
Root, Docker and open internet. For repos that need packages and services: a Sprite gives root and Docker, and reaches the internet unless you set an allowlist.

Use OpenAI Containers when

your app already calls OpenAI models and the model only needs to run short pieces of code or shell commands on files you give it.

Built into the model call. For apps that already call OpenAI models: one tool line in a request gives the model a place to run code.
Locked-down network by default. For code that must only reach chosen hosts: Code Interpreter and Hosted Shell have no outbound access until an admin allows domains.
Your own compute behind the API. For teams that want to keep execution in-house: the Agents API can drive a sandbox on machines you run.

Where bochka fits

If your agent needs a real machine for hours or days, Sprites is closer than OpenAI Containers, since it keeps its disk and gives root. Look at bochka when the agent also needs systemd, /dev/kvm, more than one public port, a desktop it can see, or forks, and when you want to drive the agents inside from your own code.

A full machine with systemd and /dev/kvm

Sprites runs no systemd and its docs do not mention /dev/kvm, so services need rewriting and Android emulators cannot run. An OpenAI container has no sudo and no Docker documented, so the agent stops at its first apt install.

Ports, SSH and a desktop you can reach

A Sprite exposes one HTTP port, and SSH or a second port go through the sprite proxy on your own machine. An OpenAI container accepts no inbound connections. bochka gives SSH, raw TCP, 50 HTTPS ports and a 60fps desktop.

Forks and agents driven from outside

Sprites checkpoints restore in place and its agents run through exec, so you write the code that starts and watches them. OpenAI drives only its own Codex harness, in beta. bochka forks a running sandbox and drives seven agents through one API.

Use bochka when your agents need a full machine for hours: systemd, Docker, /dev/kvm, many ports and SSH, 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 OpenAI Containers.

Questions people ask

Is Sprites cheaper than OpenAI Containers?

In every scenario we priced, yes: one coding agent on workdays comes to $23 a month on Sprites and $228 on OpenAI, and one agent that never stops is $92 versus $1,051. OpenAI also bills model tokens on top. On bochka the same two scenarios are $20 and $26 a month.

Which is faster, Sprites or OpenAI Containers?

There is no comparable measurement for either one. A Sprite always has 8 vCPU, while OpenAI does not publish the vCPU behind each container size. bochka did 26.69 runs per second on the Node.js build-and-test benchmark at 4 vCPU / 8 GB.

Can Sprites and OpenAI Containers run Docker?

Users run Docker on Sprites, though a community report shows docker exec failing for containers whose main process is not root. OpenAI's docs say hosted shell commands do not run with sudo, and no Docker support is documented. bochka runs Docker, systemd and /dev/kvm in every sandbox.

Do they keep my files?

A Sprite keeps a 100 GB disk between runs, even while it sleeps. An OpenAI container expires after 20 minutes without use, and its data is discarded and cannot be recovered. bochka saves the disk every minute and on stop.

Can I open a web app running inside them?

A Sprite gets one HTTPS URL to one HTTP port; other ports and SSH go through the sprite proxy CLI. OpenAI containers have no ports, URLs or SSH. bochka gives each sandbox HTTPS URLs for up to 50 ports, raw TCP and SSH.

Is bochka SOC 2 compliant?

SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.

Try bochka

Install the CLI, then run bochka new.

Product preview