Modal vs Namespace
Modal runs short-lived sandboxes from code inside a serverless AI cloud with GPUs and regions around the world. Namespace is a build platform: CI runners, caches and Devboxes that keep their storage, on Linux, macOS and Windows.
The companies and products
Modal
Modal is a serverless cloud for AI work: inference, training, batch jobs and sandboxed code, all driven from Python, TypeScript or Go code.
Modal Sandboxes are containers you create from code, run commands in, and then terminate. By default they run under gVisor, a user-space kernel from Google; since October 2026 you can also pick a VM runtime with its own Linux kernel for Docker and FUSE (Battleships tracks that as a separate card, Modal VM Sandboxes). It suits teams that already run models on Modal and want short-lived, scalable code execution next to their GPUs.
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. “19th cheapest of 345” means 18 of the other 344 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 | Modal: 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 | Can't run it | 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 An agent that never stops is a compromise on both, since Modal sandboxes and Namespace Devboxes end after at most 24 hours; bochka has no session cap on paid plans. | 196th of 366, with limits $1,924 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 Modal fits short code runs fully, with fast starts and high concurrency, while Namespace bills Devboxes per minute and is a compromise here. | 19th cheapest of 345 $181 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 Modal fits per-user sandboxes well, and bochka fits too, with a stopped sandbox that keeps its disk and costs nothing. | 11th cheapest of 361 $811 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 Modal is built for many short sandboxes at once, which suits RL rollouts; Namespace and bochka are compromises for this one. | 5th cheapest of 360 $19,038 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 | 59th cheapest of 364 $1,244 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 Docker, Bazel and Turborepo caching; bochka also fits with Docker and /dev/kvm on every VM. | 126th cheapest of 377 $1,793 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 | 138th of 368, with limits $23 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 ships a Linux desktop: Modal shows how to set up VNC yourself and Namespace's click API is macOS only, while bochka streams a 60fps Linux desktop. | 98th of 369, with limits $183 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 | 177th of 367, with limits $136 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 | 267th of 346, with limits $394 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 | 223rd of 338, with limits $8,795 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 | Can't run it | 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 Only Modal fits GPU jobs, with GPUs from T4 to B300; Namespace and bochka are CPU only. | 19th cheapest of 98 $1,187 a month | 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 macOS agents, with Devboxes on Apple Silicon; Modal and bochka have no macOS. | Can't run it | 6th cheapest of 36 $1,205 a month | Can't run it |
Key features
| Feature | Modal | Namespace | bochka |
|---|---|---|---|
| Isolation | gVisor by default; a VM runtime with its own kernel is also offered | Linux Devboxes run from a container image on Namespace's own hardware; the docs do not say if each has its own kernel | Every sandbox is a full VM with its own kernel |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 12.79 runs/s (default gVisor sandbox) | 21.79 runs/s | 26.69 runs/s |
| Docker inside | Only with the VM runtime | Yes, in Linux Devboxes | Yes, with root and systemd, in every sandbox |
| Nested virtualization | VM runtime only, Team and Enterprise plans, on request | /dev/kvm on Linux compute instances, not on macOS or Windows | /dev/kvm on every machine |
| Longest session | 24 hours (default 5 minutes) | Devboxes stop after 4, 5 or 24 hours by plan, 24 at most | No session cap on paid plans |
| Files after a stop | No paused state; only files in Volumes survive | A stopped Devbox keeps its storage, billed at $0.20 per GB-month used | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Fork and snapshots | Filesystem snapshots to boot new sandboxes; memory snapshots in alpha | No fork; compute instances can suspend and resume with RAM kept | Fork a running sandbox without stopping it; resume reboots from disk |
| Desktop and computer use | Not offered; an example shows how to set up VNC yourself | Screenshot and click API on macOS Devboxes only; VNC and RDP for compute instances | 60fps Linux desktop, Chromium, computer use and browser control built in |
| Coding agents | Examples only | Hosts Claude Managed Agents, Cursor and Devin sessions; an MCP server for your own agent | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets are environment variables, or you run your own proxy in a sidecar | Egress rules inject a header from Namespace Vault, outside the workload | AI credentials proxy for model providers and any HTTPS API you register |
| Reaching the sandbox | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | HTTPS URLs that need a Namespace login; TCP through a CLI port-forward | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP |
| Outbound network rules | Block all, IP-range allowlist, domain allowlist (beta) | Block, advisory or allow by domain, per Devbox blueprint, runner or instance | Open internet; no provider-side allowlist |
| GPUs and operating systems | Linux with GPUs from T4 to B300 | Linux, macOS on Apple Silicon, Windows on Team plans and up; no GPUs | Linux only, Wine for Windows apps; no GPUs |
| Regions | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | Several regions; region-exclusive residency on Enterprise | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Modal | Namespace | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | Yes | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | Yes | 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 | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | 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) | Not published | No | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's public benchmark run of 29 September 2026, at 4 vCPU / 8 GB, bochka did 26.69 Node.js build-and-test runs per second, Namespace 21.79 and Modal's default gVisor sandbox 12.79. Namespace did about 1.7 times the work of Modal's default sandbox, and bochka about a fifth more than Namespace. A Namespace Devbox's vCPU count is a ceiling it can boost to, not a guaranteed share.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal measured on: Sandbox (gVisor), request = size, any region. 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 | Modal, 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 | $15 · Starter · with limits | $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 | $178 · Starter · with limits | $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 | $2,229 · Starter · with limits | $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 | $792 · Team | $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,193 · Team · with limits | $3,237 · Devbox (pay as you go) | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for the higher of what you request and what you use, and an idle sandbox pays until it is terminated. Starter is free with $30 of monthly credit, Team is $250 a month with $100 of credit, and pinning a region costs 1.15x to 1.75x.
Namespace: Namespace bills Devboxes 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 on Team and Business cover runners and instances, not Devboxes, and stored files cost $0.20 per GB-month.
Namespace: bochka plans start at $20 a month and the whole fee becomes usage credit, spent by the second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Both stop at 24 hours: a Modal sandbox lives at most that long, and a Namespace Devbox is shut down after 4, 5 or 24 hours by plan, so the agent that never stops fits neither. Modal also resets files outside Volumes when a sandbox ends, and its default sandbox has no Docker, so the 50-agent fleet does not fit there while it fits Namespace. For 1,000 short jobs at once, Namespace fits, while Modal's Team tier uses shared vCPUs that other tenants can slow down. Namespace does not publish an egress price.
| Scenario | Modal | Namespace | bochka |
|---|---|---|---|
| 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 |
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Modal when
your sandboxes need GPUs, must run in the US or Asia-Pacific, or are huge bursts of short jobs that finish in minutes.
- GPUs on the same platform. Useful if your agent trains or runs models: Modal rents GPUs from T4 to B300 next to its sandboxes.
- Huge bursts of short jobs. Useful for code runs and RL rollouts: Modal starts sandboxes fast and runs up to 5,000 containers on Team.
- Regions around the world. Useful if users sit outside Europe: Modal runs in the US, EU and Asia-Pacific and can pin a sandbox to one.
Use Namespace when
you need macOS or Windows machines, faster GitHub Actions runners with build caches, or Devboxes that keep their storage and stop when idle.
- macOS and Windows. Useful for iOS, Mac or Windows builds: Namespace runs macOS on Apple Silicon and Windows on Team plans and up.
- CI runners and build caches. Useful if you want faster GitHub Actions: Namespace is a drop-in runner with Docker, Bazel and Turborepo caching.
- Devboxes that keep their storage. Useful for people and agents who come back: a stopped Devbox keeps its files and starts again when you connect.
Where bochka fits
If what you are running is coding agents that work for hours or days on Linux, both Modal and Namespace end the session within 24 hours. bochka gives each agent a full VM with no session cap on paid plans, a disk saved every minute, a 60fps desktop and agents you drive from outside.
No clock on the session
A Modal sandbox ends within 24 hours and its root disk goes with it unless files sit in a Volume. A Namespace Devbox is shut down after 4, 5 or 24 hours even while it works. Either way your code must restart the agent and resume.
A full VM that is faster
Docker on Modal needs the VM runtime, and Namespace's docs do not say whether a Devbox has its own kernel. bochka gives every sandbox its own kernel, Docker, systemd and /dev/kvm, and ran 26.69 build runs per second against 12.79 and 21.79.
A Linux desktop and agents built in
Modal offers only a VNC example to set up yourself, and Namespace's click API works on macOS only. bochka streams a 60fps Linux desktop with Chromium and ships Claude Code and Codex with an API to drive them.
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, and coding agents you drive from outside. Compare it one to one: bochka vs Modal and bochka vs Namespace.
Questions people ask
Is Modal cheaper than Namespace?
It depends on the job. For sandboxes for your users, Modal comes to $792 a month against $1,214 on Namespace, and for one agent on workdays $15 against $50, though Modal resets files outside Volumes. For 50 agents in parallel they are close, $2,229 against $2,198, and bochka comes to $317 a month.
Which is faster, Modal or Namespace?
In the same public benchmark at 4 vCPU / 8 GB, Namespace did 21.79 Node.js build-and-test runs per second and Modal's default sandbox 12.79. bochka did 26.69 in the same run.
Can Modal and Namespace run Docker?
Namespace Linux Devboxes include Docker. Modal runs Docker only with its VM runtime, not in the default gVisor sandbox. Every bochka sandbox runs Docker with root and systemd.
How long can a session run on Modal or Namespace?
A Modal sandbox runs 5 minutes by default and 24 hours at most. A Namespace Devbox stops after 4 hours on Developer, 5 on Team and 24 on Business, even while you work. bochka has no session cap on paid plans.
Which one has GPUs or macOS?
Modal has GPUs from T4 to B300 but no macOS. Namespace has macOS on Apple Silicon and Windows but no GPUs. bochka runs Linux CPU machines 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