Namespace vs Beam
Namespace is a build and dev platform: fast GitHub Actions runners, caches and Devboxes on Linux, macOS and Windows, each Devbox capped at 24 hours at most. Beam is a serverless GPU platform with fast gVisor sandboxes, a separate line of CPU VMs, and a runtime you can self-host.
The companies and products
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
Beam
Beam is a serverless cloud for GPU inference, sandboxes and background jobs, built on its open-source runtime Beta9.
Beam runs functions, REST endpoints, task queues, pods, sandboxes and VMs on CPUs and GPUs, all from a Python or TypeScript SDK. A sandbox is a container isolated with gVisor that starts in a second or two, lives until you terminate it or its time to live runs out, and can be saved as a filesystem image or a memory snapshot. Beam VMs are a separate CPU product: a microVM with its own kernel, systemd and a root disk that stays when it stops. Much of Beam is a GPU serverless platform for AI teams.
- Bring your own cloud
- Management fee per vCPU and GB of RAM, on top of your own cloud bill
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. “80th cheapest of 377” means 79 of the other 376 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 | Namespace: price rank | Beam: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 39th of 367, with limits $3,495 a month | 69th of 367, with limits $551 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that never stops is a compromise on both: a Namespace Devbox is shut down after at most 24 hours, and a Beam sandbox needs its time to live turned off; bochka has no session cap on paid plans. | 303rd of 366, with limits $6,645 a month | 115th of 366, with limits $651 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 Beam fits short code runs well, with sandboxes that start in a second or two, bill per second and end on their own; Namespace is a compromise here. | 247th of 345, with limits $250 a month | 8th cheapest of 345 $117 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 Beam gives each of your users a quick container and fits well, while Namespace is a compromise; bochka gives each user a full VM with hosting and a disk that persists. | 284th of 361, with limits $2,068 a month | 3rd cheapest of 361 $290 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 | 356th of 360, with limits $9,012 a month | 341st of 360, with limits $939 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 | 282nd of 364, with limits $1,043 a month | 13th cheapest of 364 $251 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 with Docker, Bazel and Turborepo caches are Namespace's main product, Beam can run jobs in its sandboxes, and bochka runs them on full VMs with /dev/kvm. | 80th cheapest of 377 $765 a month | 12th cheapest of 377 $171 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Beam VM keeps its root disk while stopped and fits a dev box well; a Namespace Devbox is a compromise because it is shut down after at most 24 hours. | 126th of 368, with limits $168 a month | 13th cheapest of 368 $21 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 Namespace's screenshot and click API works on macOS Devboxes only and Beam has no desktop product; bochka streams a 60fps Linux desktop with Chromium. | 67th of 369, with limits $982 a month | 111th of 369, with limits $237 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 | 285th of 367, with limits $789 a month | 195th of 367, with limits $176 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 | 259th of 346, with limits $332 a month | 200th of 346, with limits $131 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 | 226th of 338, with limits $9,012 a month | 42nd of 338, with limits $923 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 | 242nd of 360, with limits $339 a month | 175th of 360, with limits $155 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 Beam fits: it has GPU sandboxes and serverless GPUs up to H100 and B200, while Namespace and bochka are CPU only. | Can't run it | Cheapest of 98 $458 a month | 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 Beam nor bochka has macOS. | 6th cheapest of 36 $1,205 a month | Can't run it | Can't run it |
Key features
| Feature | Namespace | Beam | bochka |
|---|---|---|---|
| Isolation | Linux Devboxes run from a container image on Namespace's own hardware; the docs do not say if each has its own kernel | gVisor container by default for sandboxes; separate Beam VMs are CPU microVMs with their own kernel | Every sandbox is a full VM with its own kernel, on dedicated AMD Ryzen 9 9950X hosts |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 21.79 runs/s | Not measured | 26.69 runs/s |
| Docker, systemd and /dev/kvm | Docker in Linux Devboxes; /dev/kvm on Linux compute instances, not on macOS or Windows | Docker in sandboxes with docker_enabled; systemd only in Beam VMs; /dev/kvm not documented | Docker, root, systemd and /dev/kvm on every machine |
| How long a session can run | Devboxes stop after 4, 5 or 24 hours by plan, even while you work; 24 hours at most | Sandbox time to live defaults to 10 minutes; set -1 to run until you terminate it | No session cap on paid plans |
| Files after a stop | A stopped Devbox keeps its storage, billed at $0.20 per GB-month used | A sandbox's files go when it ends unless you save an image or use a volume; a Beam VM keeps a 50 GiB root disk | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Snapshots and fork | No fork; compute instances can suspend and resume with RAM kept | Memory snapshot of a running sandbox, restored into new sandboxes | Fork a running sandbox with its disk into a new one |
| GPUs | No, CPU only | GPU sandboxes and serverless GPUs up to H100, H200 and B200 | No, CPU only |
| Operating systems | Linux, macOS on Apple Silicon, and Windows on Team plans and up | Linux only | Linux only; Wine for Windows apps |
| Desktop and computer use | Screenshot and click API on macOS Devboxes only; VNC and RDP for compute instances | No desktop or browser product | 60fps Linux desktop with Chromium, computer use and browser control |
| Reaching the sandbox | HTTPS URLs that need a Namespace login; TCP through a CLI port-forward; no public IP | A public HTTPS URL per exposed port with no built-in auth; no raw TCP or dedicated IP | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | Block, advisory or allow by domain, per Devbox blueprint, runner or instance | Block all outbound traffic or allow up to 10 CIDR ranges, changeable while running | Open internet on every plan; no provider-side allowlist |
| Keeping keys out of the sandbox | Egress rules inject a header from Namespace Vault, resolved outside the workload | Secrets are environment variables inside the sandbox | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| Coding agents | Hosts Claude Managed Agents, Cursor and Devin sessions run by those partners; an MCP server for your own agent | None preinstalled; you install and run them through process exec | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Self-hosting and regions | Hosted only, in several regions; region-exclusive data residency on Enterprise | Beta9 runtime is AGPL-3.0 and free to self-host; hosted in the US only | Hosted only, in the EU (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Namespace | Beam | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | No | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | No | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | Yes | No |
| Windows | Yes | No | No |
| Arm64 | Yes | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | Yes | Not published | 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. Beam has no result on that test, so we cannot say how fast its CPUs are. Beam's own guide says its sandboxes cold-boot in 1 to 3 seconds.
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). Beam 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 | Namespace, a month | Beam, 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 | $50 · Devbox (pay as you go) | $5 · Developer | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $176 · Devbox (pay as you go) · with limits | $22 · Developer | $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,198 · Devbox (pay as you go) | $410 · Team | $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,214 · Devbox (pay as you go) | $191 · Team | $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,237 · Devbox (pay as you go) | $259 · Team | $2,000 · $2000/mo · with limits |
Namespace: Devboxes are billed in Devbox Minutes at $0.004 each, pay as you go on every plan; a 4 vCPU / 8 GB Devbox uses one a minute. The Team ($100) and Business ($250) plan minutes cover runners and instances, not Devboxes, and stored files cost $0.20 per GB-month.
Beam: Beam sandboxes bill per second for each CPU core (two vCPU) and GiB of RAM until you terminate them or their time to live ends, so an idle tail is billed too. Developer has no fee, Team costs $89 a month plus usage, and there are no egress fees.
Beam: Plans start at $20 a month, and the whole fee becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps 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, and Namespace publishes no egress price. Beam's Developer plan allows 30 CPU containers at once, so 50 parallel agents need its Team plan, and Beam publishes no price for extra disk, so its scenarios count no disk cost. bochka's start limits are the tightest of the three for 1,000 short jobs at once, where its $2,000 plan queues the starts.
| Scenario | Namespace | Beam | 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 |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Namespace when
you need macOS or Windows machines, faster GitHub Actions runners with build caches, or Devboxes for people that stop when idle and wake on connect.
- macOS and Windows. Useful if your agents build iOS or Mac apps or test on Windows: Namespace runs both, and Beam is Linux only.
- 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.
- Domain egress rules and idle stop. Useful if agents may reach only chosen domains, or boxes should stop when idle and start again on connect.
Use Beam when
your agents need GPUs, when you run many short sandboxes that should start fast and end on their own, or when you must self-host the runtime.
- GPUs in the same platform. For work that needs a GPU, Beam has GPU sandboxes and serverless GPUs from RTX 4090 to H100, H200 and B200.
- Fast, short-lived sandboxes. Useful for quick code runs: sandboxes start in a second or two, bill per second and end when their timer runs out.
- Open source and your own cloud. Its Beta9 runtime is AGPL-3.0 and free to self-host, and it can run in your own cloud for a management fee.
Where bochka fits
If what you are really running is AI agents that work for hours or days on Linux, both Namespace and Beam leave pieces for you to build. Namespace cuts every Devbox off at 24 hours at most, and Beam's default sandbox is a short-lived gVisor container with no desktop and keys inside it. bochka gives each agent a full VM with no session cap, a desktop and coding agents built in.
No clock on the session
A Namespace Devbox is shut down after 4, 5 or 24 hours even mid-task, so your code must restart it daily. A Beam sandbox ends with its time to live, 10 minutes by default, and loses files unless you save an image.
A full VM with /dev/kvm and systemd
In a Beam gVisor sandbox, tools that expect a real kernel or systemd can fail, and neither Beam nor a Namespace Devbox documents /dev/kvm for emulators. bochka gives every sandbox its own kernel, root, systemd, Docker and /dev/kvm.
Desktop, agents and keys built in
Namespace's click API works on macOS only and Beam has no desktop, so a Linux browser agent needs your own setup. bochka adds a 60fps desktop, agents you drive from outside, and a proxy that keeps API keys out.
Use bochka when your agents work on Linux for hours or days: a full VM with no session cap, Docker, systemd and /dev/kvm, a 60fps desktop, and coding agents you drive from outside. Compare it one to one: bochka vs Namespace and bochka vs Beam.
Questions people ask
Is Namespace cheaper than Beam?
Not in the scenarios we priced: Beam costs less in all five. One agent that never stops comes to $22 a month on Beam against $176 on Namespace, and 50 agents in parallel come to $410 against $2,198. Beam's figures count no disk cost because it publishes no disk price.
Which is faster, Namespace or Beam?
We cannot compare them on CPU: Namespace did 21.79 runs per second on StarSling's Node.js test at 4 vCPU / 8 GB, and Beam has no result on it. bochka did 26.69 on the same test. Beam says its sandboxes cold-boot in 1 to 3 seconds.
Can Namespace and Beam run Docker?
Yes. Namespace Linux Devboxes include Docker, and Beam supports Docker inside a sandbox with docker_enabled. bochka runs Docker in a full VM that also has systemd and /dev/kvm.
How long can a session run on each?
A Namespace Devbox stops after 4, 5 or 24 hours by plan, and 24 hours is the most support can set. A Beam sandbox runs for its time to live, 10 minutes by default, or until you terminate it if you set -1. bochka has no session cap on paid plans.
Does Namespace or Beam have GPUs or macOS?
Beam has GPUs, from RTX 4090 up to H100, H200 and B200, and Namespace has none. Namespace runs macOS on Apple Silicon and Windows, and Beam is Linux only. bochka is Linux and CPU only.
Where does my data run?
Beam runs on AWS and Google Cloud in the United States. Namespace runs in several regions, 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