Namespace vs Claude Managed Agents
Namespace rents you machines: CI runners and Devboxes on Linux, macOS and Windows, which stop after 4 to 24 hours. Claude Managed Agents rents you an agent: Anthropic runs Claude in a small container it manages, and you talk to it through an events API.
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
Claude Managed Agents
Claude Managed Agents is Anthropic's ready-made agent harness: Claude runs as an autonomous agent in a cloud sandbox that Anthropic manages, and you talk to it through an events API.
This is an agent platform, not a sandbox you rent. You define an agent (model, prompt, tools, MCP servers, skills) and an environment, then start sessions, send messages as events and stream back what Claude does; the harness handles tool calls, prompt caching and compaction. Each session gets its own Ubuntu container, or runs its tools on a worker you host yourself. It is built for teams that want Claude doing long tasks without building their own agent loop or sandbox.
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 | Claude Managed Agents: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Namespace gives a coding agent a Devbox with Docker but stops it after 4 to 24 hours, and Managed Agents gives it a container with up to 8 GB of memory and Docker only in limited availability; bochka gives a full VM with no session cap. | 39th of 367, with limits $3,495 a month | 106th of 367, with limits $964 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Neither fits cleanly: a Namespace Devbox is shut down after at most 24 hours, and a Managed Agents sandbox keeps its state only 30 days after it is created; bochka has no session cap on paid plans. | 303rd of 366, with limits $6,645 a month | 219th of 366, with limits $2,511 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 Namespace bills per minute with no plan fee and Managed Agents bills runtime only while the agent works, so both handle short bursts well, while bochka's start limits make big bursts a compromise. | 247th of 345, with limits $250 a month | 163rd of 345, with limits $756 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 Your users cannot open a Managed Agents sandbox, which has no inbound ports, and Namespace URLs need a Namespace login; bochka gives each sandbox token-protected HTTPS URLs on up to 50 ports. | 284th of 361, with limits $2,068 a month | 231st of 361, with limits $823 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 | 252nd of 360, with limits $3,978 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 | 244th of 364, with limits $320 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 runners and caches for Docker, Bazel and more; Managed Agents is not a CI service, and bochka runs CI jobs on full VMs with Docker and /dev/kvm. | 80th cheapest of 377 $765 a month | 227th of 377, with limits $96 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Namespace Devbox stops when idle and wakes on connect but is shut down after at most 24 hours, and Managed Agents has no SSH at all; a bochka machine stays up as long as you want. | 126th of 368, with limits $168 a month | 224th of 368, with limits $48 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 Managed Agents has headless Chromium but no desktop; bochka streams a 60fps Linux desktop with computer use. | 67th of 369, with limits $982 a month | 127th of 369, with limits $288 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 | 126th of 367, with limits $288 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 | 127th of 346, with limits $390 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 | 155th of 338, with limits $4,798 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 | 179th of 360, with limits $160 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 Managed Agents and bochka run Linux only. | 6th cheapest of 36 $1,205 a month | Can't run it | Can't run it |
Key features
| Feature | Namespace | Claude Managed Agents | bochka |
|---|---|---|---|
| What it is | A build and dev platform: CI runners, build caches, Devboxes and a compute API | A hosted Claude agent: Anthropic's harness runs Claude in a sandbox and you send it events | A sandbox platform: each agent gets its own full Linux VM, with coding agents built in |
| Isolation | Linux Devboxes run from a container image on Namespace's own hardware; the docs do not say if each has its own kernel | Isolated Linux container per session | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | Devbox sizes from 4 vCPU / 8 GB up, billed in more Devbox Minutes for bigger sizes; vCPU is a burst ceiling | Up to 8 GB memory and 10 GB disk; vCPU not published; not configurable | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Docker and /dev/kvm | Docker in Linux Devboxes; /dev/kvm on Linux compute instances, not on macOS or Windows | Docker listed as limited availability; root, systemd and /dev/kvm not documented | Root, Docker, systemd and /dev/kvm on every machine |
| How long a session can run | Devboxes are shut down after 4, 5 or 24 hours by plan, even while you work; 24 hours at most | No session cap published; idle sessions sleep and resume on the next message | No session cap on paid plans |
| What persists | A stopped Devbox keeps its storage, billed at $0.20 per GB-month used | Sandbox is checkpointed when a session goes idle; state is kept only 30 days after the sandbox is created | The whole disk, saved every minute and on stop; a stopped sandbox costs nothing |
| Idle stop and wake | Devboxes stop after an idle timeout (15 minutes to 8 hours) and start again when you connect | Idle sessions are not billed and resume from their checkpoint on the next message | Machines run until you stop them; a stopped sandbox is started by API |
| Fork | No fork; compute instances can suspend and resume with RAM kept | No fork or clone of a session or sandbox | Fork a running sandbox into a new one with its disk |
| Reaching the sandbox | HTTPS URLs that need a Namespace login, TCP through a running CLI port-forward; no public IP | No inbound ports or SSH; reached only through the sessions and events API | Token-protected HTTPS URLs for up to 50 ports, raw TCP, SSH, dedicated IPv6 or IPv4 |
| Browser and desktop | Screenshot and click API on macOS Devboxes only; VNC and RDP for compute instances | Headless Chromium with Playwright; no desktop or computer-use tool | 60fps Linux desktop with Chromium, computer use and browser control, embeddable stream |
| Agents | Hosts Claude Managed Agents, Cursor and Devin sessions run by those partners; an MCP server lets your agent create Devboxes | Anthropic's harness with Claude models only: events, steering, interrupts, multiagent threads, memory stores and webhooks | Claude Code, Codex, OpenCode and more preinstalled, driven from outside with a prompt, steer and events API |
| Outbound rules | Egress policies per Devbox blueprint, runner or instance: block, advisory or allow by domain | Unrestricted, or limited to listed hosts plus optional package registries and MCP servers | 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 | Vault secrets sit in the sandbox as placeholders and are swapped in at egress, per host | AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Operating systems | Linux, macOS on Apple Silicon, and Windows on Team plans and up | Ubuntu 24.04 on x86_64 only | Linux only; Wine for Windows apps |
Every feature Battleships tracks (43)
| Feature | Namespace | Claude Managed Agents | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | 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 | No | Yes |
| Raw TCP inbound | Yes | No | 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 | No | Yes | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | Yes | No | No |
| Arm64 | Yes | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | 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 | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | No | 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. Claude Managed Agents was not measured, and Anthropic does not publish how many vCPUs its sandbox gets. On Managed Agents, much of a session's time is spent waiting on the model rather than the CPU.
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). Claude Managed Agents 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 | Claude Managed Agents, 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) | $13 · Claude API (pay-as-you-go, usage tiers) · with limits | $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 | $53 · Claude API (pay-as-you-go, usage tiers) · 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,198 · Devbox (pay as you go) | $634 · Claude API (pay-as-you-go, usage tiers) · with limits | $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) | $360 · Claude API (pay-as-you-go, usage tiers) · 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) | $796 · Claude API (pay-as-you-go, usage tiers) · 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. Plan minutes cover runners and instances, not Devboxes, and stored files cost $0.20 per GB-month.
Claude Managed Agents: Managed Agents bills model tokens at API rates plus a session runtime fee, metered to the millisecond only while the session runs, including time waiting on the model. The tables show runtime only; tokens come on top and usually cost more.
Claude Managed Agents: 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
On Namespace the limit that bites is time: a Devbox is shut down after 4, 5 or 24 hours by plan, so an agent that never stops restarts at least once a day, and Namespace publishes no egress price. On Managed Agents it is the box: up to 8 GB of memory and 10 GB of disk, an unpublished vCPU count and Docker in limited availability, so no scenario counts as a clean fit, and usage-tier spend limits pause all API use when reached. bochka has no session cap, but at 1,000 short jobs at once the $2,000 plan queues starts above 90 per minute and allows 2,400 starts a day.
| Scenario | Namespace | Claude Managed Agents | 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.
- macOS and Windows machines. 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.
- Machines you control. Useful if you want the box itself: a Devbox from any container image, with Docker, SSH and a choice of agent partners.
Use Claude Managed Agents when
you want Claude itself doing long, mostly text and code tasks with no harness to build, free idle time, and the option to run tools on your own workers.
- No agent loop to build. Teams that want Claude doing long tasks get the harness, caching, compaction, memory and webhooks ready to use.
- Idle time costs nothing. Agents that wait a long time between messages pay runtime only while working, and resume on the next message.
- Tools on your own workers. Teams with strict rules can run every tool call on their own infrastructure, including a Namespace Devbox, while Anthropic orchestrates.
Where bochka fits
Namespace gives you a machine that stops within a day, and Claude Managed Agents gives you Claude in a small container you cannot open. If your agents need a real Linux machine that keeps running, with Docker, a desktop, ports you can share and the agent of your choice, look at bochka.
No clock on the work
A Namespace Devbox is shut down after at most 24 hours, even mid-task, and a Managed Agents sandbox loses its state 30 days after it is created. On bochka there is no session cap, and the disk is saved every minute.
A whole VM, not a small box
Managed Agents caps a sandbox at 8 GB of memory with Docker in limited availability, and a Namespace Devbox has /dev/kvm only on compute instances. Every bochka sandbox is a full VM with its own kernel, Docker, systemd and /dev/kvm.
Open and watch what it builds
A Managed Agents sandbox has no inbound ports, and Namespace URLs need a Namespace login, with no Linux display API. bochka gives token-protected HTTPS URLs on up to 50 ports and a 60fps Linux desktop you can share.
Use bochka when your agents need a real Linux machine for hours or days: a full, faster VM with no session cap, Docker and /dev/kvm, a 60fps desktop, ports you can open, and coding agents you drive from outside. Compare it one to one: bochka vs Namespace and bochka vs Claude Managed Agents.
Questions people ask
Is Namespace cheaper than Claude Managed Agents?
For machine time alone, Managed Agents runtime costs less in all five scenarios we priced, for example $53 against $176 for one agent running all month. But Managed Agents adds model tokens on top, which usually cost more than the runtime, and its small container does not fit any scenario cleanly. On bochka the same always-on agent comes to $26 a month.
Which is faster, Namespace or Claude Managed Agents?
Only Namespace has a comparable measurement: 21.79 Node.js build-and-test runs per second at 4 vCPU / 8 GB, against 26.69 on bochka. Anthropic does not publish the vCPU count of a Managed Agents sandbox, and it was not in the benchmark.
Can Claude Managed Agents run on Namespace?
Yes. Namespace says its Devboxes host Claude Managed Agents sessions, and Anthropic's self-hosted sandboxes let tools run on workers outside Anthropic while it keeps the orchestration. A self-hosted worker needs only a Linux host with bash and outbound HTTPS, so a bochka VM can run one too.
Can Namespace or Claude Managed Agents run Docker?
Namespace Linux Devboxes include Docker, and its Linux compute instances also have /dev/kvm. Managed Agents lists Docker as limited availability and does not document root, systemd or /dev/kvm. Every bochka sandbox has root, Docker, systemd and /dev/kvm.
How long can a session run on each?
A Namespace Devbox is shut down after 4, 5 or 24 hours by plan, even while you work. Managed Agents publishes no session cap, but sandbox state is kept only 30 days after the sandbox is created. bochka has no session cap on paid plans.
Where does my data run?
Managed Agents stores data and runs code in the US only today. Namespace runs in several regions, and keeping every workload in one region needs its enterprise plan. bochka runs only in the EU (Germany, Finland and France), with a zero data retention option.
Try bochka
Install the CLI, then run bochka new.
Product preview