Tensorlake vs Modal VM Sandboxes
Both give an agent its own Linux kernel with Docker inside. Tensorlake's microVMs can sleep with their memory and wake up warm, while Modal's VM Sandboxes are short-lived machines that end within 24 hours, next to Modal's inference and training.
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
Modal VM Sandboxes
Modal is a serverless cloud for AI work, and VM Sandboxes are the version of its sandboxes that run in a virtual machine with their own Linux kernel.
You create a VM Sandbox from Python, TypeScript or Go code with runtime="vm", run commands in it, and terminate it when the job is done. Modal built the runtime on the Rust-based Cloud Hypervisor, so Docker, FUSE, systemd and nested cgroups work, with the same API, images and prices as its gVisor sandboxes. It became generally available on 1 October 2026 and suits teams that want many short-lived agent machines next to Modal's inference and training.
- Funding
- Over $466M raised
- Generally available
- 1 October 2026; early customers launched over 20 million VMs before that
- Session length
- Default 5 minutes, maximum 24 hours
- Compliance
- SOC 2 on every plan; HIPAA on 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. “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 | Modal VM 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 full software factory because its sandboxes keep their state, while a Modal VM ends within 24 hours; bochka adds /dev/kvm and a desktop to check the app. | 5th cheapest of 367 $1,010 a month | 84th of 367, with limits $759 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 needs no session cap: Tensorlake Pro and bochka have none, and Modal VM Sandboxes stop at 24 hours. | 9th cheapest of 366 $1,381 a month | Can't run it | 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 | 24th cheapest of 345 $250 a month | Can't run it | 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 | 5th cheapest of 361 $471 a month | Can't run it | 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 first here, built for a thousand rollouts at once from one warm state; Modal handles big bursts too, and bochka's start-rate limits queue them. | Cheapest of 360 $5,637 a month | 171st of 360, with limits $16,322 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 | Can't run it | 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 run Docker builds in a VM; bochka's Ryzen 9 9950X hosts are the fastest measured, and Modal's VM runtime measured 15.54 runs/s against bochka's 26.69. | 54th cheapest of 377 $424 a month | 188th of 377, with limits $1,064 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A box that stays on all day fits bochka best, since Tensorlake is built around suspending idle sandboxes and Modal ends each VM within 24 hours. | 185th of 368, with limits $250 a month | Can't run it | 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 ships an XFCE desktop with Firefox over VNC and control calls; on Modal you install Xvfb, VNC and a browser yourself; bochka streams a 60fps desktop. | 9th cheapest of 369 $294 a month | Can't run it | 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 | Can't run it | 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 | Can't run it | 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 | Can't run it | 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 Both give root in a real kernel; Modal and bochka also take raw TCP inbound, which Tensorlake's HTTP proxy does not carry. | 4th cheapest of 360 $250 a month | 294th of 360, with limits $642 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 | Modal VM Sandboxes | bochka |
|---|---|---|---|
| Isolation | Firecracker and Cloud Hypervisor microVMs with their own kernel | VM with its own Linux 7.2 kernel on Cloud Hypervisor | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker, systemd, root | Yes, on the tensorlake/ubuntu-systemd image | Yes; you start dockerd yourself as the entrypoint | Yes, in every sandbox |
| Nested virtualization | No: sandboxes set SANDBOX_KVM_AVAILABLE=0 | Team and Enterprise plans only, on request | Yes, /dev/kvm on every plan |
| Longest session | No cap on Pro (idle timeout still applies); 24 hours on prepaid credits, 2 hours on Free | 24 hours (default 5 minutes); continue from a filesystem snapshot | No cap on paid plans; you set the time to live |
| Pause and resume | Named sandboxes suspend with memory and running processes, billed as snapshot storage | No paused state; a finished sandbox is gone, only Volumes and snapshots keep files | Stop for free and resume with the whole disk, saved every minute; resume reboots |
| Memory snapshots | Yes: memory snapshots restore warm | Alpha: snapshotting ends the sandbox, snapshots expire after 7 days | No; resume boots the VM again |
| Clone a sandbox | Copy a running or suspended sandbox into N warm clones with memory | Snapshot the filesystem into an image and boot new sandboxes from it | Fork a running sandbox with its disk |
| Desktop and computer use | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | Not offered; an example shows how to set up Xvfb and VNC yourself | 60fps desktop and Chromium, computer-use and browser control, embeddable stream |
| Coding agents and API keys | Bring your own agent; stored secrets are injected into the sandbox | Examples only; secrets are environment variables, or you run your own proxy in a sidecar | Claude Code, Codex and others preinstalled with a prompt, steer and events API; real keys stay in a proxy outside |
| Inbound traffic | HTTP, WebSocket and gRPC through an authenticated proxy | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | 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 | Block all, IP-range allowlist, domain allowlist (beta) | No provider-side allowlist; you set your own firewall as root |
| CPU benchmark (4 vCPU / 8 GB) | Not measured | 15.54 runs/s | 26.69 runs/s |
| GPUs | GPU sandboxes by request, on gVisor | None on the VM runtime; GPU sandboxes need gVisor | None |
| Where it runs | US and EU, or your own AWS, GCP, Azure, CoreWeave, Nebius or bare-metal account | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Tensorlake | Modal VM Sandboxes | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Yes | 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 | No | Yes |
| Automatic snapshots | Yes | No | 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 | Yes | No |
| Wake on request | Yes | No | 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 | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | No | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | 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 | Not published | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
In the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, run on 29 September 2026, bochka finished 26.69 runs per second and Modal's VM runtime 15.54, so bochka did about 1.7 times the CPU work in the same time. Tensorlake has no result on this benchmark, so there is no comparable CPU measurement for it. This measures CPU speed only, not start time.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal VM Sandboxes measured on: VM Sandbox, request = size. 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 | Modal VM 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 | $15 · Starter · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Pro | $178 · Starter · 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,229 · Starter · 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 | $792 · Team | $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,193 · Team · with limits | $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, RAM and disk on what you allocate while running, and a suspended sandbox pays snapshot storage; small users can buy prepaid packs from $5 instead.
Modal VM Sandboxes: Modal bills by the second for whichever is higher, the CPU and memory you request or what you use, until the sandbox ends. Starter is free with $30 of monthly credit, Team is $250 a month with $100 of credit, and pinning a region multiplies the price by 1.15x to 1.75x.
Modal VM Sandboxes: bochka 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
A Modal VM Sandbox lives at most 24 hours and its root disk is gone when it ends, so the workday, always-on and 50-agent scenarios only keep files you put in a Volume or a snapshot, which is why they do not fit. Its 1,000-job burst is priced on Team with shared vCPUs that other tenants can slow. Tensorlake fits all five scenarios on Pro, but an ephemeral sandbox ends after 10 idle minutes by default and CPU, memory and disk are fixed at creation. On bochka the limit that bites is start speed: even the $2,000 plan queues bursts above 90 starts a minute, so 1,000 jobs at once does not fit.
| Scenario | Tensorlake | Modal VM Sandboxes | 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 | None that bite |
| 1,000 short jobs at once | None that bite |
|
|
Which one should you use?
Use Tensorlake when
your agents need to pause with their memory and resume warm, fan out a thousand rollouts from one state, or run on GPUs or in your own cloud account.
- Sleep with memory, wake up warm. Useful when an agent must pick up mid-process: a named sandbox suspends with its memory and can be copied into warm clones.
- Sessions that keep going. On Pro there is no session cap, so an agent can come back to the same sandbox instead of starting over every 24 hours.
- GPUs and your own cloud. Tensorlake offers GPU sandboxes by request and can run sandboxes in your own AWS, GCP, Azure, CoreWeave, Nebius or bare-metal account.
Use Modal VM Sandboxes when
you run huge bursts of short jobs that finish within a day, need regions in Asia-Pacific, or already run your models on Modal.
- Huge bursts of short jobs. Useful for big fan-outs that finish within a day: Modal runs 5,000 containers at once on Team and more on Enterprise.
- Regions and raw TCP. Modal runs in the US, EU and Asia-Pacific, and it can tunnel raw TCP into a sandbox as well as HTTPS.
- One platform with inference and training. Useful if you already serve or train models on Modal: sandboxes and models sit on one account and one bill.
Where bochka fits
If your agents do hours of real work in one machine, with installs, builds, Docker, emulators and a desktop, look at bochka. Each sandbox is a full VM that keeps its disk, stops for free and has coding agents built in, with keys kept outside the machine.
Run emulators and VMs inside
Tensorlake sandboxes have no /dev/kvm, so an Android emulator or a VM does not start. Modal turns on nested virtualization only on Team or Enterprise after you ask support. bochka has /dev/kvm on every plan.
Coding agents in, keys out
On both, you install the agent harness yourself and your secrets end up inside the sandbox, where one prompt injection can read them, unless you build a sidecar proxy on Modal. bochka ships the agents and keeps real keys in a proxy outside.
A faster machine that keeps its work
A Modal VM ends within 24 hours and loses its root disk, and it did 15.54 runs/s against bochka's 26.69 in the same CPU test. Tensorlake has no published score. bochka saves the disk every minute and stops for free.
Use bochka when your agents work for hours or days in a machine they come back to: installs, builds, tests, Docker, emulators and a desktop, with coding agents built in and keys kept outside. Compare it one to one: bochka vs Tensorlake and bochka vs Modal VM Sandboxes.
Questions people ask
Is Tensorlake cheaper than Modal VM Sandboxes?
For bigger workloads, yes: 50 agents in parallel cost $1,030 a month on Tensorlake Pro against $2,229 on Modal, and sandboxes for your users cost $293 against $792. For one agent on workdays Modal is cheaper ($15 against $250), but its files reset between days unless you use a Volume. bochka prices that workday agent at $20 and the 50 agents at $317.
Which is faster, Tensorlake or Modal VM Sandboxes?
Modal's VM runtime did 15.54 runs per second on the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB. Tensorlake has no result on that test, so the two cannot be compared on CPU speed. bochka did 26.69 in the same run.
How long can a sandbox run on each?
On Tensorlake Pro there is no session cap, though an idle timeout of 600 seconds by default suspends or ends a sandbox. A Modal VM Sandbox has a default timeout of 5 minutes and a maximum of 24 hours. bochka has no session cap on paid plans.
Can Tensorlake and Modal run Docker and Android emulators?
Both run Docker inside the VM. Tensorlake has no nested virtualization, so Android emulators do not run, and Modal offers it on Team and Enterprise after you ask support. bochka exposes /dev/kvm on every plan.
Which one keeps a sandbox's memory?
Tensorlake: named sandboxes suspend with memory and running processes, and can be copied into warm clones. Modal's memory snapshots on VMs are alpha, end the original sandbox and expire after 7 days. bochka keeps the disk but reboots on resume.
Which one has GPUs?
Tensorlake offers GPU sandboxes by request, running on gVisor. Modal VM Sandboxes have no GPUs; only Modal's gVisor sandboxes do. bochka has no GPUs.
Try bochka
Install the CLI, then run bochka new.
Product preview