Sprites vs Namespace
Sprites gives each agent a persistent Linux microVM that sleeps when idle and wakes on the next request. Namespace is mainly a CI platform whose Devboxes run Linux, macOS or Windows but are shut down after 4 to 24 hours by plan.
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
Namespace
Namespace is a dev platform for fast builds, tests and coding environments: CI runners, build caches and Devboxes, on its own hardware.
Most of Namespace is CI: a faster drop-in for GitHub Actions runners, with Docker, Bazel, Turborepo and Nix caching. Its Devboxes are remote Linux and macOS machines with persistent storage, made for people and AI coding agents, and they also host sessions for Claude Managed Agents, Cursor Cloud Agents and Devin. It is a different kind of product from bochka, so this page compares the part where they overlap: a machine an agent works on.
- Products
- GitHub Actions runners, Docker, Bazel, Turborepo and Nix caching, Devboxes, and a compute API
- Hardware
- Its own hardware in its own racks: AMD EPYC for Linux and Windows, Apple M4 Pro or M5 Max for macOS
- Linux Devboxes
- Run from a container image you choose and include Docker; the docs do not say whether each one has its own kernel
- Funding
- Announced a $42M Series B
- Compliance
- Trust center lists SOC 2 Type II
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 | Namespace: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 66th of 367, with limits $546 a month | 39th of 367, with limits $3,495 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Neither fits fully: a Sprite pauses when nothing holds it awake and drops open connections, and a Namespace Devbox is shut down after at most 24 hours; bochka has no session cap on paid plans. | 157th of 366, with limits $1,166 a month | 303rd of 366, with limits $6,645 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 fits short code runs better than Namespace here, because it sleeps about 30 seconds after the last command and bills only the CPU and memory it really uses. | 93rd of 345, with limits $140 a month | 247th of 345, with limits $250 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 a URL that wakes it, but 300 at once is not confirmed on pay as you go; Namespace URLs need a Namespace login. | 56th of 361, with limits $428 a month | 284th of 361, with limits $2,068 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 | 356th of 360, with limits $9,012 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 | 282nd of 364, with limits $1,043 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 with Docker, Bazel and Turborepo caching are Namespace's main product, while bochka runs CI jobs on full VMs with Docker and /dev/kvm. | 63rd cheapest of 377 $476 a month | 80th cheapest of 377 $765 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both are compromises: Sprites has no systemd and tunnels SSH through its CLI, and a Namespace Devbox stops after at most 24 hours; a bochka machine stays up with SSH and systemd. | 213th of 368, with limits $27 a month | 126th of 368, with limits $168 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 Sprites is headless, and Namespace's screenshot and click API works on macOS Devboxes only; bochka streams a 60fps Linux desktop with Chromium. | 85th of 369, with limits $136 a month | 67th of 369, with limits $982 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 Neither ships a managed browser, so on both you install and run one yourself; bochka ships Chromium with browser control on a desktop you can watch. | 171st of 367, with limits $122 a month | 285th of 367, with limits $789 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 | 259th of 346, with limits $332 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 | 226th of 338, with limits $9,012 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 | 242nd of 360, with limits $339 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 Only Namespace fits: it runs macOS Devboxes on Apple Silicon, while Sprites and bochka run Linux only. | Can't run it | 6th cheapest of 36 $1,205 a month | Can't run it |
Key features
| Feature | Sprites | Namespace | bochka |
|---|---|---|---|
| What it mainly is | Persistent Linux computers for agents, made by API or CLI | CI runners and build caches, plus Devboxes for people and coding agents | Sandboxes for agents: full VMs with agents and a desktop built in |
| Isolation | Firecracker microVM with its own kernel | Linux Devboxes run from a container image on Namespace's own hardware; the docs do not say if each has its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | Not measured | 21.79 runs/s | 26.69 runs/s |
| Machine size | Fixed 8 vCPU and 100 GB disk; memory managed by the platform | Sizes you pick; a 4 vCPU / 8 GB Devbox uses one Devbox Minute a minute | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| How long a session can run | No time cap, but it pauses about 30 seconds after activity stops unless a task holds it awake | Devboxes stop after 4, 5 or 24 hours by plan, even while you work | No session cap on paid plans |
| Idle stop and wake | Pauses when idle and wakes on the next request in 100 to 500 ms with memory kept | Devboxes stop after an idle timeout (15 minutes to 8 hours) and start again when you connect | Runs until you stop it; a stopped sandbox costs nothing |
| Inside the machine | Root and Docker (with rough edges users report); no systemd, no /dev/kvm in the docs | Docker in Linux Devboxes; /dev/kvm on Linux compute instances | Root, Docker, systemd and /dev/kvm on every machine |
| Operating systems | One managed Ubuntu image | Linux, macOS on Apple Silicon, and Windows on Team plans and up | Linux only; Wine for Windows apps |
| Custom images | No; you install on top of the managed image | Any container image you choose, plus Devbox blueprints | Named snapshots (templates) to start new sandboxes from |
| Fork | No fork; checkpoints restore in place | No fork; compute instances can suspend and resume with RAM kept | Fork a running sandbox with its disk into a new one |
| Reaching the sandbox | One HTTPS URL to one HTTP port; other ports and SSH through the sprite proxy CLI | HTTPS URLs that need a Namespace login; TCP through a running CLI port-forward | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6; SSH |
| Outbound rules | Optional DNS-based domain allowlist; private IPs always blocked | Egress policies per blueprint, runner or instance: block, advisory or allow by domain | Open internet, no provider-side allowlist |
| Coding agents | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec | Hosts Claude Managed Agents, Cursor and Devin sessions; an MCP server lets your agent create Devboxes | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Desktop and computer use | Headless; no desktop or browser | Screenshot and click API on macOS Devboxes only; VNC and RDP for compute instances | 60fps Linux desktop and Chromium, computer use and browser control, embeddable stream |
Every feature Battleships tracks (43)
| Feature | Sprites | Namespace | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | Yes | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | 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 | Yes | 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 | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | Yes | No |
| Arm64 | No | Yes | 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 | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's run of 2026-09-29 at 4 vCPU / 8 GB, bochka did 26.69 Node.js build-and-test runs per second and Namespace did 21.79, so the same build takes about a fifth longer on Namespace. Sprites is not in those results, so there is no comparable score for it, and a Sprite always has 8 vCPU.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Namespace measured on: Linux compute instance (unit-minutes, PAYG/overage $0.0015). Sprites has 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 | Namespace, 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 | $50 · Devbox (pay as you go) | $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 | $176 · Devbox (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 | $2,198 · Devbox (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 | $314 · Pay-as-you-go · with limits | $1,214 · Devbox (pay as you go) | $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 | $3,237 · Devbox (pay as you go) | $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 such as Hero at $100 a month buy fixed allowances that are not credit.
Namespace: Devboxes are billed in Devbox Minutes at $0.004 each, pay as you go on every plan; a 4 vCPU / 8 GB Devbox uses one a minute. Plan minutes cover runners and instances, not Devboxes, and stored files cost $0.20 per GB-month.
Namespace: Plans start at $20 a month and the whole fee is usage credit, spent per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
On Namespace the limit is time: a Devbox stops after 4, 5 or 24 hours by plan, so the agent that never stops has to restart at least once a day. On Sprites the limit is how many can run at once: pay as you go has no published cap, so 300 sandboxes for your users and 1,000 jobs at once are not confirmed, and creation is 10 a minute without a plan. Namespace does not publish an egress price. bochka fits every scenario except 1,000 short jobs at once, where starts above 90 a minute are queued and the $2,000 plan runs out of daily starts.
| Scenario | Sprites | Namespace | 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
your agents or apps sit idle most of the day and should wake on a request, and you want to pay only for the CPU and memory they really use.
- Sleeps when idle, wakes on request. For agents and apps idle most of the day: a Sprite stops billing compute when it pauses and wakes on the next request.
- Bills real use. For bursty work: Sprites bills the CPU time and memory actually used while awake, with no plan fee needed.
- No clock on a session. For long jobs that keep it busy: a Sprite has no maximum session length, while a Namespace Devbox stops after 24 hours at most.
Use Namespace when
you need macOS or Windows machines, faster GitHub Actions runners with build caches, or Devboxes from your own container image.
- macOS and Windows. For iOS, Mac or Windows builds: Namespace runs macOS on Apple Silicon and Windows machines, which Sprites does not.
- CI runners and build caches. For faster GitHub Actions: Namespace is a drop-in runner with Docker, Bazel, Turborepo and Nix caching.
- Your own images. For teams with a set toolchain: a Namespace Devbox runs any container image you choose, while Sprites uses one managed image.
Where bochka fits
If what you are really running is coding agents that work on Linux for hours, look at bochka. Sprites pauses when idle and Namespace Devboxes stop after at most 24 hours, while bochka keeps a full VM running with no session cap on paid plans, a desktop and agents you drive from outside.
A full machine that keeps running
A Sprite pauses when nothing holds it awake and drops open connections, and a Namespace Devbox is shut down after 4 to 24 hours even mid-task. bochka runs systemd, Docker and /dev/kvm with no session cap on paid plans.
Agents driven from outside, and forks
On Sprites you run agents through exec, and on Namespace a partner runs the agent loop or you write it yourself. bochka gives you a prompt, steer and events API, and forks a running sandbox; neither Sprites nor Namespace has fork.
A Linux desktop for computer use
Sprites is headless, and Namespace's screenshot and click API works only on macOS Devboxes, which cost more per minute. bochka streams a 60fps Linux desktop with Chromium and computer use in every sandbox.
Use bochka when your agents work on Linux for hours or days and need a full, fast VM with no session cap, Docker, systemd and /dev/kvm, a 60fps desktop, forks and agents you drive from outside. Compare it one to one: bochka vs Sprites and bochka vs Namespace.
Questions people ask
Is Sprites cheaper than Namespace?
In every scenario we priced, Sprites comes out lower: one coding agent on workdays is $23 a month on Sprites and $50 on Namespace, and 50 agents in parallel are $1,120 against $2,198. For 1,000 short jobs at once Sprites is $1,134 against $3,237, but its pay-as-you-go concurrency limit is not published. bochka is $20, $317 and $2,000 for the same three.
Which is faster, Sprites or Namespace?
Only Namespace has a comparable score: 21.79 Node.js build-and-test runs per second at 4 vCPU / 8 GB, against 26.69 for bochka. Sprites is not in the benchmark we use. A Sprite wakes from a pause in 100 to 500 ms.
Can Sprites and Namespace run Docker?
Yes, both run Docker inside. Users report rough edges with Docker on Sprites, and Sprites does not run systemd. Namespace offers /dev/kvm on Linux compute instances, while bochka has Docker, systemd and /dev/kvm on every machine.
Can an agent run all day and night on Sprites or Namespace?
A Namespace Devbox is shut down after 4, 5 or 24 hours by plan, even while it works. A Sprite has no time cap, but it pauses about 30 seconds after activity stops unless a task holds it awake for up to an hour at a time. bochka has no session cap on paid plans.
Do Sprites or Namespace run macOS?
Only Namespace does, on Apple M4 Pro and M5 Max chips, and it also runs Windows on Team plans and up. Sprites runs one managed Ubuntu image, and bochka runs Linux only.
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