exe.dev vs Namespace
exe.dev rents Linux VMs for developers and agents that keep running until you stop them, in nine regions. Namespace is mainly a CI and build platform, and its Devboxes run Linux, macOS or Windows but are shut down after 4 to 24 hours by plan.
The companies and products
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
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. “15th cheapest of 366” means 14 of the other 365 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 | exe.dev: 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 Namespace does better than exe.dev for a software factory here, but both are compromises; bochka fits fully, with a desktop, snapshots every minute and an agent API. | 253rd of 367, with limits $3,701 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 exe.dev fits an always-on assistant because its VMs have no time limit, while a Namespace Devbox is shut down after at most 24 hours; bochka also has no session cap on paid plans. | 15th cheapest of 366 $3,833 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 | 235th of 345, with limits $175 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 exe.dev's Personal plan stops at 50 VMs at once and Namespace Devboxes bill per minute with no published concurrency limit; bochka fits with token-protected URLs and high concurrency. | 257th of 361, with limits $1,226 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 | 265th of 360, with limits $5,250 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 | 283rd of 364, with limits $1,050 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 is Namespace's main product, with drop-in GitHub Actions runners and build caches; exe.dev pools bill whether jobs run or not, and bochka runs CI jobs on full VMs billed per second. | 288th of 377, with limits $504 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 exe.dev fits a 24/7 dev box with a disk that lasts and no time limit; a Namespace Devbox stops when idle and wakes on connect, but still hits its daily cap. | 25th cheapest of 368 $35 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 Neither fits a Linux computer-use agent well: exe.dev VMs are headless and Namespace's screenshot and click API works on macOS Devboxes only; bochka streams a 60fps Linux desktop. | 240th of 369, with limits $1,055 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 On both you install and run the browser yourself; bochka ships Chromium with browser control. | 130th of 367, with limits $530 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 | 124th of 346, with limits $278 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 | 166th of 338, with limits $5,490 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 | 60th of 360, with limits $263 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, and neither exe.dev nor bochka has macOS. | Can't run it | 6th cheapest of 36 $1,205 a month | Can't run it |
Key features
| Feature | exe.dev | Namespace | bochka |
|---|---|---|---|
| Isolation | KVM VM with Cloud Hypervisor; you can't choose the 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 |
| How long a session can run | No cap; VMs run until you stop them | Devboxes stop after 4, 5 or 24 hours by plan, raisable to 24 at most | No session cap on paid plans; you set the TTL |
| Docker and nested virtualization | Root, systemd and Docker; nested VMs on Enterprise only | Docker in Linux Devboxes; /dev/kvm on Linux compute instances | Docker, root, systemd and /dev/kvm on every machine |
| Operating systems | Linux only | Linux, macOS on Apple Silicon, and Windows on Team plans and up | Linux only; Wine for Windows apps |
| Desktop and computer use | Headless; no desktop or screen streaming | 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 |
| Saved state | Disk persists and is streamed to a second server; no snapshots | 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 resumes with its disk |
| Fork and copy | cp copies a VM's disk and config into a new VM | No fork; compute instances can suspend and resume with RAM kept | Fork a running sandbox; named snapshots as templates, shareable by code |
| Custom images | Boot from your own Docker image | Any container image you choose, plus Devbox blueprints | Templates from named snapshots; no Dockerfile or OCI images |
| Idle stop and wake | VMs run until you stop them; pools bill whether busy or idle | Devboxes stop after an idle timeout (15 minutes to 8 hours) and start again when you connect | Machines run until you stop them; billing only while running |
| Reaching the machine | HTTPS proxy for ports 3000 to 9999, one of them public; SSH; no public IP or raw TCP | 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 by default; raw TCP; dedicated IPv6 or IPv4 per machine |
| Outbound rules and secrets | Open internet; integrations inject secrets at the network edge for any HTTP host | Egress policies by domain (block, advisory or allow); egress rules inject headers from Namespace Vault | Open internet; AI credentials proxy for model providers and any HTTPS API, with account switching when credits run out |
| Coding agents | Claude Code, Codex, Pi and Shelley preinstalled; only Shelley takes prompts through the API; MCP server | Hosts Claude Managed Agents, Cursor and Devin sessions run by those partners; MCP server to create Devboxes and run commands | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API and SDKs |
| Regions | 9 regions in the US, Europe, Asia and Australia | Several regions, nearest by default; region-exclusive residency on Enterprise | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | exe.dev | Namespace | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | Yes | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | 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 | No | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | 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 | No | 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) | Yes | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | No | Yes | No |
| HIPAA | No | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's public 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. exe.dev was not in that run, so there is no comparable CPU score for it, and we don't guess one.
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). exe.dev 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 | exe.dev, 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 | $35 · Personal | $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 | $35 · Personal | $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,848 · Personal | $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 | $530 · Personal · 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,050 · Personal · with limits | $3,237 · Devbox (pay as you go) | $2,000 · $2000/mo · with limits |
exe.dev: Personal is a flat monthly pool your VMs share, $35 for 4 vCPU / 8 GiB, billed whether used or not. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour, and Work is a team fee plus hourly extra capacity.
Namespace: Devboxes bill pay as you go in Devbox Minutes at $0.004 each, one a minute for 4 vCPU / 8 GB, and plan minutes on Team and Business cover runners and instances, not Devboxes. Stored files cost $0.20 per GB-month.
Namespace: Your monthly plan fee, from $20, is all usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and resumes with its disk.
Limits in those scenarios
On Namespace the limit that bites is time: a Devbox is shut down after 4, 5 or 24 hours by plan, so the agent that never stops has to restart at least once a day. On exe.dev Personal the limit is count: up to 50 VMs in a pool plus 50 standalone VMs, so the 300-at-once and 1,000-at-once scenarios don't fit there. Namespace fits 1,000 short jobs at once on our table, while bochka's start limits queue that burst even on its top plan.
| Scenario | exe.dev | Namespace | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel | None that bite |
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use exe.dev when
you want Linux VMs that stay up for days in a region near your users, booted from your own Docker image, on a flat monthly pool.
- No clock on the VM. For agents or dev boxes that must stay up for days: exe.dev VMs run until you stop them, with no session cap.
- Regions around the world. Useful if your users are far from Europe: exe.dev runs in nine regions across the US, Europe, Asia and Australia.
- A flat bill for a fixed pool. For one steady machine: a Personal pool is a flat monthly fee, so a box running all month costs the same as one used on workdays.
Use Namespace when
you need macOS or Windows machines, faster GitHub Actions runners with build caches, or Devboxes for people that stop when idle.
- macOS and Windows. Useful if you build iOS or Mac apps or test on Windows: Namespace runs macOS on Apple Silicon and Windows machines.
- CI runners and build caches. Useful if you want faster GitHub Actions: Namespace is a drop-in runner with Docker, Bazel, Turborepo and Nix caching.
- Egress rules and idle stop. Useful if agents must reach only chosen domains, or boxes should stop when nobody uses them and start on connect.
Where bochka fits
If what you are really running is coding agents on Linux, bochka gives each one a full VM with no session cap, a 60fps desktop and state saved every minute. exe.dev covers the long-running part but is headless with no snapshots, and Namespace adds macOS and CI but cuts Devboxes off within a day.
A screen for computer use
exe.dev VMs are headless, and Namespace's screenshot and click API works only on macOS Devboxes. On either, a Linux agent that must use a browser or desktop app needs you to install a desktop and VNC, or pay for macOS minutes.
State saved every minute, and forks
exe.dev has no snapshots to roll back to, and Namespace has no fork. When an agent wrecks an install, you lose the session's work. bochka snapshots every minute and can fork a running sandbox to try two paths at once.
Agents you drive from outside
On exe.dev only Shelley takes prompts through the API, and Namespace leaves the agent loop to partners like Cursor or Devin. Either way you script shell sessions yourself. bochka gives one prompt, steer and events API for seven harnesses.
Use bochka 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, snapshots every minute and coding agents you drive from outside. Compare it one to one: bochka vs exe.dev and bochka vs Namespace.
Questions people ask
Is exe.dev cheaper than Namespace?
In our scenario table, yes for most loads: one agent running all month is $35 a month on exe.dev and $176 on Namespace, and 50 agents in parallel are $1,848 against $2,198. For 1,000 short jobs at once only Namespace fits, since exe.dev Personal stops at 50 VMs at once. bochka is lower than both in four of the five scenarios.
Which is faster, exe.dev or Namespace?
We can't say for exe.dev, because it was not in the public benchmark run. Namespace scored 21.79 Node.js build-and-test runs per second at 4 vCPU / 8 GB, and bochka scored 26.69 in the same run.
How long can a machine run on each?
exe.dev VMs run until you stop them, with no time limit. A Namespace Devbox is shut down after 4 hours on Developer, 5 on Team and 24 on Business, even while you work in it. bochka has no session cap on paid plans.
Can exe.dev and Namespace run Docker?
Yes. exe.dev VMs have root, systemd and Docker, and Linux Namespace Devboxes include Docker. Nested VMs need exe.dev Enterprise, and on Namespace /dev/kvm is on Linux compute instances. bochka has Docker and /dev/kvm on every machine.
Do exe.dev or Namespace support computer use?
exe.dev VMs are headless with no desktop stream. Namespace has a screenshot and click API on macOS Devboxes only, and VNC or RDP for compute instances. bochka streams a 60fps Linux desktop with Chromium, computer use and browser control.
Where do exe.dev and Namespace run?
exe.dev has nine regions in the US, Europe, Asia and Australia. Namespace runs in several regions, nearest by default, and keeping every workload in one region needs its enterprise plan. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview