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.

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.

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 workloadSprites: price rankNamespace: price rankboat: 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 requirementNot ranked: misses a requirementNot 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 requirement6th cheapest of 35
$1,255 a month
Not ranked: misses a requirement

Key features

FeatureSpritesNamespaceboat
What it mainly isPersistent Linux computers for agents, made by API or CLICI runners and build caches, plus Devboxes for people and coding agentsSandboxes for agents: full VMs with agents and a desktop built in
IsolationFirecracker microVM with its own kernelLinux Devboxes run from a container image on Namespace's own hardware; the docs do not say if each has its own kernelFull 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 use24.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 sizeFixed 8 vCPU and 100 GB disk; memory scales from 2 GB to 16 GB as neededSizes you pick; a 4 vCPU / 8 GB Devbox uses one Devbox Minute a minute; vCPU count is a ceiling it can boost to2 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 runNo time cap, but it pauses about 30 seconds after activity stops unless a task holds it awakeDevboxes stop at 3 hours on Developer and Devbox Plus, 5 on Team, 24 on Business, even while you workAuto-stop after 1 hour by default; up to 30 days, or off on a paid plan
Idle stop and wakePauses when idle and wakes on the next request in 100 to 500 ms with memory keptDevboxes stop after an idle timeout (15 minutes to 8 hours) and start again when you connectRuns until auto-stop and bills its full size, busy or idle; no compute charge while stopped
Inside the machineRoot and Docker; services run through the Sprites services API, not systemd; no /dev/kvm in the docsDocker in Linux Devboxes; /dev/kvm on Linux compute instances, not on macOS or WindowsRoot, Docker, systemd and /dev/kvm on every machine
Operating systemsOne managed Ubuntu imageLinux, macOS on Apple Silicon, and Windows on Team plans and upLinux only; Windows programs through Wine on the Linux desktop
Custom imagesOne managed image; you install on top and save a checkpointAny container image you choose, plus Devbox blueprintsboat's Ubuntu 24.04 image or a saved snapshot; no custom Docker image
ForkNo fork in the CLI or API docs; checkpoints restore in placeNo fork documented; compute instances suspend and resume with RAM and disks keptFork a running sandbox from its latest disk save (taken every minute)
Reaching the sandboxOne HTTPS URL to one HTTP port; other ports and SSH through the sprite proxy CLIHTTPS URLs that need a Namespace login; TCP through a running CLI port-forward; no public IPHTTPS 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 rulesOptional DNS-based domain allowlist; private IPs always blockedEgress policies per blueprint, runner or instance: block, advisory or allow by domainOpen internet, no provider-side allowlist
Coding agentsClaude Code, Codex, Gemini CLI and Cursor preinstalled, run through execYou run Claude Code, Codex, OpenCode, Amp, Copilot or Cursor in persistent Devbox sessions; hosts Claude Managed Agents, Cursor, Devin and Amp sessionsSeven agents preinstalled, with a prompt, steer and events API to drive them from outside
Desktop and computer useNo desktop or browser built in; you install a browser, a display server and a stream yourselfmacOS Devboxes: screenshot and click API and a VNC desktop; Linux Devboxes: you install a desktop and VNC in your image; compute instances: VNC and RDP60fps Linux desktop and Chromium, computer use and browser control, embeddable stream
Every feature Battleships tracks (43)
FeatureSpritesNamespaceboat
Full VM (own kernel)YesYesYes
Docker insideYesYesYes
Nested virtualizationNo documented wayYesYes
RootYesYesYes
SystemdNo documented wayNot publishedYes
Desktop GUINo documented wayYesYes
BrowserNo documented wayWith your own setupYes
Computer-use APINo documented wayYesYes
SSHWith your own setupYesYes
Persistent diskYesYesYes
Pause/resumeYesYesYes
Automatic snapshotsYesYesYes
Fork/cloneNo documented wayNo documented wayYes
Live fork (no pause)No documented wayNo documented wayYes
Memory forkNo documented wayNo documented wayNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesYesYes
Idle auto-stopYesYesNo documented way
Wake on requestYesYesNo documented way
HTTPS preview URLsYesYesYes
Raw TCP inboundNo documented wayYesYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesYesNo documented way
Secret proxyYesYesYes
Secret proxy for any APIYesYesYes
Preinstalled agentsYesYesYes
Agent harness APINo documented wayNo documented wayYes
MCP serverYesYesNo documented way
GPUNo documented wayNo documented wayNo documented way
WindowsNo documented wayYesNo documented way
Arm64No documented wayYesNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCNo documented wayNo documented wayNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsNot publishedYesYes
Usage per sandbox (API)No documented wayNo documented wayYes
Audit logsNot publishedYesNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAAYesNo documented wayNo documented way
EU data residencyNo documented wayYesNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

SpritesNot measured
Namespace24.90 runs/s
boat28.06 runs/s

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.

ScenarioSprites, a monthNamespace, a monthboat, 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.

ScenarioSpritesNamespaceboat
One coding agent, workdaysNone for this scenario
  • egress price not published
None for this scenario
One agent that never stopsNone for this scenario
  • Devbox on Business: sessions capped at 24 h
  • egress price not published
None for this scenario
50 agents in parallel
  • how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)
  • egress price not published
None for this scenario
Sandboxes for your users
  • not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
  • Devbox Plus: max 50 concurrent
  • egress price not published
None for this scenario
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)
  • Devbox Plus: max 50 concurrent
  • egress price not published
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429

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

More comparisons