Tensorlake vs Sprites
Both give each agent a Firecracker microVM with its own kernel. Tensorlake lets you pick the size, freeze memory and copy a running sandbox into warm clones, while Sprites gives every agent a fixed 8 vCPU machine that sleeps seconds after work stops and wakes 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
Sprites
Sprites is Fly.io's product for agents: persistent Linux computers you create by API or CLI, which sleep when idle and wake on the next request.
Each Sprite is a Firecracker microVM with 8 vCPU, memory the platform manages, and a 100 GB ext4 disk that syncs to object storage. It runs one managed Ubuntu image with Claude Code, Codex, Gemini CLI and Cursor preinstalled, gets an HTTPS URL that wakes it, and bills only for the CPU and memory it actually uses while awake. It is built for coding agents, dev environments and user code that sit idle most of the time.
- Isolation
- Firecracker microVM per Sprite
- Regions
- Not selectable for Sprites
- Free start
- $30 trial credit per organization
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 | Sprites: 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 with systemd and Docker, while Sprites is a compromise with no systemd and one public HTTP port; bochka adds /dev/kvm for emulators. | 5th cheapest of 367 $1,010 a month | 66th of 367, with limits $546 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Tensorlake named sandboxes suspend with memory, while a Sprite drops open connections on every pause; bochka just keeps the machine running with no session cap. | 9th cheapest of 366 $1,381 a month | 157th of 366, with limits $1,166 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: Sprites sleeps about 30 seconds after the last command and bills real CPU use, and Tensorlake boots in a few hundred milliseconds. | 24th cheapest of 345 $250 a month | 93rd of 345, with limits $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 | 5th cheapest of 361 $471 a month | 56th of 361, with limits $428 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 here, built to fan out about a thousand rollouts from one warm state, which Sprites does not confirm and bochka's start-rate limits queue. | Cheapest of 360 $5,637 a month | 105th of 360, with limits $6,540 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 | 125th of 364, with limits $545 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 | 54th cheapest of 377 $424 a month | 63rd cheapest of 377 $476 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, since both are built around sleeping idle machines; bochka keeps it running with SSH and systemd. | 185th of 368, with limits $250 a month | 213th of 368, with limits $27 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, and Sprites is headless; bochka streams a 60fps desktop with Chromium. | 9th cheapest of 369 $294 a month | 85th of 369, with limits $136 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 gives a browser agent a desktop to work in, while on Sprites you install and run a headless browser yourself. | 13th cheapest of 367 $250 a month | 171st of 367, with limits $122 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 | 229th of 346, with limits $206 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 | 141st of 338, with limits $4,113 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 with outbound rules by domain, IP or CIDR; bochka adds raw TCP inbound and nested virtualization. | 4th cheapest of 360 $250 a month | 210th of 360, with limits $223 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 | Sprites | bochka |
|---|---|---|---|
| Isolation | Firecracker and Cloud Hypervisor microVMs with their own kernel; GPU sandboxes use gVisor | Firecracker microVM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | You set CPU, memory and disk at creation; up to 16 vCPU, 64 GB RAM and 100 GB disk on Pro | Fixed 8 vCPU and 100 GB disk; memory managed and scaled by the platform | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Inside the machine | Root and Docker on the tensorlake/ubuntu-systemd image; no /dev/kvm | Root and Docker (with rough edges users report); no systemd, and no /dev/kvm in the docs | Root, Docker, systemd and /dev/kvm, so Android emulators and VMs run |
| Memory on pause | Memory snapshots and suspend keep running processes and restore warm | Pauses with memory and wakes in 100 to 500 ms, or 1 to 2 s after a cold stop | No: disk is kept, resume boots the machine again |
| Clone or fork | Copy a running or suspended sandbox into N warm clones with memory | No fork; checkpoints restore in place | Fork a running sandbox with its disk into a new one |
| Idle behavior | Idle timeout, 600 s by default, then suspend (named) or terminate (ephemeral) | Pauses about 30 seconds after activity stops and wakes on the next request | Runs until you stop it or its time to live ends; a stopped sandbox costs nothing |
| Desktop and browser | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | Headless; no desktop or browser product | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Coding agents | You bring and run your own agent; managed images are plain OS bases | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| API keys | Stored secrets are injected into the sandbox | Connectors gateway holds the token for GitHub, OpenRouter, Slack or any HTTP API, with path allow and block lists | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Inbound traffic | HTTP, WebSocket and gRPC through an authenticated proxy on exposed ports | One HTTPS URL to one HTTP port; other ports and SSH only through the sprite proxy CLI | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP, a dedicated IP and SSH |
| Outbound rules | allow_out and deny_out lists by domain, IP or CIDR, or no internet at all | Optional DNS-based domain allowlist set from outside; private IPs always blocked | No provider-side allowlist; you set your own firewall as root |
| GPUs | GPU sandboxes by request (H100 shown in the docs) | None | None |
| Integrations | API and SDKs, plus versioned file systems, hosted Git and an orchestration layer | Remote MCP server, agent plugins, and backends for Claude Managed Agents and Cursor Cloud Agents | REST API, CLI and SDKs |
| Where it runs | US and EU, or your own cloud account through BYOC | Region not selectable | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Tensorlake | Sprites | 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 | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | 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 | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | 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 | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | No | 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 | No | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
Neither Tensorlake nor Sprites has a result on the hpc-sandbox-benchmarks test we use, so there is no CPU comparison between the two. bochka did 26.69 runs per second on the Node.js build-and-test loop at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. Tensorlake's docs say its default image starts in a few hundred milliseconds, and Sprites says a warm wake takes 100 to 500 ms.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Tensorlake and Sprites 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 | Sprites, 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 | $23 · Pay-as-you-go | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Pro | $92 · Pay-as-you-go | $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,120 · Pay-as-you-go | $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 | $314 · 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 | $1,134 · Pay-as-you-go · with limits | $2,000 · $2000/mo · with limits |
Tensorlake: Pro is $250 per billing cycle, which includes 25,000 CU ($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 prepaid Usage Credits packs from $5 suit very small workloads.
Sprites: Sprites bills CPU time at $0.0385 per CPU-hour and actual memory at $0.021875 per GB-hour, only while the Sprite is awake, plus storage on the bytes you write. Optional plans such as Hero at $100 a month buy fixed allowances, not credit.
Sprites: Plans start at $20 a month, and the whole fee is usage credit. You pay per second for the size you pick while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Tensorlake's Pro plan allows 1,000 sandboxes at once, so 300 sandboxes for your users and 1,000 short jobs at once both fit. Sprites does not publish how many Sprites can run at once on pay as you go, so those two scenarios are not confirmed, and creation is 10 a minute without a plan. On Tensorlake an ephemeral sandbox ends after 10 idle minutes by default, and a Sprite drops open connections on every pause unless a task holds it awake, for up to an hour at a time. bochka has no session cap on paid plans, but even its $2,000 plan queues starts above 90 a minute, so 1,000 short jobs at once does not fit.
| Scenario | Tensorlake | Sprites | bochka |
|---|---|---|---|
| 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 |
| 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 runs from one warm state, need to pick the machine size or add GPUs, or want sandboxes in the US or your own cloud account.
- Memory snapshots and warm clones. Useful when many runs must start from one prepared state: Tensorlake copies a running sandbox into warm clones with memory.
- Pick the size, add GPUs. Tensorlake lets you set CPU, memory and disk per sandbox and offers GPU sandboxes by request, where a Sprite is always 8 vCPU.
- Your cloud, your region. Tensorlake runs in the US or the EU, or inside your own AWS, GCP, Azure, CoreWeave, Nebius or bare-metal account.
Use Sprites when
your agents or apps sit idle most of the day and should wake on a request, with coding agents preinstalled and tokens kept in Connectors.
- Sleeps when idle, wakes on request. Useful for agents and apps that sit idle most of the day: a Sprite stops billing compute and wakes on the next request.
- Agents preinstalled, keys held outside. Sprites ships Claude Code, Codex, Gemini CLI and Cursor, and its Connectors keep API tokens out of the machine.
- Plugs into agent platforms. Teams on Claude Managed Agents or Cursor Cloud Agents can use Sprites as the machine behind them, next to the rest of Fly.io.
Where bochka fits
Tensorlake and Sprites are both built around machines that sleep when idle. If your agents do long, hands-on work, such as builds, emulators, a desktop and services others connect to, look at bochka: a full VM on a dedicated Ryzen 9 host that stays on, with coding agents you drive from outside and keys kept outside the machine.
Run emulators and VMs inside
Neither Tensorlake nor Sprites gives a sandbox /dev/kvm, so an Android emulator or a nested VM does not start, and Sprites has no systemd either. bochka runs Docker, systemd and /dev/kvm in every sandbox.
Reach it like a server
Tensorlake's proxy carries only HTTP, WebSocket and gRPC, and a Sprite has one public HTTP port, with everything else tunneled through a CLI on your machine. bochka gives up to 50 HTTPS ports, raw TCP, SSH and its own IP.
Drive agents inside from outside, with a screen
On Tensorlake you install the agent yourself and secrets go into the sandbox; Sprites is headless and runs agents through exec. bochka preinstalls seven agents with a prompt, steer and events API, a 60fps desktop and a credentials proxy.
Use bochka when your agents do real work for hours: systemd, Docker, emulators, many ports, a desktop and browser, forks, and an API to drive the agents inside from outside. Compare it one to one: bochka vs Tensorlake and bochka vs Sprites.
Questions people ask
Is Tensorlake cheaper than Sprites?
For one agent it is not: one coding agent on workdays is $250 a month on Tensorlake Pro and $23 on Sprites, and one that never stops is $250 against $92. For 50 agents in parallel Tensorlake is $1,030 against $1,120 on Sprites, and bochka is $317 a month.
Which is faster, Tensorlake or Sprites?
Neither has a result on the CPU benchmark we use, so we cannot say. Both start quickly: Tensorlake in a few hundred milliseconds, and a Sprite wakes in 100 to 500 ms. bochka did 26.69 runs per second on that benchmark.
Can Tensorlake and Sprites run Docker?
Both run Docker inside. Tensorlake also offers an image with systemd, while Sprites does not run systemd and users report that docker exec fails for containers whose main process is not root. Neither exposes /dev/kvm; bochka runs Docker, systemd and /dev/kvm.
Do Tensorlake and Sprites keep memory when idle?
Yes, both can. Tensorlake named sandboxes suspend with memory and running processes, and can be copied into warm clones. A Sprite pauses about 30 seconds after work stops and wakes with its processes still in memory, but open connections drop.
Which one has GPUs or a desktop?
Tensorlake offers GPU sandboxes by request and an XFCE desktop with Firefox for computer use. Sprites has neither. bochka has no GPUs but streams a 60fps desktop with Chromium.
Where do Tensorlake and Sprites run?
Tensorlake runs in the US and the EU, or in your own cloud account through BYOC. Sprites does not let you choose a region. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview