Modal vs Tensorlake
Modal runs short-lived gVisor sandboxes inside a big AI compute platform, with GPUs and regions around the world, and each sandbox ends within 24 hours. Tensorlake runs Firecracker microVMs with their own kernel that can suspend with their memory, wake up warm and run Docker.
The companies and products
Modal
Modal is a serverless cloud for AI work: inference, training, batch jobs and sandboxed code, all driven from Python, TypeScript or Go code.
Modal Sandboxes are containers you create from code, run commands in, and then terminate. By default they run under gVisor, a user-space kernel from Google; since October 2026 you can also pick a VM runtime with its own Linux kernel for Docker and FUSE (Battleships tracks that as a separate card, Modal VM Sandboxes). It suits teams that already run models on Modal and want short-lived, scalable code execution next to their GPUs.
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
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. “19th cheapest of 345” means 18 of the other 344 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 | Modal: price rank | Tensorlake: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker and a disk that lasts, which Tensorlake and bochka both give, while Modal's default sandbox has neither. | Can't run it | 5th cheapest of 367 $1,010 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on agent hits Modal's 24-hour session cap, while Tensorlake Pro and bochka paid plans have no session cap. | 196th of 366, with limits $1,924 a month | 9th cheapest of 366 $1,381 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 For lots of short code runs, Modal and Tensorlake both fit well, and bochka's start-rate limits make big bursts a compromise. | 19th cheapest of 345 $181 a month | 24th cheapest of 345 $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 | 11th cheapest of 361 $811 a month | 5th cheapest of 361 $471 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 RL rollouts are where Tensorlake leads, with 1,000 sandboxes at once on Pro and warm clones from one state; Modal fits too at a higher price. | 5th cheapest of 360 $19,038 a month | Cheapest of 360 $5,637 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 | 59th cheapest of 364 $1,244 a month | 24th cheapest of 364 $506 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 jobs that build Docker images run on Tensorlake and bochka, while Modal needs its separate VM runtime for Docker. | 126th cheapest of 377 $1,793 a month | 54th cheapest of 377 $424 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 is a compromise on both: Modal ends sessions at 24 hours and Tensorlake is built around suspending idle sandboxes. | 138th of 368, with limits $23 a month | 185th of 368, with limits $250 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 ships an XFCE desktop over VNC with mouse and keyboard calls, Modal leaves the desktop to you, and bochka has a 60fps desktop built in. | 98th of 369, with limits $183 a month | 9th cheapest of 369 $294 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 | 177th of 367, with limits $136 a month | 13th cheapest of 367 $250 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 | 267th of 346, with limits $394 a month | 22nd cheapest of 346 $250 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 | 223rd of 338, with limits $8,795 a month | 121st of 338, with limits $3,484 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 | Can't run it | 4th cheapest of 360 $250 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 Only Modal has GPUs from T4 to B300 next to its sandboxes, so it is the pick for GPU eval jobs. | 19th cheapest of 98 $1,187 a month | 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 | Modal | Tensorlake | bochka |
|---|---|---|---|
| Isolation | gVisor user-space kernel by default; a separate VM runtime is available | Firecracker and Cloud Hypervisor microVMs with their own kernel; GPU sandboxes use gVisor | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker inside | Only with the VM runtime | Yes, on the tensorlake/ubuntu-systemd image | Yes, in every sandbox, with root and systemd |
| Nested virtualization | VM runtime only, Team and Enterprise plans, on request | No: sandboxes set SANDBOX_KVM_AVAILABLE=0 | Yes, /dev/kvm inside, so Android emulators and VMs run |
| Longest session | 24 hours (default 5 minutes) | No cap on Pro; idle timeout of 600 s by default | No cap on paid plans (default TTL 1 h, changeable) |
| Stop and resume | No paused state; a finished sandbox is gone, only Volumes keep files | Named sandboxes suspend with memory and running processes, then wake up warm | Stop for free and resume later with the whole disk; resume reboots the machine |
| Memory snapshots | Yes, in alpha: snapshotting ends the sandbox, snapshots expire after 7 days | Yes: memory snapshots restore running processes warm | No: disk is kept, resume reboots the machine |
| Clone a running sandbox | Snapshot the filesystem into an image and boot new sandboxes from it | Copy a running or suspended sandbox into N warm clones with memory | Fork a running sandbox without stopping it (disk) |
| Desktop and computer use | Not offered; an example shows how to set up VNC yourself | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | 60fps desktop and Chromium, computer-use and browser control, embeddable stream |
| Coding agents and API keys | Examples only; secrets are environment variables, or you run your own proxy in a sidecar | You bring your own agent; stored secrets are injected into the sandbox | Claude Code, Codex and others preinstalled with an API to drive them; a credentials proxy keeps real keys outside |
| Inbound traffic | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | HTTP, WebSocket and gRPC through an authenticated proxy on exposed ports | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP and a dedicated IP per machine |
| Outbound rules | Block all, IP-range allowlist, domain allowlist (beta) | allow_out and deny_out lists by domain, IP or CIDR, or no internet at all | No provider-side allowlist; you set your own firewall as root |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | GPU sandboxes by request (H100 shown in the docs), no published rate | None |
| Where it runs | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | US and EU, or your own cloud account through BYOC | EU only: Germany, Finland, France |
| Sandboxes at once | 100 containers on Starter, 5,000 on Team | 1,000 on Pro, unlimited on Enterprise | Depends on the plan; bursts above 90 starts a minute are queued |
Every feature Battleships tracks (43)
| Feature | Modal | Tensorlake | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Yes | Yes |
| Desktop GUI | No | Yes | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | No | 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 | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | No | 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 | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | Yes | 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) | Not published | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Yes | Yes |
Performance
On 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 default gVisor sandbox 12.79, so bochka did about twice the work. Tensorlake has no published result on this benchmark, so there is no comparable CPU measurement for it. 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. Modal measured on: Sandbox (gVisor), request = size, any region. 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 | Modal, a month | Tensorlake, 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 | $15 · Starter · with limits | $250 · Pro | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $178 · Starter · with limits | $250 · Pro | $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,229 · Starter · with limits | $1,030 · 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 | $792 · Team | $293 · Pro | $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,193 · Team · with limits | $1,127 · Pro | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for whichever is higher, the CPU and memory you request or what you use, and an idle sandbox pays until it is terminated. 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.
Tensorlake: Tensorlake Pro is $250 per billing cycle with $250 of usage included, then $0.01 per CU; CPU is billed only while actively working, RAM and disk on what you allocate while running. Small users can buy prepaid Usage Credits packs from $5 instead, so the table's Pro prices overstate very small workloads.
Tensorlake: bochka plans start at $20 a month and the whole fee becomes usage credit. Running time is billed per second by machine size, and a stopped sandbox costs nothing while its disk is kept.
Limits in those scenarios
On Modal, a sandbox lives at most 24 hours and its root disk is wiped when it ends, so the workday, always-on and fleet scenarios keep only files in a Volume, and the 50-agent fleet does not fit because Docker needs the VM runtime. Modal's 1,000-job burst runs on shared vCPUs that other tenants can slow down. Tensorlake Pro fits all five scenarios, but CPU, memory and disk are fixed when a sandbox is created, disk is 10 to 100 GiB, and an ephemeral sandbox ends after 10 idle minutes by default. bochka's limit that bites is start speed: even the $2,000 plan queues bursts above 90 starts a minute.
| Scenario | Modal | Tensorlake | 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 Modal when
your sandboxes need GPUs, must run in Asia-Pacific, or are huge bursts of short jobs next to models you already run on Modal.
- GPUs on the same platform. Useful if your agent trains or runs models: Modal rents GPUs from T4 to B300 right next to its sandboxes.
- Very large bursts and more regions. Modal runs up to 5,000 containers on Team and has regions in the US, EU and Asia-Pacific.
- One platform for all AI work. Teams already running inference or batch jobs on Modal can add sandboxes from the same Python, TypeScript or Go code.
Use Tensorlake when
your agents must suspend and resume with their memory, fan out warm clones from one state, or run inside your own cloud account.
- Suspend with memory, wake up warm. Useful when an agent must pick up mid-process: named sandboxes suspend with memory and running processes, with no session cap on Pro.
- Docker in a real kernel. Each Tensorlake sandbox is a Firecracker microVM, so Docker runs inside without picking a separate runtime.
- Warm clones and your own cloud. Tensorlake copies a running sandbox into many warm clones, and can run sandboxes in your own AWS, GCP or Azure account.
Where bochka fits
If your agents work for hours or days on installs, builds, tests and apps, look at bochka. Every bochka sandbox is a full VM on a fast dedicated host, with /dev/kvm, Docker, a desktop and coding agents built in, and it keeps its disk when it stops. Modal and Tensorlake stay ahead for GPUs, regions outside Europe and huge bursts of short jobs.
Emulators and VMs run inside
Tensorlake sandboxes have no /dev/kvm, and Modal offers it only on its VM runtime, on request, on Team and up. Without it an Android emulator or a nested VM does not start, so an agent testing a mobile app has nowhere to run it.
Agents built in, keys kept outside
On both Modal and Tensorlake you install the agent harness yourself, and real API keys sit inside the sandbox as environment variables or injected secrets, where one prompt injection can leak them. Modal's workaround is running your own proxy in a sidecar.
A fast machine that keeps working
Modal's default sandbox did 12.79 runs per second against bochka's 26.69, and ends within 24 hours, wiping files outside a Volume. Tensorlake reaches web apps only over HTTP, WebSocket and gRPC, so raw TCP services an agent starts can't be reached.
Use bochka when your agents work for hours: installs, builds, tests, Docker, emulators and a desktop, on a fast machine that keeps its disk, with coding agents built in and keys kept outside. Compare it one to one: bochka vs Modal and bochka vs Tensorlake.
Questions people ask
Is Modal cheaper than Tensorlake?
For small work, often yes: one coding agent on workdays is $15 a month on Modal against $250 on Tensorlake Pro, though Modal's files reset between days unless you use a Volume. For bigger work Tensorlake is cheaper: 50 agents in parallel cost $1,030 a month on Tensorlake against $2,229 on Modal, and sandboxes for your users cost $293 against $792. bochka prices those at $20, $317 and $200.
Which is faster, Modal or Tensorlake?
There is no comparable CPU measurement, because Tensorlake has no result on the hpc-sandbox-benchmarks run. In that run Modal's default sandbox finished 12.79 runs per second and bochka 26.69. Both Modal and Tensorlake are built for fast starts.
Can Modal and Tensorlake run Docker?
Tensorlake runs Docker inside its microVMs on the tensorlake/ubuntu-systemd image. Modal runs Docker only on its VM runtime, not in the default gVisor sandbox. Every bochka sandbox runs Docker with no extra setting.
How long can a sandbox run on Modal and Tensorlake?
A Modal sandbox runs 5 minutes by default and at most 24 hours. Tensorlake Pro has no session cap, but an idle sandbox is suspended or ended after 600 seconds by default. bochka has no session cap on paid plans.
Which has GPUs, Modal or Tensorlake?
Modal rents GPUs from T4 to B300 with published prices. Tensorlake offers GPU sandboxes by request, running on gVisor, with no published rate. bochka has no GPUs.
Is bochka SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.
Try bochka
Install the CLI, then run bochka new.
Product preview