Tensorlake vs smol machines
Both give each agent a microVM with its own kernel, and both can copy a running machine with its memory. Tensorlake is a managed platform with GPUs, a desktop, US and EU regions and a bring-your-own-cloud option, while smol machines is an open-source VM engine you can run on your laptop, on your own servers or in its hosted cloud.
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
smol machines
smol machines makes fast, isolated Linux microVMs that run the same way on your laptop, in their hosted cloud, or on your own servers.
The core is smolvm, an open-source microVM engine built on libkrun, where each machine has its own guest kernel. smol cloud is the paid hosted service that runs fleets of those machines behind a REST API and Node, Python and Rust SDKs. It is built for developers who want one VM model from local development to production, with live branching of running machines.
- Uptime SLA
- 99.95% on Pro, Startup and 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 | smol machines: 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 full software factory and smol machines is a compromise there; boat adds /dev/kvm for Android emulators and coding agents built in. | 5th cheapest of 367 $1,010 a month | 73rd of 367, with limits $604 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 | 148th of 366, with limits $1,038 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 smol machines fits short code runs well with a one-minute minimum and a /code endpoint, and Tensorlake fits too; boat's start-rate limits queue big bursts. | 24th cheapest of 345 $250 a month | 12th cheapest of 345 $140 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; boat ranks 1st here and also hands each sandbox HTTPS URLs, raw TCP and a credentials proxy. | 5th cheapest of 361 $471 a month | 7th cheapest of 361 $531 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 1st for RL rollouts, with warm clones and 1,000 sandboxes at once on Pro; smol machines can branch a running machine but is a compromise here. | Cheapest of 360 $5,637 a month | 111th of 360, with limits $6,978 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 | 36th cheapest of 364 $670 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 run fresh build machines; boat's Ryzen 9 9950X hosts are the fastest measured on the CPU benchmark, and neither Tensorlake nor smol machines has a result. | 54th cheapest of 377 $424 a month | 66th cheapest of 377 $514 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Neither is a natural box that stays on all day: Tensorlake is built around suspending idle sandboxes and smol cloud bills a base fee for every running hour. | 185th of 368, with limits $250 a month | 216th of 368, with limits $29 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, while smol cloud has no hosted desktop; boat streams a Linux desktop at 60fps with computer use. | 9th cheapest of 369 $294 a month | 90th of 369, with limits $156 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 Tensorlake ships a browser and desktop control, and smol machines documents how to run your own Chromium; boat ships Chromium ready for agents. | 13th cheapest of 367 $250 a month | 176th of 367, with limits $136 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 | 241st of 346, with limits $242 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 | 148th of 338, with limits $4,344 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 | 252nd of 360, with limits $377 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 | smol machines | boat |
|---|---|---|---|
| Isolation | Firecracker and Cloud Hypervisor microVMs with their own kernel; GPU sandboxes use gVisor | libkrun microVM with its own guest kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Biggest machine | 16 vCPU / 64 GB / 100 GB disk on Pro | 32 vCPU / 32 GB on Startup, 16 vCPU / 24 GB on Pro | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Nested virtualization | No: sandboxes set SANDBOX_KVM_AVAILABLE=0 | Not exposed in the cloud create API; a local smolvm flag only | Yes, /dev/kvm inside, so Android emulators and VMs run |
| Docker inside | Yes, on the tensorlake/ubuntu-systemd image | Yes, with Docker data on the machine's ext4 disk | Yes, with root and systemd |
| Clone with memory | Memory snapshots, and copy a running or suspended sandbox into N warm clones | Branch a running machine with its memory and processes; checkpoints capture RAM to a file | Fork a running sandbox with its disk; the fork boots fresh |
| Stop and keep state | Named sandboxes suspend with memory, billed as snapshot storage; ephemeral ones end on idle | Filesystem survives a stop, memory paths are emptied, and stopped disk keeps billing | Disk is saved every minute and on stop; a stopped sandbox costs nothing |
| Desktop and computer use | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | No hosted desktop; a guide shows running your own Chromium inside a machine | 60fps Linux desktop with Chromium, computer use and an embeddable stream |
| Coding agents | You bring and run your own agent; managed images are plain OS bases | Registry images with the Codex CLI and the Harbor eval harness, run through the command API | Seven agents preinstalled, including Claude Code and Codex, with a prompt, steer and events API |
| API keys | Stored secrets are injected into the sandbox | Cloud secrets are environment variables the guest can read | Credentials proxy for model providers and any HTTPS API; real keys never enter the sandbox |
| Shell access | SSH and a command API | Command API and a WebSocket terminal capped at one hour per connection; no SSH | SSH, plus a command API and terminal |
| Inbound traffic | HTTP, WebSocket and gRPC through an authenticated proxy on exposed ports | Up to 16 published ports through a returned URL or an authenticated connect route | HTTPS URLs for up to 50 ports, raw TCP and a dedicated IP per machine |
| Outbound rules | allow_out and deny_out lists by domain, IP or CIDR, or no internet | Blocked, open, or an allowlist of hosts and CIDR ranges | No provider-side allowlist; you set your own firewall as root |
| GPUs | GPU sandboxes by request (H100 shown in the docs) | None on the hosted cloud; self-hosted smolvm can remote GPU work through Vulkan and CUDA | None |
| Where it runs | US and EU, or your own AWS, GCP, Azure, CoreWeave, Nebius or bare-metal account | Hosted cloud with no region choice, or open-source smolvm on your laptop or servers | EU only: Germany, Finland, France, with EU data residency |
Every feature Battleships tracks (43)
| Feature | Tensorlake | smol machines | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | No | 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 | 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 | Not published | 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 | 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 | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | No | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | 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 | No | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
There is no comparable CPU measurement between Tensorlake and smol machines: neither has been run on the StarSling hpc-sandbox-benchmarks CPU test. boat did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB, the fastest result measured. On start time, Tensorlake says its default image starts in a few hundred milliseconds and smol machines publishes a boot under 200ms for smolvm.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Tensorlake and smol machines 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 | smol machines, 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 | $25 · Standard | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Pro | $93 · Standard | $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,139 · 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 | $293 · Pro | $465 · Startup | $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,389 · Startup | $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 active, RAM and disk on what you allocate while running, and small users can buy prepaid packs from $5 instead.
smol machines: smol cloud charges $0.04 for every hour a machine runs, plus $0.05 per active vCPU-hour and $0.0162 per active GB-hour of memory, with a one-minute minimum and disk billed even while stopped. Pro ($20 a month) and Startup ($150 a month) are fees on top of usage, not credit.
smol machines: Plans start at $20 a month, and the whole fee is usage credit. Running time is billed per second, and a stopped sandbox costs nothing while its disk is kept.
Limits in those scenarios
smol machines caps how many machines you hold at once by plan: 20 on Standard, 100 on Pro and 1,000 on Startup, and stopped machines still take a slot, so 50 agents needs Pro and 1,000 short jobs needs Startup. Tensorlake's Pro plan allows 1,000 sandboxes at once, but its prepaid packs cap each sandbox at 4 vCPU / 16 GB and 24-hour sessions, and an ephemeral sandbox ends after 10 idle minutes by default. boat's limit that bites is starts: even the $2,000 plan queues bursts above 90 starts a minute, so 1,000 short jobs at once does not fit.
| Scenario | Tensorlake | smol machines | boat |
|---|---|---|---|
| One coding agent, workdays | None that bite | None that bite | None that bite |
| One agent that never stops | None that bite | 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 | None that bite |
| 1,000 short jobs at once | None that bite | None that bite |
|
Which one should you use?
Use Tensorlake when
you fan out large batches of rollouts from one warm state, need GPUs or a ready desktop, or must run sandboxes in the US or your own cloud account.
- GPUs and your own cloud. For teams that need GPU sandboxes by request, or sandboxes inside their own AWS, GCP, Azure, CoreWeave or Nebius account.
- A desktop out of the box. For computer-use agents: Tensorlake ships an XFCE desktop with Firefox and screenshot, mouse and keyboard calls.
- Big fan-outs on one plan. For RL and evals: Pro runs 1,000 sandboxes at once and copies one warm sandbox into many clones.
Use smol machines when
you want one open-source VM engine from your laptop to your own servers, or light agents that pay only for the CPU and memory they use.
- Open source, laptop to servers. For teams that want one open-source VM engine that runs the same on a laptop, in a hosted cloud and on their own servers.
- Pay for what the guest uses. For agents that sit idle a lot: smol cloud bills the CPU and memory a guest actually uses, with a one-minute minimum.
- Wake on the next command. For per-user sandboxes: a stopped machine starts again on the next command, and arm64 images are available too.
Where boat fits
Tensorlake and smol machines are both built around fast, short-lived microVMs that you clone and throw away. If your agents instead do hours of real work, like installs, builds, Docker, emulators and a desktop, boat gives each one a full VM with coding agents built in and keys kept outside. For 1,000 short jobs at once, both of them fit and boat does not.
Run emulators and VMs inside
Neither Tensorlake nor smol cloud exposes /dev/kvm, so an Android emulator or a VM an agent needs simply does not start. boat sandboxes have /dev/kvm, so those tests run inside.
Keep API keys out of the sandbox
Tensorlake injects secrets into the sandbox and smol cloud passes them as plaintext env vars, so one prompt injection can leak them. smol's key swapping only works if you self-host smolvm on your own servers.
Reach it like a server
Tensorlake's proxy carries only HTTP, WebSocket and gRPC, and smol cloud has no SSH, 16 ports and an hour-long terminal. boat gives HTTPS on 50 ports, raw TCP, SSH and a dedicated IP.
Use boat when your agents do real work for hours: Docker, emulators, SSH, a desktop and a browser, with coding agents you drive from outside and keys that never enter the sandbox. Compare it one to one: boat vs Tensorlake and boat vs smol machines.
Questions people ask
Is Tensorlake cheaper than smol machines?
For one agent, no: one coding agent on workdays is $250 a month on Tensorlake Pro and $25 on smol machines, because Pro has a $250 minimum. At scale Tensorlake comes out ahead: 50 agents in parallel is $1,030 against $1,139, and 1,000 short jobs at once is $1,127 against $1,389. boat is $20 and $317 for the first two, but does not fit the burst.
Which is faster, Tensorlake or smol machines?
Neither has a result on the CPU benchmark we use, so there is no fair speed comparison. Both start quickly: Tensorlake says a few hundred milliseconds, and smol machines says under 200ms for smolvm. boat scores 26.69 runs per second on that benchmark.
Can Tensorlake and smol machines run Docker?
Yes, both run Docker inside the VM: Tensorlake on its ubuntu-systemd image, and smol machines with Docker data on the machine's ext4 disk. Neither exposes nested virtualization on hosted machines, so Android emulators do not run. boat runs Docker with systemd and exposes /dev/kvm.
Can I self-host Tensorlake or smol machines?
smol machines' engine, smolvm, is open source and runs on macOS, Linux and Windows hosts. Tensorlake is not open source, but its BYOC option runs sandboxes in your own AWS, GCP, Azure, CoreWeave, Nebius or bare-metal account. boat is a hosted service only.
Which one has GPUs?
Tensorlake offers GPU sandboxes by request, running on gVisor. smol cloud has no GPUs, though self-hosted smolvm can remote GPU work through Vulkan and CUDA. boat has no GPUs.
Can both clone a running sandbox with its memory?
Yes. Tensorlake copies a running or suspended sandbox into warm clones, and smol machines branches a running machine with its memory and processes. boat forks a running sandbox with its disk, and the fork boots fresh.
Try boat
Install the CLI, then run boat new.
7-day free trial