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.
- Isolation
- Firecracker microVM per Sprite
- Regions
- Not selectable for Sprites
- 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 boat: 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.
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 | boat: 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 boat 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; boat 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; boat 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 boat 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; boat 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; boat 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 boat 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 | boat |
|---|---|---|---|
| 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 | boat |
|---|---|---|---|
| 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
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. boat 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 | boat, 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 boat, the 1,000-job burst queues starts above 90 a minute even on the $2,000 plan.
| Scenario | Sprites | OpenAI Containers | boat |
|---|---|---|---|
| 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
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 boat 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 boat 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. boat 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. boat forks a running sandbox and drives seven agents through one API.
Use boat 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: boat vs Sprites and boat 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 boat 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. boat 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. boat 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. boat 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. boat gives each sandbox HTTPS URLs for up to 50 ports, raw TCP and SSH.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial