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. Its Devboxes run Linux, macOS or Windows for people and coding agents, and stop after 3 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 that scales from 2 GB to 16 GB as needed, and a 100 GB ext4 disk backed by object storage. It runs one managed Ubuntu image with Claude Code, Codex, Gemini CLI and Cursor preinstalled. It gets an HTTPS URL that wakes it, and it bills only for the CPU and memory it 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
- 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. You run Claude Code, Codex, OpenCode, Amp, Copilot or Cursor in persistent Devbox sessions, and Namespace also hosts sessions for Claude Managed Agents, Cursor Cloud Agents, Devin and Amp. It is a different kind of product from boat, 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 a container image you choose and include Docker; the docs do not say if each one has its own kernel
- Devbox time limit
- 3 hours on Developer and Devbox Plus, 5 on Team, 24 on Business, even while you work; support can raise it to 24 hours at most
- Devbox count limit
- Per user / per workspace: 1/3 on Developer, 3/30 on Team, 5/50 on Business and Devbox Plus; stopped Devboxes count
- Free trial
- 30-day Developer trial with no card
- 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 374” means 62 of the other 373 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 | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 101st of 365, with limits $546 a month | 74th of 365, with limits $3,745 a month | 5th cheapest of 365 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Both need work-arounds. A Sprite pauses when nothing holds it awake and drops open connections. A Namespace Devbox stops after at most 24 hours, even while it works. boat has no session cap once auto-stop is off on a paid plan (default 1 hour). | 214th of 361, with limits $1,166 a month | 316th of 361, with limits $6,645 a month | 6th cheapest of 361 $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 well: it sleeps about 30 seconds after the last command and bills only the CPU and memory it really uses. | 99th of 336, with limits $140 a month | 244th of 336, with limits $250 a month | 189th of 336, 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 caps Devboxes at 50 per workspace, and its URLs need a Namespace login. | 61st of 349, with limits $428 a month | 279th of 349, with limits $2,068 a month | 3rd cheapest of 349 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 114th of 349, with limits $6,540 a month | 345th of 349, with limits $9,012 a month | 39th of 349, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 130th of 359, with limits $545 a month | 282nd of 359, with limits $1,093 a month | 10th cheapest of 359 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI runners with Docker, Bazel and Turborepo caching are Namespace's main product. boat runs CI jobs on full VMs with Docker and /dev/kvm. Sprites bills only the CPU a job uses. | 63rd cheapest of 374 $476 a month | 87th cheapest of 374 $765 a month | 2nd cheapest of 374 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Sprites runs services through its own API instead of systemd and tunnels SSH through its CLI. A Namespace Devbox stops after 3 to 24 hours by plan and starts again when you connect. A boat machine keeps running with SSH and systemd once auto-stop is off. | 120th cheapest of 371 $27 a month | 201st of 371, with limits $250 a month | 19th cheapest of 371 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month On Sprites you install a display and a browser yourself. Namespace has a screenshot and click API on macOS Devboxes; on Linux Devboxes you install a desktop and VNC in your image. boat streams a 60fps Linux desktop with Chromium. | 132nd of 367, with limits $136 a month | 108th of 367, with limits $1,032 a month | 7th cheapest of 367 $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. boat ships Chromium with browser control on a desktop you can watch. | 236th of 356, with limits $122 a month | 191st of 356, with limits $789 a month | 7th cheapest of 356 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 279th of 343, with limits $206 a month | 191st of 343, with limits $332 a month | 6th cheapest of 343 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 139th of 327, with limits $4,113 a month | 225th of 327, with limits $9,012 a month | 73rd of 327, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 243rd of 351, with limits $223 a month | 112th of 351, with limits $339 a month | 3rd cheapest of 351 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month Namespace fits: it runs macOS Devboxes on Apple Silicon. Sprites and boat run Linux only. | Not ranked: misses a requirement | 6th cheapest of 35 $1,255 a month | Not ranked: misses a requirement |
Key features
| Feature | Sprites | Namespace | boat |
|---|---|---|---|
| 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 physical hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared |
| CPU benchmark (V8 Web Tooling, 4 vCPU / 8 GB, StarSling run of 3 October 2026) | Not in the public benchmarks we use | 24.90 runs/s, rank 2 of 15 (shared) | 28.06 runs/s, rank 2 of 15 (shared), on a Ryzen 9 9950X host; the run cannot separate boat and Namespace |
| Machine size | Fixed 8 vCPU and 100 GB disk; memory scales from 2 GB to 16 GB as needed | Sizes you pick; a 4 vCPU / 8 GB Devbox uses one Devbox Minute a minute; vCPU count is a ceiling it can boost to | 2 to 16 vCPU and 4 to 32 GB; 16 vCPU needs the $100 plan or higher; disk fixed per size (51 to 251 GB) |
| 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 at 3 hours on Developer and Devbox Plus, 5 on Team, 24 on Business, even while you work | Auto-stop after 1 hour by default; up to 30 days, or off on a paid plan |
| 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 auto-stop and bills its full size, busy or idle; no compute charge while stopped |
| Inside the machine | Root and Docker; services run through the Sprites services API, not systemd; no /dev/kvm in the docs | Docker in Linux Devboxes; /dev/kvm on Linux compute instances, not on macOS or Windows | 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; Windows programs through Wine on the Linux desktop |
| Custom images | One managed image; you install on top and save a checkpoint | Any container image you choose, plus Devbox blueprints | boat's Ubuntu 24.04 image or a saved snapshot; no custom Docker image |
| Fork | No fork in the CLI or API docs; checkpoints restore in place | No fork documented; compute instances suspend and resume with RAM and disks kept | Fork a running sandbox from its latest disk save (taken every minute) |
| 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; no public IP | HTTPS URLs for up to 50 ports, token-protected; SSH through a shared IPv4 host and port; public IPv6 for raw ports; no dedicated IPv4 |
| 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 | You run Claude Code, Codex, OpenCode, Amp, Copilot or Cursor in persistent Devbox sessions; hosts Claude Managed Agents, Cursor, Devin and Amp sessions | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Desktop and computer use | No desktop or browser built in; you install a browser, a display server and a stream yourself | macOS Devboxes: screenshot and click API and a VNC desktop; Linux Devboxes: you install a desktop and VNC in your image; compute instances: VNC and RDP | 60fps Linux desktop and Chromium, computer use and browser control, embeddable stream |
Every feature Battleships tracks (43)
| Feature | Sprites | Namespace | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No documented way | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No documented way | Not published | Yes |
| Desktop GUI | No documented way | Yes | Yes |
| Browser | No documented way | With your own setup | Yes |
| Computer-use API | No documented way | Yes | Yes |
| SSH | With your own setup | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | No documented way | No documented way | Yes |
| Live fork (no pause) | No documented way | No documented way | Yes |
| Memory fork | No documented way | No documented way | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No documented way |
| Wake on request | Yes | Yes | No documented way |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No documented way | Yes | Yes |
| Public IPv4 | No documented way | No documented way | No documented way |
| Egress allowlist | Yes | Yes | No documented way |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No documented way | No documented way | Yes |
| MCP server | Yes | Yes | No documented way |
| GPU | No documented way | No documented way | No documented way |
| Windows | No documented way | Yes | No documented way |
| Arm64 | No documented way | Yes | No documented way |
| Self-hosting | No documented way | No documented way | No documented way |
| BYOC | No documented way | No documented way | No documented way |
| Open source | No documented way | No documented way | No documented way |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | No documented way | No documented way | Yes |
| Audit logs | Not published | Yes | No documented way |
| SSO | Yes | Yes | No documented way |
| SOC 2 | Yes | Yes | No documented way |
| HIPAA | Yes | No documented way | No documented way |
| EU data residency | No documented way | Yes | No documented way |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's run of 3 October 2026 (run 37073680030), the V8 Web Tooling Benchmark at 4 vCPU / 8 GB did 28.06 runs/s on boat and 24.90 on Namespace. Both share rank 2 of 15, so the run cannot separate them. On real repo builds in the same run, boat took 135.8 s for Better-Auth against 150.5 s, 980 s for Mastra against 1,051 s, and 428 s for OpenClaw against 570 s. StarSling does not name the Namespace product it tested. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Providers ran on different hardware in different regions. Sprites is not in the public benchmarks we use, so we cannot say how it compares.
V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Namespace measured on: Linux compute instance (unit-minutes, PAYG/overage $0.0015). Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Sprites is not in the public benchmarks we use, so we cannot say which is faster.
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. Start limits, per-start fees and plan minimums are in the price, boat's included.
| Scenario | Sprites, a month | Namespace, 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 | $300 · Devbox on Business | $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 | $426 · Devbox on Business · 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,448 · Devbox on Business | $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,264 · Devbox Plus · 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 | $3,287 · Devbox Plus · with limits | $8,800 · $2000/mo · with limits |
Sprites: Sprites bills CPU time measured by cpu.stat at $0.0385 per CPU-hour and actual memory at $0.021875 per GB-hour, only while the Sprite is awake. Storage costs about $0.50 per GB-month for hot data while awake and about $0.02 per GB-month for cold data. Pay as you go has no plan fee. 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: a 4 vCPU / 8 GB Devbox uses one a minute, $0.24 an hour. Pay as you go, or Devbox Plus at $250 a month for 50,000 minutes. Team ($100) and Business ($250) plan minutes do not cover Devboxes, but you need those plans for longer sessions and more Devboxes. Storage costs $0.20 per GB-month used. New sign-ups get a 30-day Developer trial with no card.
Namespace: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. Included VM time expires at the end of the billing period. You pay per second for the size you pick while a sandbox runs: $0.036 an hour for 4 vCPU / 8 GB, busy or idle. A stopped sandbox has no compute charge, and boat keeps its disk for at least 14 days. Saved snapshots above the plan's included count and the optional AI credentials proxy still charge while sandboxes are stopped.
Limits in those scenarios
On Namespace the limit is time: a Devbox stops at 3 hours on Developer and Devbox Plus, 5 on Team and 24 on Business. So one 8-hour workday session needs Business, and the agent that never stops restarts at least once a day. Namespace caps Devboxes per workspace (3 on Developer, 30 on Team, 50 on Business and Devbox Plus, stopped ones included), and does not publish an egress price. 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. boat auto-stops after 1 hour by default; you can set up to 30 days or turn it off on a paid plan. Each boat plan caps starts. The $2,000 plan includes 90 a minute and 2,400 a day, charges $0.03 to $0.07 per extra start and refuses starts above 270 a minute, so boat does not fit 1,000 short jobs at once. boat never queues a start.
| Scenario | Sprites | Namespace | boat |
|---|---|---|---|
| One coding agent, workdays | None for this scenario |
| None for this scenario |
| One agent that never stops | None for this scenario |
| None for this scenario |
| 50 agents in parallel |
|
| None for this scenario |
| Sandboxes for your users |
|
| None for this scenario |
| 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, egress allowlists, 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.
- 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 and egress rules. For teams with a set toolchain: a Namespace Devbox runs any container image you choose, with egress policies by domain.
Where boat fits
If you run coding agents that work on Linux for hours, look at boat. Sprites pauses when idle, and Namespace Devboxes stop after 3 to 24 hours by plan. boat keeps a full VM running as long as you set, with a desktop and agents you drive from outside. boat has no macOS, no Windows VM and no outbound allowlist, and caps starts per plan.
A full machine that keeps running
A Sprite pauses when nothing holds it awake and drops open connections. A Namespace Devbox stops after 3 to 24 hours, even mid-task. boat runs systemd, Docker and /dev/kvm with no session cap once auto-stop is off on a paid plan. A boat resume is like a reboot: memory and running programs are not saved.
Agents driven from outside, and forks
On Sprites you run agents through exec, and on Namespace you run them in Devbox sessions or a partner runs the loop. boat gives you a prompt, steer and events API, and forks a running sandbox from its latest disk save. Neither Sprites nor Namespace documents a fork.
A Linux desktop for computer use
On Sprites you install a screen yourself. Namespace's screenshot and click API is on macOS Devboxes, and on Linux you install a desktop and VNC in your image. boat streams a 60fps Linux desktop with Chromium and computer use in every sandbox.
Use boat when your agents work on Linux for hours or days and need a full VM with Docker, systemd and /dev/kvm, a 60fps desktop, forks and agents you drive from outside. Compare it one to one: boat vs Sprites and boat vs Namespace.
boat's own limits
- Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
- Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
- A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
- Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
- boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
- Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
- Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
- Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source
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 $300 on Namespace, because an 8-hour session needs the Business plan; boat is $20. One agent that never stops is $92 on Sprites and $26 on boat; Namespace ($426) restarts every 24 hours. 50 agents in parallel are $1,120, $2,448 and $317. Sandboxes for your users are $314 on Sprites (300 at once not confirmed) and $200 on boat; they exceed Namespace's 50-Devbox cap. For 1,000 short jobs at once, none fits as published.
Which is faster, Sprites or Namespace?
Sprites is not in the public benchmarks we use, so we cannot say. In StarSling's run of 3 October 2026 at 4 vCPU / 8 GB, Namespace did 24.90 V8 Web Tooling runs/s and boat 28.06; both share rank 2, so the run cannot separate them. A Sprite wakes from a pause in 100 to 500 ms.
Can Sprites and Namespace run Docker?
Yes, both run Docker inside. A user reports docker exec failing on Sprites for containers that do not run as root, and Sprites runs services through its own API instead of systemd. Namespace offers /dev/kvm on Linux compute instances. boat has Docker, systemd and /dev/kvm on every machine.
Can an agent run all day and night on Sprites or Namespace?
A Namespace Devbox stops at 3, 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. boat has no session cap once auto-stop is off on a paid plan (the default is 1 hour).
Do Sprites or Namespace run macOS?
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. boat runs Linux only, with Windows programs through Wine.
Is boat SOC 2 compliant?
No SOC 2 report today; SOC 2 is in progress. boat publishes 99.95% measured sandbox uptime and no SLA. Sprites has SOC 2 Type II, and Namespace's trust center lists SOC 2 Type II. Live status is 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