Tensorlake vs Morph Cloud
Both can freeze a running sandbox with its memory and copy it into warm clones. Tensorlake runs microVMs built for big fan-outs, with GPUs, US and EU regions and your own cloud, while Morph Cloud runs full VMs with experimental nested virtualization that pause and wake on the next request.
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
Morph Cloud
Morph Cloud sells full virtual machines for AI agents that can be snapshotted, branched and restored with their memory, which it calls Infinibranch.
You get MorphVM instances as low-level building blocks and Devboxes as ready workspaces on top of them, with SSH, preview URLs and a tmux API for running coding agents you install yourself. Everything is billed in MCUs, where one MCU is 1 vCPU, 4 GB of RAM or 16 GB of disk for an hour. It is built for teams that fan agents out from one saved state, and it also sells managed GitHub Actions runners and a shared filesystem.
- 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 | Morph Cloud: 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 (rank 5) while Morph is a compromise here; bochka ranks 3 and adds nested virtualization and preinstalled coding agents. | 5th cheapest of 367 $1,010 a month | 198th of 367, with limits $2,288 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 9th cheapest of 366 $1,381 a month | 235th of 366, with limits $3,014 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 suit short code runs, and Morph ranks a little higher (16 vs 24) because a paused VM costs almost nothing and wakes on the next request. | 24th cheapest of 345 $250 a month | 16th cheapest of 345 $154 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 Both create a sandbox per user through an API; bochka ranks first and gives each one HTTPS on up to 50 ports and raw TCP. | 5th cheapest of 361 $471 a month | 12th cheapest of 361 $905 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 first for RL rollouts, since it is built to fan out about a thousand sandboxes at once from one warm state. | Cheapest of 360 $5,637 a month | 86th of 360, with limits $4,847 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 | 38th cheapest of 364 $675 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 Morph ranks a little higher for CI and also sells managed GitHub Actions runners; bochka ranks 4 on fast Ryzen 9 9950X hosts. | 54th cheapest of 377 $424 a month | 39th cheapest of 377 $355 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Morph fits a box that stays on all day better than Tensorlake, whose model is built around suspending idle sandboxes; bochka ranks 18. | 185th of 368, with limits $250 a month | 85th cheapest of 368 $116 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 with screenshot, mouse and keyboard calls, while on Morph you install the browser and agent yourself; bochka ships a 60fps desktop with Chromium. | 9th cheapest of 369 $294 a month | 182nd of 369, with limits $595 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 | 214th of 367, with limits $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 | 22nd cheapest of 346 $250 a month | 239th of 346, with limits $234 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 | 154th of 338, with limits $4,750 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 Tensorlake fits parallel red teaming (rank 4) far better than Morph; bochka ranks 2 and adds raw TCP inbound and /dev/kvm. | 4th cheapest of 360 $250 a month | 214th of 360, with limits $228 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 | Morph Cloud | bochka |
|---|---|---|---|
| Isolation | Firecracker and Cloud Hypervisor microVMs with their own kernel; GPU sandboxes use gVisor | Full VM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Nested virtualization | No: sandboxes set SANDBOX_KVM_AVAILABLE=0 | Experimental | Yes, /dev/kvm inside, so Android emulators and VMs run |
| Docker inside | Yes, on the tensorlake/ubuntu-systemd image | Yes, including Docker in Docker and local Kubernetes | Yes, with root and systemd |
| Pause with memory | Yes: named sandboxes suspend with memory and running processes and restore warm | Yes: resume brings back all processes and memory, and a paused VM bills only its snapshot | No: disk is kept, resume boots the machine again |
| Clone a running sandbox | Copy a running or suspended sandbox into N warm clones with memory | Branch a running VM with its memory into many copies in under 250 ms | Fork a running sandbox with its disk |
| Idle handling | Idle timeout, 600 s by default, then suspend or terminate | No built-in idle timer; you set a TTL to pause, and a paused VM wakes on the next HTTP request, SSH or exec call | Time-to-live (1 h by default, changeable or off); no idle timer |
| Desktop and computer use | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | Browser-based remote desktop; you install the browser and any computer use agent yourself | 60fps 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 | You install the agent, then drive it through a tmux API that sends keys and reads the screen | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| API keys | Stored secrets are injected into the sandbox | Responses Proxy for model APIs; other secrets are handed to the machine | Credentials proxy for model providers and any HTTPS API: real keys never enter the sandbox |
| Inbound traffic | HTTP, WebSocket and gRPC through an authenticated proxy on exposed ports | Named HTTP services with optional API key auth; SSH through Morph's gateway; no raw TCP | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP and a dedicated IP per machine |
| GPUs | GPU sandboxes by request (H100 shown in the docs) | None | None |
| Guest systems | Linux | Linux, with experimental Windows and macOS (x86) | Linux |
| Where it runs | US and EU, or your own cloud account through BYOC | Regions not published | EU only: Germany, Finland, France, with zero data retention |
| Managed CI runners | GitHub Actions runner pricing is not on the sandbox rate card | GitHub Actions runners in three sizes, billed from the same MCU balance | No; run your own runner inside a sandbox |
Every feature Battleships tracks (43)
| Feature | Tensorlake | Morph Cloud | 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 | Yes | 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 | Yes | No |
| Wake on request | Yes | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | No | No | No |
| GPU | Yes | No | No |
| Windows | No | Yes | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Yes | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Not published | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | Yes | Not published | No |
| EU data residency | Yes | Not published | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
Neither Tensorlake nor Morph Cloud is in the hpc-sandbox-benchmarks run, so there is no comparable CPU measurement between them. bochka scores 26.69 runs/s on that Node.js build-and-test loop at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. Tensorlake says its default image starts in a few hundred milliseconds and Morph says it restores a snapshot in under 250 ms, which measure 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. Tensorlake and Morph Cloud 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 | Morph Cloud, 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 | $32 · Developer | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Pro | $121 · Team | $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 | $1,459 · Scale | $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 | $325 · Scale | $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 | $869 · Scale | $2,000 · $2000/mo · with limits |
Tensorlake: Pro is $250 per billing cycle, which includes $250 of usage, then $0.01 per CU. CPU is billed only while it is actively working, RAM and disk on what you allocate while the sandbox runs, and smaller users can buy prepaid packs from $5 instead.
Morph Cloud: Morph bills MCUs at $0.05 an hour: the largest of a machine's vCPUs, its RAM in 4 GiB steps or its disk in 16 GiB steps. Team ($40 a month) and Scale ($250 a month) are prepaid MCU bundles at a discount, and a paused VM bills only its snapshot.
Limits in those scenarios
Tensorlake's $250 Pro minimum makes small workloads look expensive: one coding agent on workdays is $250 there and $32 on Morph, though Tensorlake's prepaid packs can cost less. Morph prices each machine by its largest resource, so our 50 GB disk is beyond its 16 GiB allowance and egress prices are not published, and its Developer pool of 64 vCPU holds only 16 machines at 4 vCPU. At 50 agents in parallel Tensorlake is $1,030 against Morph's $1,459, and both fit 1,000 short jobs at once, which bochka's start-rate limits queue.
| Scenario | Tensorlake | Morph Cloud | 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 about a thousand rollouts or evals from one warm state, or need GPUs, outbound rules, US regions or sandboxes in your own cloud account.
- Big fan-outs from one warm state. For RL rollouts and evals, Tensorlake Pro allows 1,000 sandboxes at once and copies one warm sandbox into many clones.
- 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.
- Outbound rules and published regions. Tensorlake can allow or deny outbound traffic by domain, IP or CIDR, and it runs in both the US and the EU.
Use Morph Cloud when
you want full VMs that branch with their memory and sleep until the next request, or need experimental nested virtualization, Windows or macOS guests.
- Full VMs that wake on request. Useful for agents that sleep between requests: a paused Morph VM keeps its memory, bills only its snapshot and wakes on the next call.
- Windows, macOS and nested virtualization. Morph is a full VM and lists experimental nested virtualization plus Windows and macOS (x86) guests, which Tensorlake does not offer.
- Managed CI runners and a shared filesystem. Morph also sells managed GitHub Actions runners and a filesystem many machines can mount at once.
Where bochka fits
Tensorlake and Morph Cloud both shine at freezing a machine with its memory and copying it, and bochka does not do that. If your agents instead work for hours on one machine, installing, building, running Docker and emulators, using a desktop or calling paid APIs, bochka gives them more out of the box. It is also the cheaper of the three in four of the five scenarios we price.
Emulators and VMs run inside
Tensorlake sandboxes have no /dev/kvm, so an Android emulator or a VM will not start, and Morph lists nested virtualization as experimental. bochka gives every sandbox /dev/kvm on a full VM.
Coding agents built in, keys kept outside
On both you install the agent yourself; Morph drives it by sending keystrokes to tmux. Tensorlake injects secrets into the sandbox, and Morph's proxy covers only model APIs, so other keys sit where a prompt injection can read them.
A desktop and ports you can reach
Morph has you build the browser and computer use loop yourself, and Tensorlake's desktop is Firefox over VNC. Neither carries raw TCP inbound. bochka streams a 60fps desktop with Chromium and serves HTTPS on 50 ports plus raw TCP.
Use bochka when your agents do long, real work on one machine: builds, Docker, emulators and a desktop, with coding agents built in and keys kept outside the machine. Compare it one to one: bochka vs Tensorlake and bochka vs Morph Cloud.
Questions people ask
Is Tensorlake cheaper than Morph Cloud?
It depends on scale. Morph is cheaper for one agent ($32 vs $250 on workdays, $121 vs $250 always on) and for 1,000 short jobs ($869 vs $1,127), while Tensorlake is cheaper for 50 agents in parallel ($1,030 vs $1,459) and sandboxes for your users ($293 vs $325). bochka is $20, $26, $317 and $200 in those scenarios but does not fit 1,000 short jobs at once.
Which is faster, Tensorlake or Morph Cloud?
Neither has a result on the hpc-sandbox-benchmarks CPU test, so there is no fair speed comparison. Both claim fast starts: a few hundred milliseconds for Tensorlake's default image and under 250 ms for a Morph snapshot restore. bochka scores 26.69 runs/s on that benchmark, the fastest result measured.
Can Tensorlake and Morph Cloud run Docker?
Yes. Tensorlake runs Docker on its tensorlake/ubuntu-systemd image, and Morph runs Docker in Docker and local Kubernetes. For nested virtualization, Tensorlake has none and Morph lists it as experimental, while bochka exposes /dev/kvm.
Do both keep a sandbox's memory?
Yes. Tensorlake suspends named sandboxes with their memory and copies them into warm clones, and Morph pauses and branches a running VM with its memory and wakes it on the next request. bochka keeps the disk but boots the machine again on resume.
Which one has computer use?
Tensorlake has an XFCE desktop with Firefox over VNC and screenshot, mouse and keyboard calls. Morph has browser-based remote access, but you install the browser and any computer use agent yourself. bochka ships a 60fps desktop with Chromium and a computer use API.
Which one has GPUs?
Tensorlake offers GPU sandboxes by request, running on gVisor. Morph Cloud and bochka have no GPUs.
Try bochka
Install the CLI, then run bochka new.
Product preview