Runloop vs Namespace
Runloop is built for AI coding agents: micro-VM devboxes with egress rules, arm64 and deploys into your own cloud. Namespace is mainly a CI and dev platform, with faster CPUs, macOS and Windows, but Devboxes that shut down after 24 hours at most.
The companies and products
Runloop
Runloop is a US platform of sandboxes, called devboxes, for building, running and testing AI coding agents.
You get Linux devboxes built from Dockerfile-style blueprints, disk snapshots, HTTPS tunnels, agent gateways that hide API keys, and Axons, event streams that drive agents such as Claude Code. Each devbox runs in a micro-VM on Runloop's own bare-metal hypervisor, with a container layer inside. It is built for teams shipping coding agents, plus evaluation and RL fine-tuning work on the Enterprise plan.
- Compliance
- SOC 2 Type 2
- Architectures
- x86_64 and arm64 base blueprints
- Own-cloud deploy
- Deploy to VPC on AWS, GCP and Azure (Enterprise)
- Regions
- Not documented or selectable
- Company
- Runloop AI, Inc.
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 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 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. “20th cheapest of 367” means 19 of the other 366 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 | Runloop: 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 | 20th cheapest of 367 $8,152 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 Runloop fits an assistant that never stops because an idle policy replaces its 48-hour lifetime; a Namespace Devbox is shut down after at most 24 hours, and boat has no session cap on paid plans. | 32nd cheapest of 366 $10,194 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 | 44th cheapest of 345 $525 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 | 26th cheapest of 361 $3,301 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 Runloop ranks 4th for RL rollouts: it starts large waves with no published start limits and sells RL fine-tuning on Enterprise, while Namespace's 24-hour cap and CI focus make it a compromise. | 4th cheapest of 360 $15,922 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 | 81st cheapest of 364 $2,562 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 CI runners are Namespace's main product, with caches for Docker, Bazel and more, so it ranks above Runloop here; boat runs CI on full VMs with Docker and /dev/kvm. | 121st cheapest of 377 $1,554 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 a compromise for a box that runs all month: Runloop has no public IP or raw TCP, and a Namespace Devbox stops after at most 24 hours; boat keeps a machine up as long as you want. | 113th cheapest of 368 $410 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 Runloop ships a desktop your agent can control on Linux, while Namespace's screenshot and click API works on macOS Devboxes only; boat streams a 60fps Linux desktop. | 39th cheapest of 369 $2,306 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 Runloop includes a browser your agent can control, while Namespace has no managed browser for Devboxes; boat ships Chromium with browser control. | 40th cheapest of 367 $1,153 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 | 68th cheapest of 346 $781 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 | 266th of 338, with limits $15,611 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 | 10th cheapest of 360 $770 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 None of the three fits: all their machine shapes are CPU only. | 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 on Apple Silicon, and neither Runloop nor boat has macOS. | Can't run it | 6th cheapest of 36 $1,205 a month | Can't run it |
Key features
| Feature | Runloop | Namespace | boat |
|---|---|---|---|
| What it is | Sandboxes, called devboxes, for building, running and testing AI coding agents | CI runners, build caches and Devboxes for people and coding agents | Sandboxes for agents: a full Linux VM per agent, with agents built in |
| Isolation | Micro-VM on a custom bare-metal hypervisor, plus a container layer | 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) | 8.29 runs/s | 21.79 runs/s | 26.69 runs/s |
| Docker and nested virtualization | Docker on the dnd blueprints, as root; nested virtualization not documented | Docker in Linux Devboxes; /dev/kvm on Linux compute instances | Docker, root, systemd and /dev/kvm on every machine |
| How long a session can run | Fixed lifetime 1 hour by default, 48 hours max; an idle policy replaces it with no documented cap | Devboxes stop after 4, 5 or 24 hours by plan, raisable to 24 at most, even while you work | No session cap on paid plans |
| Files after a stop | Disk kept through suspend (Pro plan) or manual disk snapshots; shutdown ends the devbox | A stopped Devbox keeps its storage, billed at $0.20 per GB-month used | Snapshots every minute and on stop; a stopped sandbox costs nothing and keeps its disk |
| Idle stop and wake | Suspend after idle, wake on an HTTP request to the tunnel (Pro) | Devboxes stop after an idle timeout and start again when you connect | No idle timer; machines run until you stop them or their TTL ends |
| Reaching the sandbox | One HTTPS tunnel per devbox, open or bearer token; SSH through a TLS proxy; no public IP | 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; raw TCP; dedicated IPv6 or IPv4 |
| Outbound rules | Hostname allowlist with wildcards, or block all | Egress policies by domain: block, advisory or allow | Open internet, no provider-side allowlist |
| Keeping keys out of the sandbox | Agent gateways for any API endpoint with bearer, header or basic auth | Egress rules inject a header from Namespace Vault, resolved outside the workload | AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Claude Code, Codex, OpenCode, Gemini CLI, DeepAgents, driven through Axons and Broker | Hosts Claude Managed Agents, Cursor and Devin sessions through those partners; an MCP server for your own agent | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Desktop and computer use | Desktop and browser your agent can control | 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 |
| Operating systems and CPUs | Linux on x86_64 and arm64 | Linux, macOS on Apple Silicon, and Windows on Team plans and up | Linux on x86_64 only; Wine for Windows apps |
| Where it runs | Regions not documented; Deploy to VPC on AWS, GCP or Azure (Enterprise) | Several regions, nearest by default; region-exclusive residency on Enterprise | EU only (Germany, Finland, France), EU data residency |
Every feature Battleships tracks (43)
| Feature | Runloop | Namespace | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | Yes | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | 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 | Yes | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | Yes | No |
| Arm64 | Yes | Yes | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | 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 | Not published | No | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
All three were measured on the same Node.js build-and-test loop at 4 vCPU / 8 GB (StarSling run 36498291449, 2026-09-29). boat scored 26.69 runs a second, Namespace 21.79 and Runloop 8.29, so Namespace ran about 2.6 times as fast as Runloop and boat about a fifth faster than Namespace. The test measures CPU work only, not start time or network speed.
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).
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 | Runloop, 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 | $113 · Basic | $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 | $429 · Basic | $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 | $5,268 · Basic | $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 | $1,441 · Basic | $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 | $3,184 · Basic | $3,237 · Devbox (pay as you go) | $2,000 · $2000/mo · with limits |
Runloop: Runloop bills per second for the CPU and memory you allocate, including while a devbox starts, suspends or resumes, and bills its disk for the devbox's whole life. Basic has no plan fee; Pro adds $250 a month that is not usage credit and unlocks suspend and resume.
Namespace: Namespace bills Devboxes in Devbox Minutes at $0.004 each, pay as you go on every plan, and 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
Namespace's limit that bites is time: a Devbox shuts down after 4, 5 or 24 hours by plan, so the agent that never stops restarts at least once a day. Runloop's fixed lifetime tops out at 48 hours, but an idle policy replaces it, so it runs 24/7; it caps disk at 64 GiB. Neither publishes an egress price or a Devbox concurrency cap. boat's limit is start rate, so 1,000 short jobs at once does not fit on its $2,000 plan, while both Runloop and Namespace fit it.
| Scenario | Runloop | Namespace | boat |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| 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 Runloop when
you build and test AI coding agents at scale, run RL or eval waves, or need arm64, hostname allowlists or devboxes inside your own cloud.
- Runs as long as the agent needs. Useful for agents that work for days: an idle policy replaces Runloop's 48-hour lifetime, while Namespace Devboxes stop at 24 hours.
- Built for agent evals and RL. Useful for big rollout waves: Runloop publishes no start limits and sells RL fine-tuning on its Enterprise plan.
- arm64 and your own cloud. Useful if you need arm64 devboxes, or want them inside your own AWS, GCP or Azure account on Enterprise.
Use Namespace when
you want faster GitHub Actions runners with build caches, macOS or Windows machines, or dev boxes for people that stop when idle.
- Faster CPUs. Useful when builds and tests dominate: Namespace scored 21.79 runs a second to Runloop's 8.29 on the same benchmark.
- macOS and Windows. Useful if your agents build iOS or Mac apps or test on Windows: Namespace runs macOS on Apple Silicon and Windows.
- CI runners and build caches. Useful if you also want faster GitHub Actions: Namespace is a drop-in runner with Docker, Bazel and Turborepo caching.
Where boat fits
If what you are running is Linux agents that work for hours or days, look at boat too. It gives each agent a full VM that is faster than both on the same benchmark, with no session cap on paid plans and files kept on every plan. Pick Runloop or Namespace instead for arm64, macOS, own-cloud deploys or provider-side egress rules.
A full machine with /dev/kvm
Runloop documents Docker-in-Docker but not nested virtualization, and Namespace's Linux Devboxes run from a container image. Without /dev/kvm an Android emulator or a VM does not start; boat has it on every machine.
No clock, files always kept
A Namespace Devbox is shut down at 24 hours even mid-task, and a Runloop devbox is gone after shutdown unless you pay for Pro suspend or write snapshot code. boat saves the disk every minute and has no session cap on paid plans.
Real ports in, agents driven from outside
Both reach their machines through HTTPS tunnels or a CLI port-forward, with no public IP. boat gives HTTPS on 50 ports, raw TCP and a dedicated IP, plus a prompt, steer and events API to drive agents inside from outside.
Use boat when your agents work on Linux for hours or days: a full, faster VM with no session cap, Docker and /dev/kvm, a 60fps desktop, and coding agents you drive from outside. Compare it one to one: boat vs Runloop and boat vs Namespace.
Questions people ask
Is Runloop cheaper than Namespace?
Usually not in our scenarios. One coding agent on workdays costs $113 a month on Runloop and $50 on Namespace, and 50 agents in parallel cost $5,268 versus $2,198. For 1,000 short jobs at once they are close: $3,184 on Runloop and $3,237 on Namespace. boat comes to $20, $317 and, for the burst, does not fit.
Which is faster, Runloop or Namespace?
Namespace, on CPU. On the same Node.js build-and-test benchmark at 4 vCPU / 8 GB, Namespace ran 21.79 loops a second and Runloop 8.29. boat ran 26.69.
Can a Runloop or Namespace sandbox run 24/7?
A Runloop devbox can, if you set an idle policy in place of its 48-hour lifetime. A Namespace Devbox cannot: it shuts down after at most 24 hours, even while you work in it. boat has no session cap on paid plans.
Can Runloop and Namespace run Docker?
Yes. Runloop runs Docker on its Docker-in-Docker blueprints, and Namespace Linux Devboxes include Docker. For /dev/kvm, Namespace offers it on Linux compute instances and Runloop does not document it; boat has Docker, systemd and /dev/kvm on every machine.
Do Runloop or Namespace run macOS?
Namespace does, on Apple M4 Pro and M5 Max machines, and it runs Windows on Team plans and up. Runloop runs Linux on x86_64 and arm64. boat runs Linux only.
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