Blaxel vs Tensorlake
Both run each sandbox as a Firecracker microVM that can save its memory and wake up warm. Blaxel is built to sleep seconds after the last connection and wake in under 25 ms, while Tensorlake is built to run up to 1,000 sandboxes at once and copy one warm state into many clones.
The companies and products
Blaxel
Blaxel is a San Francisco company that runs cloud infrastructure for AI agents, and since September 2026 it is part of Baseten.
You get sandboxes, batch jobs, MCP server hosting and a model gateway. Each sandbox is a Firecracker microVM with its own kernel that drops to standby when nothing is connected and resumes in under 25 ms with its memory and running processes. It is built for agent products that start many sandboxes and want them asleep most of the time.
- Headquarters
- San Francisco, founded 2024
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. “10th cheapest of 367” means 9 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 | Blaxel: price rank | Tensorlake: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both fit a software factory, and boat adds /dev/kvm for Android emulators, a faster CPU and coding agents built in. | 10th cheapest of 367 $2,373 a month | 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 | 12th cheapest of 366 $2,832 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 Blaxel fits short code runs best of the three, since it sleeps right after a run and wakes in milliseconds, and boat's start-rate limits make this a compromise. | 14th cheapest of 345 $144 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 Tensorlake's Pro plan fits 300 users at once while Blaxel's self-serve tiers stop at 200, and boat ranks 1st here with HTTPS URLs and raw TCP per sandbox. | 101st of 361, with limits $926 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 Tensorlake ranks 1st for RL rollouts, with 1,000 at once and warm clones, while Blaxel and boat are compromises because of concurrency and start-rate limits. | 77th of 360, with limits $4,378 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 Tensorlake fits many evals at once on Pro, Blaxel caps self-serve at 200 at once, and boat starts a fresh VM per task from a named snapshot. | 136th of 364, with limits $704 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 | 57th cheapest of 377 $431 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 Neither is built for a box that stays on all day, and boat fits it better as a plain machine with SSH and a disk that stays. | 265th of 368, with limits $114 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 Both run a desktop with a browser, and boat adds a 60fps desktop stream you can embed in your app. | 14th cheapest of 369 $634 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 | 16th cheapest of 367 $317 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 | 16th cheapest of 346 $215 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 | 147th of 338, with limits $4,292 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 All three fit: Blaxel and Tensorlake add provider-side outbound rules, and boat gives root with raw TCP inbound. | 3rd cheapest of 360 $217 a month | 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 | 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 | Blaxel | Tensorlake | boat |
|---|---|---|---|
| Isolation | Firecracker microVM, own kernel | Firecracker and Cloud Hypervisor microVMs, own kernel; GPU sandboxes use gVisor | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Sleep and wake | Standby a few seconds after the last connection, wakes in under 25 ms with memory and processes | Idle timeout (600 s by default), then named sandboxes suspend with memory; ephemeral ones end | Stop keeps the disk and costs nothing; resume boots the VM again |
| Clone a running sandbox | Fork with memory and running processes (private preview) | Copy a running or suspended sandbox into N warm clones with memory | Fork a running sandbox (disk) |
| Sandboxes at once (self-serve) | 10, 50 or 200 by tier, and standby sandboxes count | 1,000 on Pro | 100 to 2,000 by plan, with a limit on starts per minute |
| Disk | Files live in memory (about half the RAM); one volume can be attached at creation | Root disk of 10 to 100 GiB, fixed at creation | A real disk that stays, snapshotted every minute and on stop |
| Nested virtualization | No: Firecracker guests do not get /dev/kvm | No: sandboxes set SANDBOX_KVM_AVAILABLE=0 | Yes: /dev/kvm, so Android emulators and VMs run inside |
| SSH and systemd | Root, terminal through bl connect, no native SSH or systemd | Root, systemd on the tensorlake/ubuntu-systemd image | Real SSH, root and systemd |
| Docker inside | Yes, with a Docker-in-sandbox image | Yes, on the tensorlake/ubuntu-systemd image | Yes |
| Inbound traffic | Preview URL per port, public or token-protected; no raw TCP | HTTP, WebSocket and gRPC through an authenticated proxy; no raw TCP | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP and its own IP |
| Outbound rules | Domain allow and deny lists, method and path rules, static egress IPs | allow_out and deny_out by domain, IP or CIDR, or no internet | Open internet; filter inside the VM with nftables |
| API keys | Proxy fills secrets into outbound HTTPS requests (public preview) | Stored secrets are injected into the sandbox | Credential proxy: real keys never enter the sandbox, for model providers and any HTTPS API |
| Built-in agents | Claude Code image you drive from its terminal or your own harness | You bring your own agent; images are plain OS bases | Claude Code, Codex, OpenCode and more, driven by a prompt, steer and events API |
| GPUs and own cloud | No GPUs; bring-your-own-metal on a custom quote | GPU sandboxes by request; BYOC on AWS, GCP, Azure, CoreWeave, Nebius and bare metal | No GPUs, no bring-your-own-cloud |
| Regions | Oregon, North Virginia, London, Frankfurt | US and EU | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Blaxel | Tensorlake | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | Yes | Yes |
| Desktop GUI | Yes | Yes | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | No | 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 | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | No | No |
| GPU | No | Yes | 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 | Yes | Not published | Yes |
| Spend limits | No | Not published | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Not published | 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 | Yes | Yes | Yes |
Performance
On the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU and 8 GB, run on September 29, 2026, boat did 26.69 runs per second and Blaxel 19.48, so boat did about 1.4 times the work in the same time. Tensorlake has no published result on this benchmark, so there is no comparable CPU measurement for it.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Blaxel measured on: Sandbox (active time, RAM-only pricing, CPU bundled). 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 | Blaxel, a month | Tensorlake, 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 | $33 · Pay-as-you-go Tier 1 | $250 · Pro | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $120 · Pay-as-you-go Tier 1 | $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 | $1,489 · Pay-as-you-go Tier 1 | $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 | $396 · Pay-as-you-go Tier 2 · with limits | $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 | $876 · Pay-as-you-go Tier 2 · with limits | $1,127 · Pro | $2,000 · $2000/mo · with limits |
Blaxel: Blaxel charges for allocated RAM per second while a sandbox has an open connection, with CPU included. In standby you pay only snapshot storage, and tiers unlock by how much you top up in 30 days.
Tensorlake: Tensorlake Pro is $250 per cycle, which includes $250 of usage, then pay per use. CPU is billed while active, RAM and disk on allocation; small users can buy prepaid packs from $5 instead.
Tensorlake: Your plan payment (from $20 a month) is all usage credit, billed per second while a machine runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Blaxel's self-serve tiers stop at 200 sandboxes at once, and standby ones count, so the 300-user and 1,000-job scenarios need a sales tier. Tensorlake Pro fits both with 1,000 at once, but sizes are fixed at creation and an ephemeral sandbox ends after 10 idle minutes by default. boat fits 300 users at once but queues bursts above 90 starts a minute, so 1,000 jobs at the same moment does not fit either.
| Scenario | Blaxel | Tensorlake | 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 |
| 1,000 short jobs at once |
| None that bite |
|
Which one should you use?
Use Blaxel when
your sandboxes sit idle most of the time and must wake in milliseconds, you want no monthly minimum, or you need fine outbound rules and static egress IPs.
- Wakes in milliseconds. For sandboxes that sit idle most of the time: Blaxel sleeps seconds after the last connection and wakes in under 25 ms.
- No monthly minimum. For small or spiky workloads: Blaxel bills allocated RAM only while a sandbox is active, with CPU included and no plan fee.
- Finer outbound rules. For teams that lock down egress: Blaxel filters by domain, method and path, and can give a sandbox static egress IPs.
Use Tensorlake when
you fan out hundreds or a thousand sandboxes at once from one warm state, or need GPUs or sandboxes in your own cloud account.
- A thousand at once. For RL rollouts and big eval runs: Tensorlake Pro allows 1,000 sandboxes at once and copies one warm state into many clones.
- GPUs and your own cloud. For teams that need GPUs or must keep compute in their own AWS, GCP or Azure account, Tensorlake offers both.
- A real root disk. For agents with big repos: Tensorlake gives each sandbox a root disk of up to 100 GiB instead of files held in memory.
Where boat fits
Blaxel and Tensorlake are both built around sandboxes that sleep and wake warm. If your agents instead work for hours on builds, tests, Docker and emulators, boat gives each one a whole Linux machine with a real disk, a faster CPU and coding agents built in.
Emulators and VMs run inside
Neither Blaxel nor Tensorlake exposes /dev/kvm, so an Android emulator or a VM does not start at all. boat gives every sandbox /dev/kvm, so an agent testing a mobile app has somewhere to run it.
Keys stay outside the machine
On Tensorlake, stored secrets are injected into the sandbox the agent controls, where one prompt injection can leak them. Blaxel's secret proxy is still in public preview. boat's proxy keeps real keys outside for any HTTPS API.
Agents built in, reachable like a server
On both you install or wire up the agent harness yourself, and neither carries raw TCP inbound. boat ships Claude Code and Codex with one API to drive agents inside from outside, plus HTTPS on 50 ports and raw TCP.
Use boat when your agents do real work for hours: builds, tests, Docker and emulators on a whole Linux machine with a real disk, a faster CPU, coding agents built in and keys kept outside. Compare it one to one: boat vs Blaxel and boat vs Tensorlake.
Questions people ask
Is Blaxel cheaper than Tensorlake?
For one agent, yes: one coding agent on workdays is $33 a month on Blaxel and $250 on Tensorlake Pro, because Pro has a $250 minimum. For 50 agents in parallel Tensorlake is cheaper, $1,030 against $1,489. boat is $20 and $317 for those two.
Which is faster, Blaxel or Tensorlake?
Only Blaxel has a result on the shared CPU benchmark: 19.48 runs per second, against 26.69 for boat. Tensorlake has no published result there. Blaxel wakes from standby in under 25 ms.
Can Blaxel and Tensorlake run Docker?
Yes. Blaxel has a Docker-in-sandbox image and Tensorlake runs Docker on its ubuntu-systemd image. Neither exposes /dev/kvm, so Android emulators and VMs do not run, while boat runs both.
Which handles more sandboxes at once?
Tensorlake Pro allows 1,000 at once. Blaxel's self-serve tiers allow 10, 50 or 200, and standby sandboxes count toward that, so more needs a sales tier.
Do Blaxel and Tensorlake keep memory when a sandbox sleeps?
Both do. Blaxel saves memory and processes in standby, and Tensorlake does it for named sandboxes and can copy one into warm clones. boat keeps the disk and reboots on resume.
Where do Blaxel, Tensorlake and boat run?
Blaxel runs in Oregon, North Virginia, London and Frankfurt. Tensorlake runs in the US and the EU, or in your own cloud through BYOC. boat runs only in the EU, in Germany, Finland and France, with EU data residency.
Try boat
Install the CLI, then run boat new.
7-day free trial