Namespace vs smol machines
Namespace is a build platform: fast CI runners, caches, and Devboxes on Linux, macOS and Windows that stop after 4 to 24 hours. smol machines runs open-source Linux microVMs with no session cap, which you can branch with their memory and run on your own servers too.
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
smol machines
smol machines makes fast, isolated Linux microVMs that run the same way on your laptop, in their hosted cloud, or on your own servers.
The core is smolvm, an open-source microVM engine built on libkrun, where each machine has its own guest kernel. smol cloud is the paid hosted service that runs fleets of those machines behind a REST API and Node, Python and Rust SDKs. It is built for developers who want one VM model from local development to production, with live branching of running machines.
- Uptime SLA
- 99.95% on Pro, Startup and Enterprise
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 | smol machines: 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 | 73rd of 367, with limits $604 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB A Namespace Devbox is shut down after at most 24 hours even while it works, while a smol machine can run with no cap but has no desktop, browser or key proxy; bochka has all of these. | 303rd of 366, with limits $6,645 a month | 148th of 366, with limits $1,038 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 smol machines fits short code runs well, with a one-minute minimum and branches of a warm machine that pay the minimum once, while Namespace is a compromise here. | 247th of 345, with limits $250 a month | 12th cheapest of 345 $140 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 smol machines fits, starting a stopped machine on the next command; bochka also fits and adds a desktop, hosting on up to 50 ports and a credentials proxy per user. | 284th of 361, with limits $2,068 a month | 7th cheapest of 361 $531 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 smol machines can branch a running machine with its memory and processes, so many rollouts start from one prepared state; Namespace has no fork. | 356th of 360, with limits $9,012 a month | 111th of 360, with limits $6,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 | 36th cheapest of 364 $670 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, and bochka adds /dev/kvm for jobs that boot VMs or Android emulators. | 80th cheapest of 377 $765 a month | 66th cheapest of 377 $514 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 126th of 368, with limits $168 a month | 216th of 368, with limits $29 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 smol cloud has no hosted desktop, while bochka streams a 60fps Linux desktop with computer use. | 67th of 369, with limits $982 a month | 90th of 369, with limits $156 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 Neither Namespace nor smol machines ships a managed browser, so you install Chromium yourself; bochka ships Chromium with browser control. | 285th of 367, with limits $789 a month | 176th of 367, with limits $136 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 | 241st of 346, with limits $242 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 | 148th of 338, with limits $4,344 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 | 252nd of 360, with limits $377 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, and neither smol machines nor bochka has macOS. | 6th cheapest of 36 $1,205 a month | Can't run it | Can't run it |
Key features
| Feature | Namespace | smol machines | bochka |
|---|---|---|---|
| What it mainly is | A CI and build platform with Devboxes for people and coding agents | An open-source microVM engine (smolvm) plus a hosted cloud, smol cloud | Agent sandboxes: full VMs with a desktop and 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 | libkrun microVM with its own guest 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) | 21.79 runs/s | Not measured | 26.69 runs/s |
| How long a session can run | Devboxes stop after 4, 5 or 24 hours by plan, 24 at most | No provider cap; an optional lifetime you set yourself | No session cap on paid plans |
| Docker and nested virtualization | Docker in Linux Devboxes; /dev/kvm on Linux compute instances | Docker inside the VM; nested virtualization not exposed in the cloud API | Docker, root, systemd and /dev/kvm on every machine |
| Fork | No fork; compute instances can suspend and resume with RAM kept | Branch a running machine with its memory and processes; checkpoints capture RAM | Fork a running sandbox with its disk; the fork boots fresh |
| Files after a stop | A stopped Devbox keeps its storage, billed at $0.20 per GB-month used | Filesystem survives a stop; stopped disk keeps billing | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Idle stop and wake | Devboxes stop after an idle timeout and start again when you connect | A command or terminal starts a stopped machine; idle apps wake on the next request | Machines run until you stop them; start a stopped one by API |
| Desktop and computer use | Screenshot and click API on macOS Devboxes only; VNC and RDP for compute instances | No hosted desktop; a guide shows running your own Chromium | 60fps Linux desktop with Chromium, computer use and browser control |
| Reaching the machine | HTTPS URLs that need a Namespace login, TCP through a CLI port-forward; no public IP | Up to 16 published ports, a command API and a WebSocket terminal; no SSH, no dedicated IP | SSH, HTTPS URLs for up to 50 ports, raw TCP, dedicated IPv4 or IPv6 |
| Keeping keys out of the sandbox | Egress rules inject a header from Namespace Vault, outside the workload | Cloud secrets are environment variables the guest can read | Credentials proxy for model providers and any HTTPS API, with account switching when credits run out |
| Coding agents | Hosts Claude Managed Agents, Cursor and Devin sessions; an MCP server for your own agent | Registry images with the Codex CLI and the Harbor eval harness, run through the command API | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Operating systems | Linux, macOS on Apple Silicon, and Windows on Team plans and up | Linux guests only, on amd64 or arm64 | Linux only; Wine for Windows apps |
| Self-hosting | No | Open-source smolvm runs on your laptop or your own servers | No |
Every feature Battleships tracks (43)
| Feature | Namespace | smol machines | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | 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 | 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 | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | Yes | No | No |
| Arm64 | Yes | Yes | 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 | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | 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. smol cloud has not been run on that test, so there is no comparable number for it; smol machines publishes a boot time under 200ms for smolvm, which is start time, not CPU speed.
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). smol machines 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 | smol machines, 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) | $25 · Standard | $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 | $93 · Standard | $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) | $1,139 · Pro | $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) | $465 · Startup | $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) | $1,389 · Startup | $2,000 · $2000/mo · with limits |
Namespace: Devboxes are billed in Devbox Minutes at $0.004 each, pay as you go on every plan, and a 4 vCPU / 8 GB Devbox uses one a minute. The minutes in the Team and Business plans cover runners and instances, not Devboxes, and stored files cost $0.20 per GB-month.
smol machines: smol cloud charges a base fee for every hour a machine runs, plus the CPU and memory the guest actually uses, with a one-minute minimum and disk billed even while stopped. Pro ($20 a month) and Startup ($150 a month) are fees on top of usage, not credit.
smol machines: 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 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 does not publish an egress price. smol machines caps how many machines you hold by plan (20 on Standard, 100 on Pro, 1,000 on Startup, stopped ones included), so 50 agents need Pro and 1,000 short jobs need Startup. bochka's limit is starts: the 1,000 short jobs at once get queued above 90 starts a minute, so that scenario does not fit on bochka.
| Scenario | Namespace | smol machines | bochka |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
| None that bite | None that bite |
| 50 agents in parallel |
| None that bite | None that bite |
| Sandboxes for your users |
| None that bite | None that bite |
| 1,000 short jobs at once |
| None that bite |
|
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. 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.
- Keys injected outside the box. Useful if agents call APIs with secrets: Namespace egress rules add a header from its Vault outside the workload.
Use smol machines when
you want one open-source VM engine from your laptop to your own servers, or fan out many branches of a running machine with its memory.
- Open source, laptop to servers. Teams that want the same VM locally, in a hosted cloud and on their own servers can do it with one open-source engine.
- Live branches with memory. Useful for RL and test fan-out: branch a running machine with its memory and processes, and pay the minimum once.
- No clock on a machine. Useful for agents that run for days: smol cloud imposes no session cap, while a Namespace Devbox stops within 24 hours.
Where bochka fits
Namespace is strongest at CI and Apple builds, and smol machines at open-source microVMs that branch with memory. If what you are running is Linux agents that work for hours or days and need a whole machine, bochka gives each one a full VM with nested virtualization, a desktop, SSH and coding agents built in.
A whole machine, with no time limit
A Namespace Devbox is shut down after 24 hours at most, and smol cloud does not expose /dev/kvm, so an Android emulator or nested VM cannot start. bochka has no session cap on paid plans and /dev/kvm on every machine.
A Linux desktop for computer use
Namespace's screenshot and click API rejects Linux Devboxes, and smol cloud has no hosted desktop. On either you install, package and maintain a desktop, a browser and a screen stream yourself. bochka streams a 60fps Linux desktop with Chromium.
Agents and keys built in
On smol cloud secrets are plaintext in the guest, and on Namespace a partner runs the agent loop or you write your own harness. bochka ships coding agents you drive from outside and keeps real keys in a credentials proxy.
Use bochka when your agents work on Linux for hours or days and need a whole machine: Docker and /dev/kvm, SSH, a 60fps desktop, coding agents you drive from outside and keys that never enter the sandbox. Compare it one to one: bochka vs Namespace and bochka vs smol machines.
Questions people ask
Is Namespace cheaper than smol machines?
Not in the scenarios we priced. One coding agent on workdays comes to $50 a month on Namespace and $25 on smol machines, and 50 agents in parallel come to $2,198 versus $1,139. On bochka those two come to $20 and $317.
Which is faster, Namespace or smol machines?
We can only say for Namespace: it did 21.79 runs per second on StarSling's Node.js test at 4 vCPU / 8 GB, and bochka did 26.69. smol cloud has not been run on that test.
Can Namespace and smol machines run Docker?
Yes, both run Docker inside the machine. Namespace exposes /dev/kvm on Linux compute instances, while smol cloud does not expose nested virtualization on hosted machines. bochka has Docker and /dev/kvm on every machine.
How long can a machine run on each?
A Namespace Devbox stops after 4, 5 or 24 hours by plan, even while you work, and 24 is the most support can raise it to. smol cloud has no provider cap, only a lifetime you can set yourself. bochka has no session cap on paid plans.
Can either one fork a running machine?
smol machines can branch a running machine into children that keep its memory and processes. Namespace has no fork, though its compute instances can suspend and resume with RAM kept. bochka forks a running sandbox with its disk.
Do Namespace or smol machines run macOS?
Namespace does, on Apple M4 Pro and M5 Max chips, and it runs Windows on Team plans and up. smol machines runs Linux guests only, and so does bochka.
Try bochka
Install the CLI, then run bochka new.
Product preview