Tensorlake vs Docker Cloud Sandboxes
Both run each agent in a microVM with its own kernel and Docker inside. Tensorlake is an API platform for big fleets, with 1,000 sandboxes at once on Pro, warm memory clones, GPUs and your own cloud, while Docker Cloud Sandboxes moves the sbx sandboxes you run on your laptop into the cloud, 10 at a time and up to 24 hours each.
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
Docker Cloud Sandboxes
Docker Cloud Sandboxes runs Docker's sbx coding-agent microVMs on Docker-managed compute instead of your laptop.
Each sandbox is a microVM with its own Linux kernel and its own Docker Engine, started from the same sbx CLI you use locally, with Claude Code, Codex and other agents ready to run. You can move a sandbox from your laptop to the cloud and back, publish HTTPS ports and SSH in. It launched on September 24, 2026, is billed pay-as-you-go on a personal Docker account, and is built for developers who want their local agent sandboxes to keep going off their machine.
- Launched
- September 24, 2026
- Session length
- 1 hour by default, extendable to 24 hours from creation
- Default quota
- 10 concurrent and 50 stored sandboxes per account
- Regions
- Not published
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 | Docker Cloud Sandboxes: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Tensorlake fits a software factory with many agents at once; Docker stops each sandbox at 24 hours and runs 10 at a time, and bochka adds nested virtualization and built-in coding agents. | 5th cheapest of 367 $1,010 a month | 280th of 367, with limits $4,928 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An agent that lives on its machine all month fits Tensorlake Pro, which has no session cap, but not Docker, whose sandboxes end 24 hours after creation. | 9th cheapest of 366 $1,381 a month | 276th of 366, with limits $5,110 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 Both handle short code runs with memory kept between them; Docker's per-second rate with no monthly fee suits small volumes, while Tensorlake takes far more at once. | 24th cheapest of 345 $250 a month | 119th of 345, with limits $233 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 Serving your own users needs more than Docker's default of 10 sandboxes at once; Tensorlake and bochka both create one per user through an API at that scale. | 5th cheapest of 361 $471 a month | 136th of 361, with limits $1,628 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 is built for RL rollouts, with 1,000 sandboxes at once and warm clones from one state; Docker's 10 at a time and bochka's start-rate limits make it a compromise. | Cheapest of 360 $5,637 a month | 114th of 360, with limits $7,000 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 | 167th of 364, with limits $1,400 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 start clean build machines, but neither exposes /dev/kvm for Android or VM builds; bochka does, on the fastest hosts measured on the CPU benchmark. | 54th cheapest of 377 $424 a month | 172nd of 377, with limits $672 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Neither is shaped for a box that stays on all month: Tensorlake suspends idle sandboxes and Docker ends them at 24 hours, while bochka has no session cap. | 185th of 368, with limits $250 a month | 127th of 368, with limits $204 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 has an XFCE desktop with Firefox over VNC and Docker's sandboxes are terminal only; bochka has a 60fps desktop with Chromium. | 9th cheapest of 369 $294 a month | 268th of 369, with limits $1,400 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 | 277th of 367, with limits $700 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 | 262nd of 346, with limits $350 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 | 190th of 338, with limits $7,000 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 | 248th of 360, with limits $350 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 | Can't run it | Can't run it | Can't run it |
Key features
| Feature | Tensorlake | Docker Cloud Sandboxes | bochka |
|---|---|---|---|
| Isolation | Firecracker and Cloud Hypervisor microVMs with their own kernel; GPU sandboxes use gVisor | MicroVM with its own Linux kernel and its own Docker Engine; hypervisor not named | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Session length | No cap on Pro (idle timeout 600 s by default); 24 hours on prepaid credits, 2 hours on Free | 1 hour by default, at most 24 hours from creation; resuming starts a new timer | No cap on any paid plan; you set the time to live, or turn it off |
| Sandboxes at once | 1,000 on Pro, with no published start rate | 10 by default; no published way to raise it | 100 on the $20 plan, up to 2,000 on higher plans; bursts above 90 starts a minute are queued |
| Stop and resume | Named sandboxes suspend with memory and running processes and wake warm; ephemeral ones end on idle | Stop keeps memory and files; resume picks up where it left off | Disk saved every minute and on stop; resume boots the machine again; a stopped sandbox costs nothing |
| Fork | Copy a running or suspended sandbox into N warm clones with memory | Snapshot a running sandbox with disk, or disk and memory, and restore it as a new sandbox | Fork a running sandbox with its disk |
| Docker inside | Yes, on the tensorlake/ubuntu-systemd image | Yes, its own Docker Engine; the agent runs as a non-root user with sudo | Yes, with root and systemd |
| Nested virtualization | No: sandboxes set SANDBOX_KVM_AVAILABLE=0 | Not documented | Yes, /dev/kvm inside, so Android emulators and VMs run |
| Desktop and computer use | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | Terminal sessions only | 60fps Linux desktop with Chromium, computer use and browser control, embeddable stream |
| Coding agents | You bring and run your own agent; managed images are plain OS bases | Claude Code, Codex, Copilot, OpenCode and more, run and attached to from the sbx CLI | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| API keys | Stored secrets are injected into the sandbox | Cloud proxy sets the auth header for built-in AI services and custom hosts; the sandbox sees a placeholder | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Inbound traffic | HTTP, WebSocket and gRPC through an authenticated proxy on exposed ports | Public HTTPS URL per published port, not protected by Docker sign-in; not a TCP tunnel; SSH with Docker-issued certificates | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP and a dedicated IP per machine |
| Outbound rules | Allow and deny lists by domain, IP or CIDR, or no internet at all | Allow and deny rules by host, with allow-all, balanced and deny-all presets | Open internet, no provider-side allowlist; you set your own firewall as root |
| GPUs | GPU sandboxes by request (H100 shown in the docs) | CPU only | None |
| Where it runs | US and EU, or your own AWS, GCP, Azure, CoreWeave, Nebius or bare-metal account through BYOC | Docker's cloud (regions not published), or your laptop with the same microVM and CLI | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Tensorlake | Docker Cloud Sandboxes | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | Yes | 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 | Not published | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | 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 | No | 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 | Not published | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
Neither Tensorlake nor Docker Cloud Sandboxes has a result on the hpc-sandbox-benchmarks runs, so there is no comparable CPU measurement between them, and Docker does not say what hardware it uses. bochka scores 26.69 runs/s on the same Node.js build-and-test loop at 4 vCPU / 8 GB, the fastest result measured, on dedicated AMD Ryzen 9 9950X hosts. 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. Tensorlake and Docker Cloud Sandboxes have 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 | Docker Cloud Sandboxes, 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 | $49 · Docker Agentic Platform (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 | $204 · Docker Agentic Platform (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,464 · Docker Agentic Platform (pay-as-you-go) · 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 | $293 · Pro | $700 · Docker Agentic Platform (pay-as-you-go) · 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 | $1,127 · Pro | $1,400 · Docker Agentic Platform (pay-as-you-go) · with limits | $2,000 · $2000/mo · with limits |
Tensorlake: Pro is $250 per billing cycle, which includes 25,000 CU ($250) of usage, then $0.01 per CU; CPU is billed only while active, and RAM and disk on what you allocate while running. Small users can buy prepaid Usage Credits packs from $5 at higher rates, which the table does not price.
Docker Cloud Sandboxes: Docker bills per second for the size you pick, from $0.07 an hour for 1 vCPU / 2 GiB to $1.12 an hour for 16 vCPU / 32 GiB, with no monthly fee. A stopped sandbox costs nothing, but its snapshots are deleted after 7 days of non-use.
Docker Cloud Sandboxes: Plans start at $20 a month, and the whole fee becomes usage credit. Running time is billed per second, and a stopped sandbox costs nothing while its disk is kept.
Limits in those scenarios
Docker's limits decide most scenarios: every sandbox ends 24 hours after creation, so one agent that never stops does not fit, and its default of 10 at once rules it out for 50 agents in parallel, sandboxes for your users and 1,000 short jobs at once. Tensorlake Pro fits all five scenarios, with 1,000 sandboxes at once and no session cap, though an ephemeral sandbox ends after 10 idle minutes by default. bochka fits four; even its $2,000 plan queues bursts above 90 starts a minute, so 1,000 short jobs at once does not fit.
| Scenario | Tensorlake | Docker Cloud Sandboxes | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite | 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 hundreds or a thousand sandboxes at once from one warm state, run agents for longer than a day, or need GPUs, US regions or your own cloud account.
- Built for big fleets. For RL rollouts and evals, Tensorlake Pro runs 1,000 sandboxes at once and copies one warm state into many clones.
- No session cap on Pro. For agents that run for days, a Tensorlake Pro sandbox has no session cap, while Docker ends each one at 24 hours.
- GPUs, US regions and your own cloud. Tensorlake offers GPU sandboxes by request, runs in the US and EU, and can run inside your own cloud account.
Use Docker Cloud Sandboxes when
you already run agents in sbx on your laptop and want a few of them to keep going in the cloud for up to a day, paying per second with no monthly fee.
- The same sandbox on your laptop. If you already run sbx locally, the cloud is the same microVM and CLI, and you can move a sandbox either way.
- Agents ready and keys kept out. Claude Code, Codex and other agents start from the CLI, and a proxy sets their API keys so the sandbox sees a placeholder.
- Pay only for what runs. For a few agents, Docker bills per second with no monthly fee, and a stopped sandbox costs nothing.
Where bochka fits
Tensorlake and Docker Cloud Sandboxes both give an agent a small microVM with Docker inside. If your agents need a whole machine, with emulators, a real desktop, raw network ports and no session cap, and you want to drive agents inside from outside through one API, look at bochka. It runs full VMs on dedicated AMD Ryzen 9 9950X hosts, the fastest measured on the CPU benchmark.
Run emulators and VMs inside
Tensorlake sandboxes set SANDBOX_KVM_AVAILABLE=0 and Docker's docs do not offer nested virtualization, so an agent that tests an Android app or boots a VM has nowhere to run it. bochka exposes /dev/kvm in every sandbox.
Drive agents inside from outside
On Tensorlake you install the agent yourself and secrets are injected into the sandbox it controls. Docker ships agents, but you attach to their terminal, so your app has to parse text to know when one is done.
Stay on and reachable like a server
Docker ends every sandbox 24 hours after creation and runs 10 at once by default. Neither carries raw TCP, so a database an agent starts can't be reached. bochka has no session cap, 50 HTTPS ports and raw TCP.
Use bochka when your agents do real work for hours or days: builds, Docker, Android emulators and a desktop, with coding agents built in, keys kept outside the machine and raw TCP to reach what they start. Compare it one to one: bochka vs Tensorlake and bochka vs Docker Cloud Sandboxes.
Questions people ask
Is Tensorlake cheaper than Docker Cloud Sandboxes?
For one coding agent on workdays, Docker is cheaper: $49 a month against $250 on Tensorlake Pro, though Tensorlake's prepaid packs can cost less for small use. In the other four scenarios Docker does not fit, because of its 24-hour cap or its 10 sandboxes at once. bochka is $20 a month for the workday agent.
Which is faster, Tensorlake or Docker Cloud Sandboxes?
Neither has a result on the hpc-sandbox-benchmarks runs, so there is no fair CPU comparison between them. bochka scores 26.69 runs/s on that Node.js benchmark at 4 vCPU / 8 GB, the fastest measured.
Can Tensorlake and Docker Cloud Sandboxes run Docker inside?
Yes, both. Tensorlake runs Docker on its tensorlake/ubuntu-systemd image, and each Docker cloud sandbox has its own Docker Engine. Neither offers /dev/kvm for Android emulators or VMs, which bochka does.
Can a sandbox run longer than 24 hours?
On Tensorlake Pro, yes: there is no session cap, though idle sandboxes suspend or end after the idle timeout. A Docker cloud sandbox ends 24 hours after creation at most. bochka has no session cap on paid plans.
Do they keep memory when a sandbox stops?
Both do. Tensorlake suspends named sandboxes with memory and running processes and can copy one into warm clones, and Docker keeps memory and files on stop. bochka keeps the disk, saved every minute and on stop, but a resume boots the machine again.
Which one has GPUs?
Tensorlake offers GPU sandboxes by request, running on gVisor. Docker Cloud Sandboxes are CPU only, and bochka has no GPUs.
Try bochka
Install the CLI, then run bochka new.
Product preview