Tensorlake vs exe.dev
Tensorlake gives each agent a short-lived microVM you create through an API, which can save its memory and copy itself into warm clones. exe.dev gives you persistent Linux VMs you reach over SSH and HTTPS, sharing a pool you reserve each month.
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
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
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 | exe.dev: price rank | boat: 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 Docker and memory snapshots; exe.dev has no desktop or snapshots, and boat adds nested virtualization and preinstalled agents. | 5th cheapest of 367 $1,010 a month | 253rd of 367, with limits $3,701 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB All three keep an agent's files between sessions; Tensorlake also keeps its memory while it sleeps, and exe.dev and boat can keep it running with no time limit. | 9th cheapest of 366 $1,381 a month | 15th cheapest of 366 $3,833 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 many short runs well; exe.dev pools bill whether VMs are busy or not, and boat's start-rate limits queue big bursts. | 24th cheapest of 345 $250 a month | 235th of 345, with limits $175 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 and boat both create a sandbox per user through an API at high concurrency; exe.dev's Personal plan stops at 50 VMs at once. | 5th cheapest of 361 $471 a month | 257th of 361, with limits $1,226 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 on Pro and warm clones, while exe.dev's Personal plan stops at 50 VMs at once. | Cheapest of 360 $5,637 a month | 265th of 360, with limits $5,250 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 | 283rd of 364, with limits $1,050 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 Tensorlake bills CPU only while it works and exe.dev pools bill whether jobs run or not; boat's Ryzen 9 9950X hosts are the fastest measured on the CPU benchmark. | 54th cheapest of 377 $424 a month | 288th of 377, with limits $504 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB exe.dev suits a box that stays on all day, while Tensorlake is built around suspending idle sandboxes; boat also keeps a box on with no session cap. | 185th of 368, with limits $250 a month | 25th cheapest of 368 $35 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 over VNC and boat streams a 60fps desktop, while exe.dev VMs are headless. | 9th cheapest of 369 $294 a month | 240th of 369, with limits $1,055 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 | 130th of 367, with limits $530 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 | 124th of 346, with limits $278 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 | 166th of 338, with limits $5,490 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 | 60th of 360, with limits $263 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 | exe.dev | boat |
|---|---|---|---|
| Isolation | Firecracker and Cloud Hypervisor microVMs with their own kernel; GPU sandboxes use gVisor | KVM VM with Cloud Hypervisor on rented servers; you can't choose the kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Memory snapshots | Yes: suspend keeps memory and running processes and restores warm | No snapshots; the disk persists on a second server | No memory snapshots; disk snapshots every minute and on stop |
| Clone a sandbox | Copy a running or suspended sandbox into N warm clones with memory | cp copies a VM's disk and config into a new VM | Fork a running sandbox (disk); named snapshots as templates |
| Docker inside | Yes, on the tensorlake/ubuntu-systemd image | Yes, with root and systemd | Yes, with root and systemd |
| Nested virtualization | No: sandboxes set SANDBOX_KVM_AVAILABLE=0 | Enterprise only | Yes, /dev/kvm on every plan, so Android emulators and VMs run |
| Desktop and computer use | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | Headless; no desktop or screen streaming | 60fps desktop and Chromium, computer use, browser control, embeddable stream |
| Built-in agents | You bring your own agent; managed images are plain OS bases | Claude Code, Codex, Pi and Shelley; only Shelley takes prompts through the API | Claude Code, Codex, OpenCode and more, with a prompt, steer and events API |
| API keys | Stored secrets are injected into the sandbox | Integrations inject secrets at the network edge for any HTTP host | 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 | HTTPS proxy for ports 3000 to 9999 and SSH; no public IP or raw TCP | HTTPS URLs for up to 50 ports, raw TCP and a dedicated IP per machine |
| Idle and session length | Idle timeout of 600 s by default, then suspend or end; no cap on Pro | No cap; VMs run until you stop them | No cap on paid plans; you set the time-to-live |
| Outbound rules | Allow and deny lists by domain, IP or CIDR, or no internet | No provider-side allowlist | No provider-side allowlist; you set your own firewall as root |
| Custom images | Custom images supported | Boot from your own Docker image | Templates from named snapshots; no Dockerfile or OCI images |
| GPUs | GPU sandboxes by request | None | None |
| Regions | US and EU, or your own cloud through BYOC | 9 regions in the US, Europe, Asia and Australia | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Tensorlake | exe.dev | boat |
|---|---|---|---|
| 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 | Yes | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | Yes | No | 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 | No | 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 | Yes | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | Yes | 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 | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
boat scores 26.69 runs/s on the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, the fastest result measured. Neither Tensorlake nor exe.dev is in that benchmark run, so there is no comparable CPU measurement between the three. Tensorlake's docs say its default image starts in a few hundred milliseconds, and exe.dev says a new VM boots in about two seconds.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Tensorlake and exe.dev 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 | exe.dev, a month | boat, 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 | $35 · Personal | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Pro | $35 · Personal | $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,848 · Personal | $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 | $530 · Personal · 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,050 · Personal · with limits | $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 running, and a suspended sandbox pays snapshot storage.
exe.dev: You reserve a pool that your VMs share, billed the same whether they are busy or idle: Personal runs from $15 to $155 a month by size. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour.
exe.dev: You pick a monthly plan from $20, 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
exe.dev Personal allows 50 VMs at once, so the 300-at-once and 1,000-at-once scenarios don't fit there. Tensorlake Pro allows 1,000 sandboxes at once and fits both, but an ephemeral sandbox ends after 10 idle minutes by default and only named sandboxes can suspend. boat goes from 100 to 2,000 at once by plan, but its start-rate limits queue bursts above 90 starts a minute, so 1,000 short jobs at once does not fit.
| Scenario | Tensorlake | exe.dev | boat |
|---|---|---|---|
| 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 | 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 of short rollouts or evals from one warm state, or need GPUs, outbound rules or sandboxes in your own cloud account.
- 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.
- Big fan-outs. For RL rollouts and evals, Tensorlake Pro runs 1,000 sandboxes at once, where exe.dev Personal stops at 50 VMs.
- GPUs and outbound rules. Tensorlake offers GPU sandboxes by request and can allow or deny outbound traffic by domain, IP or CIDR.
Use exe.dev when
you want a persistent Linux box you SSH into, close to users outside Europe, booted from your own Docker image.
- A box that stays on. For a persistent dev box, exe.dev VMs run until you stop them, reached over SSH, with a disk that lasts.
- Regions around the world. Useful if your users are far from Europe: exe.dev runs in nine regions across the US, Europe, Asia and Australia.
- Docker images and team controls. exe.dev boots VMs from your own Docker image, and its Work plan covers a whole team with SSO and roles.
Where boat fits
Tensorlake is strongest for short fan-outs from one warm state, and exe.dev for a persistent box you SSH into. If your agents do long, real work like builds, Docker, emulators and checking UIs in a browser, boat gives each one a full VM with a desktop, built-in agents and state saved every minute.
Run emulators and VMs inside
Tensorlake sandboxes have no /dev/kvm, and exe.dev offers nested virtualization only on Enterprise, so an Android emulator or a VM an agent needs will not start. boat exposes /dev/kvm on every plan.
A screen and agents you can drive
exe.dev VMs are headless, and Tensorlake ships a VNC desktop but no agents, so you install and wire up the harness yourself. boat streams a 60fps desktop and lets you drive agents inside from outside with one API.
Reach it like a server
Tensorlake's proxy carries only HTTP, WebSocket and gRPC, and exe.dev has no public IP or raw TCP, so a database an agent starts can't be reached. boat gives HTTPS URLs on 50 ports, raw TCP and its own IP.
Use boat when your agents do real work for hours: builds, tests, Docker, emulators, a desktop and a browser, with coding agents built in and state saved every minute. Compare it one to one: boat vs Tensorlake and boat vs exe.dev.
Questions people ask
Is Tensorlake cheaper than exe.dev?
It depends on the shape of the work. One coding agent on workdays is $35 a month on exe.dev and $250 on Tensorlake Pro, but 50 agents in parallel is $1,030 on Tensorlake against $1,848 on exe.dev. boat is $20 and $317 for those two.
Which is faster?
Neither Tensorlake nor exe.dev has a result on the hpc-sandbox-benchmarks CPU test, so we can't compare their speed. boat scores 26.69 runs/s on it, the fastest measured.
Can Tensorlake and exe.dev run Docker?
Yes. Tensorlake runs Docker on its tensorlake/ubuntu-systemd image, and exe.dev VMs come with root, systemd and Docker. boat also runs Docker with root and systemd.
Does either have a desktop for computer use?
Tensorlake has an XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls. exe.dev VMs are headless. boat streams a 60fps desktop with Chromium and APIs for computer use and browser control.
Can I keep a sandbox's memory when it stops?
On Tensorlake, yes: named sandboxes suspend with memory and running processes. exe.dev has no snapshots, only a disk that lasts. boat keeps the disk with snapshots every minute, but a resume boots the machine again.
Where do they run?
Tensorlake runs in the US and the EU, or in your own cloud through BYOC. exe.dev has nine regions in the US, Europe, Asia and Australia. boat runs only in the EU, in Germany, Finland and France.
Try boat
Install the CLI, then run boat new.
7-day free trial