Namespace vs Agent 37
Namespace is a build and dev platform: CI runners, caches and Devboxes on Linux, macOS and Windows, with each Devbox shut down after 4 to 24 hours. Agent 37 hosts one always-on sandbox per user, gVisor by default, that sleeps when idle and wakes on the next message.
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
Agent 37
Agent 37 hosts AI agents, one isolated, always-on sandbox per user, behind one API.
You create an instance from a template (Hermes, OpenClaw, Claude Code, Codex, OpenCode, Pi, Grok or your own Docker image) and talk to it through a chat API, files, exec, SSH and HTTPS URLs. The default instance is a container enforced by gVisor; a VM type gives a full Linux machine with its own kernel for Docker, Kubernetes and Android emulators. It is built for companies that give each of their customers an agent.
- Where it runs
- Dedicated servers in the United States
- Instance types
- Default (shared), Performance (dedicated cores), VM
- Compliance
- SOC 2 Type I, Type II in progress
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 | Agent 37: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Agent 37 and bochka both fit; on Agent 37 Docker needs the VM type at 2.5 times the compute rate, and a Namespace Devbox stops after 4 to 24 hours by plan. | 39th of 367, with limits $3,495 a month | 2nd cheapest of 367 $551 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Agent 37 ranks first here because one always-on assistant per user is what it is built for; a Namespace Devbox is shut down after at most 24 hours, and bochka has no session cap on paid plans. | 303rd of 366, with limits $6,645 a month | Cheapest of 366 $279 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 | 247th of 345, with limits $250 a month | Cheapest of 345 $22 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 Agent 37's top self-serve tier holds 200 instances, counting sleeping and stopped ones; Namespace publishes no Devbox concurrency limit, and bochka ranks 1st with plans up to 2,000 at once. | 284th of 361, with limits $2,068 a month | 30th of 361, with limits $79 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 | 6th of 360, with limits $363 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 | 90th of 364, with limits $58 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 All three fit; CI runners with Docker, Bazel and Turborepo caches are Namespace's main product, while Agent 37 and bochka run jobs on plain machines. | 80th cheapest of 377 $765 a month | 2nd cheapest of 377 $84 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Agent 37 and bochka keep a machine up around the clock; a Namespace Devbox stops when idle, starts on connect, and is shut down after at most 24 hours. | 126th of 368, with limits $168 a month | 3rd cheapest of 368 $12 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; Agent 37 adds a noVNC desktop through a template, and bochka streams a 60fps Linux desktop in every sandbox. | 67th of 369, with limits $982 a month | Cheapest of 369 $53 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 | 48th of 367, with limits $29 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 | Cheapest of 346 $32 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 | 36th of 338, with limits $648 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 Neither Namespace nor Agent 37 can fork a machine; bochka can copy a running sandbox to try many paths at once. | 242nd of 360, with limits $339 a month | Cheapest of 360 $43 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 on Apple Silicon, while Agent 37 and bochka are Linux only. | 6th cheapest of 36 $1,205 a month | Can't run it | Can't run it |
Key features
| Feature | Namespace | Agent 37 | 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 by default; full VM with its own kernel as an opt-in instance type | Every sandbox is a full VM with its own kernel |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 21.79 runs/s | No published result | 26.69 runs/s |
| Docker inside | Docker in Linux Devboxes | Only on the VM type, at 2.5x the default compute rate; the default gVisor type cannot run a Docker daemon | Docker, root and systemd in every sandbox |
| Nested virtualization | /dev/kvm on Linux compute instances, not on macOS or Windows | /dev/kvm on the VM type, with a ready Android template | /dev/kvm in every sandbox |
| How long a session can run | Devboxes stop after 4, 5 or 24 hours by plan, even while you work; 24 at most | No time limit; runs until stopped or put to sleep | No session cap on paid plans |
| Sleep when idle | Devboxes stop after an idle timeout (15 minutes to 8 hours) and start again on connect | Opt-in auto-sleep after a quiet period, memory kept, wakes on the next request | No idle timer; a time limit you set, or no limit |
| Fork and snapshots | No fork; compute instances can suspend and resume with RAM kept | No fork; daily backups plus one on-demand backup, restored in place only | Fork a running sandbox; snapshots every minute and on stop; named snapshots as templates |
| Desktop and computer use | Screenshot and click API on macOS Devboxes only; VNC and RDP for compute instances | noVNC desktop through a template build or the Ubuntu VM template | 60fps Linux desktop and Chromium in every sandbox, embeddable stream |
| Coding agents | Hosts Claude Managed Agents, Cursor and Devin sessions run by those partners; an MCP server for your own agent | Templates for Hermes, OpenClaw, Claude Code, Codex, Grok, OpenCode and Pi, with a chat API per instance | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Egress rules inject a header from Namespace Vault, outside the workload | Managed models, search and Composio through a per-instance token; your own keys go in as env vars | Proxy for model providers and any HTTPS API you register; switch to another account when credits run out |
| Reaching the sandbox | HTTPS URLs that need a Namespace login, TCP through a CLI port-forward; no public IP | HTTPS URL per port, signed URLs, custom domains; no public IP, SSH through a WebSocket tunnel | HTTPS URLs for up to 50 ports, raw TCP, dedicated IPv6 or IPv4 |
| Outbound internet rules | Egress policies by domain: block, advisory or allow | No egress allowlist listed | Open internet; no provider-side allowlist |
| Operating systems | Linux, macOS on Apple Silicon, Windows on Team plans and up | Linux only | Linux only; Wine for Windows apps |
| Regions | Several regions; keeping every workload in one region needs the enterprise plan | Dedicated servers in the United States | EU only (Germany, Finland, France), EU data residency |
Every feature Battleships tracks (43)
| Feature | Namespace | Agent 37 | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | Yes | Yes |
| Browser | No | Yes | 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 | No | Yes | Yes |
| Live fork (no pause) | No | Yes | 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 | Yes | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | No | No | No |
| Windows | Yes | No | No |
| Arm64 | Yes | No | 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 | Yes | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | No | No |
| EU data residency | Yes | No | 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. Agent 37 has no published result on that benchmark, so there is no comparable measurement. Agent 37's default instances share host resources, and it sells a Performance type on dedicated cores.
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). Agent 37 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 | Agent 37, 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) | $6 · Wallet (any top-up) | $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 | $12 · Wallet (any top-up) | $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) | $329 · Wallet ($100 lifetime top-ups) | $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) | $33 · Wallet ($250 lifetime top-ups) · 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 | $3,237 · Devbox (pay as you go) | $73 · Wallet ($250 lifetime top-ups) · with limits | $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. Stored files cost $0.20 per GB-month, and plan minutes cover runners and instances, not Devboxes.
Agent 37: A prepaid wallet with no plan fee, metered per minute: $0.80 per vCPU and $0.70 per GB of RAM per month while running, plus $0.09 per GB of disk per month. Performance compute costs 4x and VM compute 2.5x.
Agent 37: A monthly plan from $20, all of it 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 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 Agent 37 the limit is a count: 10 instances after a first top-up, 50 at $100 of total top-ups and 200 at $250, counting sleeping and stopped ones, so the 300 user sandboxes and the 1,000 short jobs do not fit. The 50 agents in parallel need Docker, so Agent 37 is priced on its VM type. bochka's limits are concurrency per plan and a cap on starts, which stops it in the 1,000-at-once burst.
| Scenario | Namespace | Agent 37 | 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 dev boxes for people that stop when idle.
- macOS and Windows. Useful if your agents 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 by domain. Useful if agents must reach only chosen domains: Namespace can block all other outbound traffic per Devbox blueprint, runner or instance.
Use Agent 37 when
you host one mostly idle assistant per customer in the US that should sleep with its memory kept and wake on the next message.
- Always on, with no time limit. Useful for one assistant per customer: an Agent 37 instance runs until you stop it, with no daily shutdown.
- Sleeps and keeps its memory. Useful for agents idle most of the day: an instance sleeps, saves its memory and wakes on the next message.
- Agent templates and a chat API. Useful if you want a ready agent: start from Hermes, OpenClaw, Claude Code or Codex and talk to it through a chat API.
Where bochka fits
If your agents do real work on Linux for hours or days, look at bochka. Every sandbox is a full VM with Docker, systemd and /dev/kvm, with no session cap on paid plans, forks of running machines, and a 60fps desktop. It runs in the EU.
A full VM is the default
Agent 37's default gVisor sandbox cannot run Docker, and its VM type bills 2.5 times the compute with no init system. Namespace Devboxes run from a container image, with /dev/kvm only on compute instances.
No clock, and forks of running machines
A Namespace Devbox is shut down after at most 24 hours, even mid-task. Neither Namespace nor Agent 37 can fork a machine, so each new try rebuilds its state from the start.
A Linux desktop for computer use
Namespace's screenshot and click API rejects Linux Devboxes, and Agent 37 needs a template build to add a noVNC desktop. bochka streams a 60fps Linux desktop with Chromium in every sandbox.
Use bochka when your agents work on Linux for hours or days: a full, faster VM with Docker, systemd and /dev/kvm, forks of running machines, a 60fps desktop and keys kept outside for any API. Compare it one to one: bochka vs Namespace and bochka vs Agent 37.
Questions people ask
Is Namespace cheaper than Agent 37?
No, Agent 37 costs less in every scenario we priced: one coding agent on workdays is $6 a month on Agent 37 and $50 on Namespace, and 50 agents in parallel are $329 versus $2,198. But Agent 37's 200-instance cap means it does not fit 300 user sandboxes or 1,000 short jobs at once, and Namespace does.
Which is faster, Namespace or Agent 37?
Namespace did 21.79 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's public run. Agent 37 has no published result, so they can't be compared directly. bochka did 26.69 in the same run.
Can Namespace and Agent 37 run Docker?
Namespace's Linux Devboxes include Docker. On Agent 37, Docker runs only on the VM type, which bills compute at 2.5x; the default gVisor type cannot run a Docker daemon. On bochka, Docker works in every sandbox.
How long can a session run on Namespace and Agent 37?
A Namespace Devbox is shut down after 4 hours on Developer, 5 on Team and 24 on Business, even while you work. An Agent 37 instance has no time limit and runs until you stop it or it sleeps. bochka has no session cap on paid plans.
Do Namespace or Agent 37 run macOS?
Namespace runs macOS Devboxes and instances on Apple Silicon, and Windows on Team plans and up. Agent 37 and bochka run Linux only.
Where do Namespace and Agent 37 run?
Agent 37 runs on dedicated servers 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