Tensorlake vs Namespace
Tensorlake is built for agent sandboxes: microVMs that boot fast, freeze their memory and copy into warm clones. Namespace is mainly a CI and build platform, and its Devboxes are remote machines for people and coding agents that stop after 4 to 24 hours.
The companies and products
Tensorlake
Tensorlake is a San Francisco company that sells infrastructure for AI agents, with sandboxes as its main product.
Tensorlake Sandboxes are microVMs, backed by Firecracker and Cloud Hypervisor, that you create through an API and that boot in a few hundred milliseconds. Named sandboxes suspend when idle and keep their memory and running processes, and you can copy a running sandbox into several warm clones. Around them Tensorlake sells versioned file systems, hosted Git, an orchestration layer and a bring-your-own-cloud option, aimed at teams running coding agents, evals and RL rollouts.
- Headquarters
- San Francisco
- Investors shown
- Redpoint and Amplify Partners
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. “5th cheapest of 367” means 4 of the other 366 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 | Tensorlake: 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 | 5th cheapest of 367 $1,010 a month | 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 Tensorlake fits an assistant that never stops on its Pro plan, while a Namespace Devbox is shut down after at most 24 hours even while it works; bochka also has no session cap on paid plans. | 9th cheapest of 366 $1,381 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 Tensorlake fits lots of one-minute runs, while Namespace and bochka are compromises here: Namespace through its Devbox time limit and bochka through its start-rate limits. | 24th cheapest of 345 $250 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 Tensorlake creates a sandbox per user through an API and fits; on Namespace this is a compromise, and bochka adds HTTPS URLs and raw TCP for each sandbox. | 5th cheapest of 361 $471 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 Tensorlake ranks 1st here: it runs up to 1,000 sandboxes at once on Pro and copies one warm state into many clones; Namespace and bochka are compromises. | Cheapest of 360 $5,637 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 | 24th cheapest of 364 $506 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 Both fit; CI runners with build caches are Namespace's main product, Tensorlake runs fresh microVMs, and bochka runs CI jobs on full VMs with Docker and /dev/kvm. | 54th cheapest of 377 $424 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 Both are compromises for a box that stays on all day: Tensorlake is built around suspending idle sandboxes and Namespace shuts a Devbox down after at most 24 hours; a bochka machine stays up as long as you want. | 185th of 368, with limits $250 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 Tensorlake fits with an XFCE desktop over VNC and screenshot, mouse and keyboard calls, while Namespace's computer-use API works on macOS Devboxes only; bochka streams a 60fps Linux desktop. | 9th cheapest of 369 $294 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 | 13th cheapest of 367 $250 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 | 22nd cheapest of 346 $250 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 | 121st of 338, with limits $3,484 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 | 4th cheapest of 360 $250 a month | 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 | 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 Tensorlake nor bochka has macOS. | Can't run it | 6th cheapest of 36 $1,205 a month | Can't run it |
Key features
| Feature | Tensorlake | Namespace | bochka |
|---|---|---|---|
| Isolation | Firecracker and Cloud Hypervisor microVMs with their own kernel; GPU sandboxes use gVisor | Linux Devboxes run from a container image on Namespace's own hardware; the docs do not say if each has its own 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) | No published result on this benchmark | 21.79 runs/s | 26.69 runs/s |
| Docker and nested virtualization | Docker on the tensorlake/ubuntu-systemd image; no /dev/kvm (SANDBOX_KVM_AVAILABLE=0) | Docker in Linux Devboxes; /dev/kvm on Linux compute instances, not on macOS or Windows | Docker, root, systemd and /dev/kvm on every machine |
| How long a session can run | No duration cap on Pro, 24 hours on prepaid credits, 2 hours on Free; ephemeral sandboxes end after 10 idle minutes by default | Devboxes stop after 4, 5 or 24 hours by plan, even while you work, raisable to 24 at most | No session cap on paid plans |
| Memory snapshots and suspend | Named sandboxes suspend with memory and running processes, and restore warm | Compute instances can suspend and resume with RAM kept; Devboxes keep their storage | No: disk is kept, resume reboots the machine |
| Clone a running sandbox | Copy a running or suspended sandbox into N warm clones with memory | No fork | Fork a running sandbox (disk) |
| Files after a stop | A suspended sandbox pays snapshot storage per GB-month | A stopped Devbox keeps its storage, billed at $0.20 per GB-month used | Snapshots every minute and on stop; a stopped sandbox costs nothing |
| Desktop and computer use | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | Screenshot and click API on macOS Devboxes only; VNC and RDP for compute instances | 60fps Linux desktop and Chromium, computer use and browser control, embeddable stream |
| Coding agents | You bring and run your own agent; managed images are plain OS bases | Hosts Claude Managed Agents, Cursor and Devin sessions run by those partners; an MCP server lets your own agent create Devboxes | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Stored secrets are injected into the sandbox | Egress rules inject a header from Namespace Vault, resolved outside the workload | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out |
| Reaching the sandbox | HTTP, WebSocket and gRPC through an authenticated proxy on exposed ports; no raw TCP | HTTPS URLs that need a Namespace login, TCP through a running CLI port-forward; no public IP | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP and a dedicated IP per machine |
| Outbound rules | allow_out and deny_out lists by domain, IP or CIDR, or no internet at all | Egress policies per Devbox blueprint, runner or instance: block, advisory or allow by domain | No provider-side allowlist; you set your own firewall as root |
| Operating systems and GPUs | Linux; GPU sandboxes by request (H100 shown in the docs) | Linux, macOS on Apple Silicon, and Windows on Team plans and up; no GPUs | Linux only, with Wine for Windows apps; no GPUs |
| Where it runs | US and EU, or your own cloud account through BYOC | Several regions, nearest by default; keeping every workload in one region needs Enterprise | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Tensorlake | Namespace | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | Yes | Yes |
| Browser | Yes | No | 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 | Yes | No | Yes |
| Live fork (no pause) | Yes | 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 | Yes | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | 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 | Yes | 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) | No | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Yes | 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. Tensorlake has no published result on this benchmark, so it has no comparable CPU measurement. Tensorlake's docs say its default image starts in a few hundred milliseconds.
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). Tensorlake 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 | Tensorlake, 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 | $250 · Pro | $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 | $250 · Pro | $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 | $1,030 · Pro | $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 | $293 · Pro | $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 | $1,127 · Pro | $3,237 · Devbox (pay as you go) | $2,000 · $2000/mo · with limits |
Tensorlake: Pro is $250 per billing cycle, which includes 25,000 CU of usage, then $0.01 per CU; CPU is billed only while it is actively working, and RAM and disk on what you allocate. Small users can buy prepaid Usage Credits packs from $5 instead, and the table prices the Pro path.
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 minutes in the Team and Business plans cover runners and instances, not Devboxes, and stored files cost $0.20 per GB-month.
Namespace: You pick a monthly plan from $20, 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
The limit that bites on Namespace is time: a Devbox is shut down after 4, 5 or 24 hours by plan, so the agent that never stops does not fit without a daily restart, and Namespace publishes no egress price. Tensorlake's Pro plan has no duration cap and allows 1,000 sandboxes at once, so every scenario fits, but its prepaid Usage Credits plan caps sessions at 24 hours and sandboxes at 4 vCPU / 16 GB. On bochka the limit is how fast new machines start, so 1,000 short jobs at once does not fit even on the $2,000 a month plan.
| Scenario | Tensorlake | Namespace | 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 Tensorlake when
you fan out many short rollouts or evals at once from one warm state, need memory snapshots, or need GPUs, US regions or sandboxes in your own cloud.
- Memory snapshots and warm clones. Useful when an agent must pick up mid-process: Tensorlake saves a sandbox's memory and copies it into warm clones.
- Built for big fan-outs. Useful for RL rollouts and evals: Tensorlake Pro runs up to 1,000 sandboxes at once with no published start rate.
- GPUs and your own cloud. Tensorlake offers GPU sandboxes by request and can run in your own AWS, GCP, Azure, CoreWeave, Nebius or bare-metal account.
Use Namespace when
you want faster GitHub Actions runners with build caches, need macOS or Windows machines, or want 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.
- Devboxes that stop when idle. Useful for people's dev machines: a Devbox stops after an idle timeout and starts again when you connect.
Where bochka fits
If what you are really running is agents that work for hours on Linux, bochka gives each one a full VM with /dev/kvm, no session cap on paid plans and coding agents you drive from outside. Tensorlake is stronger for warm memory clones and huge bursts, and Namespace for CI and macOS, but neither ships the agent, the 60fps desktop and raw TCP in one machine.
Run emulators and VMs inside
Tensorlake sandboxes have no /dev/kvm, so an Android emulator never starts. Namespace documents /dev/kvm only on Linux compute instances, which stop after 3 to 24 hours. Every bochka machine has /dev/kvm, Docker and systemd.
No clock on the session
A Namespace Devbox is shut down at its 4, 5 or 24 hour limit even mid-task, so your code must restart it daily. On Tensorlake an ephemeral sandbox ends after 10 idle minutes; named ones suspend and pay snapshot storage.
Agents built in, keys kept outside
On Tensorlake you install the agent yourself and secrets are injected into the sandbox. On Namespace you sign up for a partner's agent service or write that wiring. bochka ships the agents, and its proxy keeps keys out and switches accounts when credits run out.
Use bochka when your agents work on Linux for hours or days: a full, fast VM with no session cap, Docker and /dev/kvm, a 60fps desktop, and coding agents you drive from outside with keys kept out. Compare it one to one: bochka vs Tensorlake and bochka vs Namespace.
Questions people ask
Is Tensorlake cheaper than Namespace?
It depends on the shape. One coding agent on workdays is $50 a month on Namespace and $250 on Tensorlake Pro, but 50 agents in parallel is $1,030 on Tensorlake against $2,198 on Namespace, and 1,000 short jobs at once is $1,127 against $3,237. On bochka those come to $20, $317 and a no-fit, because of its start-rate limits.
Which is faster, Tensorlake or Namespace?
On StarSling's Node.js build-and-test benchmark at 4 vCPU / 8 GB, Namespace did 21.79 runs per second and bochka did 26.69. Tensorlake has no published result there, so there is no direct CPU comparison with it.
Can Tensorlake or Namespace run Docker and Android emulators?
Both run Docker: Tensorlake on its ubuntu-systemd image and Namespace in Linux Devboxes. Tensorlake has no /dev/kvm, so emulators and VMs do not start, while Namespace offers /dev/kvm on Linux compute instances. bochka has Docker and /dev/kvm on every machine.
How long can a sandbox run on each?
Tensorlake Pro has no duration cap, though ephemeral sandboxes end after 10 idle minutes by default and prepaid credits cap sessions at 24 hours. A Namespace Devbox stops after 4, 5 or 24 hours by plan, even while you work. bochka has no session cap on paid plans.
Can I keep a sandbox's memory when it stops?
On Tensorlake, yes: named sandboxes suspend with memory and running processes and can be copied into warm clones. Namespace compute instances can suspend with RAM kept, while Devboxes keep their storage. bochka keeps the disk through snapshots every minute, but a resume boots the machine again.
Which one has macOS or GPUs?
Namespace runs macOS on Apple Silicon and Windows on Team plans and up, but has no GPUs. Tensorlake offers GPU sandboxes by request and runs Linux only. bochka runs Linux only and has no GPUs.
Try bochka
Install the CLI, then run bochka new.
Product preview