Tensorlake vs Fly.io Machines
Both run your code in Firecracker microVMs, but they are built for different jobs. Tensorlake is an agent sandbox with memory snapshots, warm clones and a desktop, while Fly.io Machines are the building block of an app host that runs your own image in 17 regions.
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
Fly.io Machines
Fly.io is an app hosting platform, and Machines are the microVMs underneath it that you can also start and stop through a REST API.
A Fly Machine boots your Docker image as a Firecracker microVM on Fly's own servers, in one of 17 regions. You pick a shared or performance CPU preset, attach at most one Volume for data that must last, and Fly Proxy can stop, suspend and wake Machines as traffic comes and goes. It is built for teams that host web apps and services worldwide; it is not a sandbox product, so this page compares the parts that overlap with agent work.
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 | Fly.io Machines: 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 software factory fully, while Fly Machines are a compromise because the root disk resets on restart and shared vCPUs throttle long builds; bochka adds /dev/kvm and built-in coding agents. | 5th cheapest of 367 $1,010 a month | 92nd of 367, with limits $836 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Tensorlake keeps an agent's memory while it sleeps, a Fly Machine keeps only what sits on its one Volume, and bochka keeps the whole disk with no session cap. | 9th cheapest of 366 $1,381 a month | 125th of 366, with limits $816 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 Fly's per-second billing with no plan fee is cheap for short runs, Tensorlake fits them fully, and bochka's start-rate limits make big bursts a compromise. | 24th cheapest of 345 $250 a month | 75th of 345, with limits $94 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 | 5th cheapest of 361 $471 a month | 69th of 361, with limits $600 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 rollouts a thousand at a time from one warm state, while Fly's API starts about one Machine per second per app. | Cheapest of 360 $5,637 a month | 48th of 360, with limits $2,838 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 | 117th of 364, with limits $457 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 keeps the CPU busy, which drains a shared Fly vCPU's burst balance; Tensorlake bills active CPU, and bochka's Ryzen 9 9950X hosts are the fastest measured. | 54th cheapest of 377 $424 a month | 152nd of 377, with limits $288 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both are a compromise for a box that stays on all day: Tensorlake suspends idle sandboxes and Fly loses files outside its Volume, while bochka fits fully. | 185th of 368, with limits $250 a month | 118th of 368, with limits $53 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 Firefox and computer-use calls, Fly has no desktop built in, and bochka has a 60fps desktop with Chromium. | 9th cheapest of 369 $294 a month | 95th of 369, with limits $173 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 | 160th of 367, with limits $90 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 | 161st of 346, with limits $67 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 Fly ranks highest of the three here, since it can spread scrapers across 17 regions and pay only for the seconds they run. | 121st of 338, with limits $3,484 a month | 44th of 338, with limits $1,232 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 | 118th of 360, with limits $63 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 | Fly.io Machines | bochka |
|---|---|---|---|
| Kind of product | Agent sandbox: microVMs created through an API | App hosting platform; you boot your own image as a microVM | Agent sandbox: a full VM per agent, ready to use |
| Isolation | Firecracker and Cloud Hypervisor microVMs; GPU sandboxes use gVisor | Firecracker microVM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker and systemd | Docker and systemd on the tensorlake/ubuntu-systemd image | Docker you install yourself; Fly's own init, no systemd | Docker, root and systemd on every machine |
| Nested virtualization | No: sandboxes set SANDBOX_KVM_AVAILABLE=0 | No: /dev/kvm is not offered | Yes, /dev/kvm inside, so Android emulators and VMs run |
| Memory snapshots | Suspend and memory snapshots keep running processes and restore warm | Suspend keeps memory for Machines up to 2GB; dropped on deploy or host move | No: disk is kept, resume reboots the machine |
| Clone or fork | Copy a running or suspended sandbox into N warm clones with memory | Clone copies a Machine's config; a cloned Volume starts empty | Fork a running sandbox, disk included |
| Files after a stop | Named sandboxes suspend, billed as snapshot storage; ephemeral ones end on idle | Root file system is ephemeral; lasting data goes on one Volume billed around the clock | Whole disk kept, snapshots 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 | None built in; you add a desktop and browser to your own image | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Coding agents | You bring and run your own agent | None built in; you install and run agents yourself | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| API keys | Stored secrets are injected into the sandbox | Secrets arrive as environment variables; open-source tokenizer proxy you run yourself | AI 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; no raw TCP | HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, private network | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP and a dedicated IP |
| Outbound rules | Allow and deny lists by domain, IP or CIDR, or no internet at all | Network policies allow chosen ports and protocols and deny the rest | No provider-side allowlist; you set your own firewall as root |
| CPU | CPU billed only while actively working | Shared vCPUs guarantee 6.25% of a core plus bursts; performance vCPUs cost more | One CPU class, no baseline quota or burst balance; 26.69 runs/s measured |
| Where it runs | US and EU, or your own cloud account through BYOC; GPU sandboxes by request | 17 regions on six continents; GPU Machines discontinued | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Tensorlake | Fly.io Machines | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | No | 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 | Yes | Yes |
| Automatic snapshots | Yes | Yes | 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 | Yes | No |
| Wake on request | Yes | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Yes | Yes |
| Public IPv4 | No | Yes | 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 | Yes | 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 | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | No | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
bochka 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 Fly.io Machines has a result on this benchmark, so there is no comparable CPU measurement between the three. On Fly, results would also depend on whether you pick shared vCPUs, which guarantee 6.25% of a core, or performance vCPUs.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Tensorlake and Fly.io 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 | Fly.io Machines, 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 · Pay As You Go · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Pro | $36 · Pay As You Go · 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 | $487 · Pay As You Go · 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 | $110 · Pay As You Go · 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 | $232 · Pay As You Go · with limits | $2,000 · $2000/mo · with limits |
Tensorlake: 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 suspended sandboxes pay snapshot storage.
Fly.io Machines: Fly bills each Machine per second while it runs, with no plan fee; stopped Machines pay for their root file system and Volumes are billed for their full size all month. The figures use Fly's lowest rate: shared vCPUs on a 1-year reservation.
Fly.io Machines: You pick a monthly plan from $20, and the whole fee becomes usage credit spent per second. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Fly is marked a compromise in every scenario, because its lowest figures need a 1-year reservation and shared vCPUs that guarantee only 6.25% of each core, so long builds get throttled. Fly's API also starts about one Machine per second per app, so 1,000 jobs at once need pre-created Machines or several apps. Tensorlake Pro fits all five scenarios, with 1,000 sandboxes at once, but its $250 Pro fee is the floor even for one agent. bochka queues bursts above 90 starts a minute, so 1,000 short jobs at once does not fit even on the $2,000 plan.
| Scenario | Tensorlake | Fly.io Machines | 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 many short rollouts or evals from one warm state, need memory snapshots, GPUs or sandboxes in your own cloud account.
- Memory snapshots and warm clones. Useful when agents must pick up mid-process: Tensorlake saves a sandbox's memory and copies it into many warm clones.
- Built for fan-out. For RL rollouts and evals, Tensorlake Pro allows 1,000 sandboxes at once, created through one API.
- GPUs and your own cloud. Tensorlake offers GPU sandboxes by request and can run sandboxes in your own AWS, GCP, Azure, CoreWeave or Nebius account.
Use Fly.io Machines when
you host web apps or light services that must run near users worldwide, sleep between requests and wake on traffic.
- 17 regions worldwide. Useful when work must sit near users outside Europe and the US: Fly runs Machines in 17 regions on six continents.
- Wake on request. For services that sleep between requests, Fly Proxy stops idle Machines and wakes them when traffic arrives.
- A full app platform. If you host whole apps, Fly adds raw TCP, Anycast IPs, custom domains and private networking around each Machine.
Where bochka fits
If your agents do long, real work like installs, builds, tests and Docker, both Tensorlake and Fly leave gaps. bochka gives each agent a full VM with /dev/kvm, a disk that survives every stop, a desktop, coding agents and a keys proxy, all on the fastest CPU measured.
Emulators and VMs run inside
Neither Tensorlake nor Fly offers /dev/kvm, so an Android emulator or a nested VM does not start at all. On bochka every machine has /dev/kvm, so an agent that tests a mobile app can run it.
The whole disk stays, and stops are free
On Fly anything outside the one Volume can be lost on restart, and Tensorlake's ephemeral sandboxes end after 10 idle minutes. bochka keeps the whole disk with snapshots every minute, and a stopped machine costs nothing.
Agents and keys come ready
On both, you install the agent harness yourself and secrets end up inside the sandbox, where code the agent writes can read them. bochka preinstalls Claude Code and Codex and keeps real keys in a proxy outside the machine.
Use bochka when your agents do real work for hours: installs, builds, tests, Docker and emulators on a full VM whose disk survives every stop, with a desktop, coding agents and a keys proxy built in. Compare it one to one: bochka vs Tensorlake and bochka vs Fly.io Machines.
Questions people ask
Is Tensorlake cheaper than Fly.io Machines?
Not in the scenarios we price. One coding agent on workdays is $250 a month on Tensorlake Pro and $15 on Fly, and 50 agents in parallel is $1,030 against $487. Fly's figures assume a 1-year reservation and work that stays within a shared vCPU's 6.25% baseline; bochka is $20 and $317 for the same two.
Which is faster, Tensorlake or Fly.io Machines?
There is no comparable CPU measurement for either one. Both boot microVMs quickly, and Tensorlake's docs say its default image starts in a few hundred milliseconds. bochka scores 26.69 runs/s on the hpc-sandbox-benchmarks Node.js loop, the fastest result measured.
Can Tensorlake and Fly.io Machines run Docker?
Yes. Tensorlake runs Docker on its tensorlake/ubuntu-systemd image, and on a Fly Machine you install Docker yourself as root. Neither offers /dev/kvm, so nested VMs and Android emulators do not run; bochka has Docker, systemd and /dev/kvm on every machine.
Do they keep my files when a sandbox stops?
Tensorlake's named sandboxes suspend with memory and files, while ephemeral ones end on idle. A Fly Machine keeps only what is on its one Volume, since its root file system is ephemeral. bochka keeps the whole disk, with snapshots every minute and on stop.
Which one has GPUs?
Tensorlake offers GPU sandboxes by request, running on gVisor. Fly discontinued GPU Machines from August 2026, and bochka has no GPUs.
Where do Tensorlake, Fly.io and bochka run?
Tensorlake runs in the US and the EU, or in your own cloud account through BYOC. Fly runs Machines in 17 regions worldwide. bochka runs only in the EU (Germany, Finland, France), with EU data residency.
Try bochka
Install the CLI, then run bochka new.
Product preview