Tensorlake vs Beam
Tensorlake gives each agent a Firecracker microVM that can suspend with its memory and wake up warm. Beam is a serverless GPU cloud whose sandboxes are quick gVisor containers, with separate CPU VMs and an open-source runtime you can host yourself.
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
Beam
Beam is a serverless cloud for GPU inference, sandboxes and background jobs, built on its open-source runtime Beta9.
Beam runs functions, REST endpoints, task queues, pods, sandboxes and VMs on CPUs and GPUs, all from a Python or TypeScript SDK. A sandbox is a container isolated with gVisor that starts in a second or two, lives until you terminate it or its time to live runs out, and can be saved as a filesystem image or a memory snapshot. Beam VMs are a separate CPU product: a microVM with its own kernel, systemd and a root disk that stays when it stops. Much of Beam is a GPU serverless platform for AI teams.
- Bring your own cloud
- Management fee per vCPU and GB of RAM, on top of your own cloud bill
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 | Beam: 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 better than Beam, whose sandboxes end with their time to live and lack systemd; bochka adds /dev/kvm and coding agents built in. | 5th cheapest of 367 $1,010 a month | 69th of 367, with limits $551 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 | 115th of 366, with limits $651 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 Beam fits short code runs well, since its sandboxes start in a second or two, bill per second and go away when the timer ends. | 24th cheapest of 345 $250 a month | 8th cheapest of 345 $117 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; bochka also gives each one token-protected HTTPS URLs and raw TCP. | 5th cheapest of 361 $471 a month | 3rd cheapest of 361 $290 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 from one memory snapshot. | Cheapest of 360 $5,637 a month | 341st of 360, with limits $939 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 | 13th cheapest of 364 $251 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 Beam runs fresh CPU jobs for less than Tensorlake; bochka runs on Ryzen 9 9950X hosts, the fastest measured on the CPU benchmark. | 54th cheapest of 377 $424 a month | 12th cheapest of 377 $171 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A box that stays on fits a Beam VM or bochka better than Tensorlake, whose model is built around suspending idle sandboxes. | 185th of 368, with limits $250 a month | 13th cheapest of 368 $21 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, while Beam has no desktop or browser product; bochka streams a 60fps desktop with Chromium. | 9th cheapest of 369 $294 a month | 111th of 369, with limits $237 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 | 195th of 367, with limits $176 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 | 200th of 346, with limits $131 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 | 42nd of 338, with limits $923 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 | 175th of 360, with limits $155 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 Beam is the one with GPUs here, from T4 and RTX 4090 up to H100 and B200; Tensorlake offers GPUs only by request and bochka is CPU only. | Can't run it | Cheapest of 98 $458 a month | 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 | Beam | bochka |
|---|---|---|---|
| Isolation | Firecracker and Cloud Hypervisor microVMs with their own kernel; GPU sandboxes use gVisor | gVisor container by default for sandboxes; separate Beam VMs are CPU microVMs with their own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Nested virtualization | No: sandboxes set SANDBOX_KVM_AVAILABLE=0 | Not documented | Yes, /dev/kvm inside, so Android emulators and VMs run |
| Docker and systemd | Docker and systemd on the tensorlake/ubuntu-systemd image | Docker inside sandboxes with docker_enabled; systemd only in Beam VMs | Docker, systemd and root, like a normal Ubuntu server |
| Memory snapshots | Yes: memory snapshots restore a sandbox warm with its running processes | Yes: a memory snapshot of a running sandbox is restored into new sandboxes | No: disk is kept, resume reboots the machine |
| Suspend when idle | Named sandboxes suspend with memory after an idle timeout (600 s by default) | No suspend: a sandbox runs until you terminate it or its time to live ends | No idle timer; disk saved on stop and a stopped sandbox costs nothing |
| Clone a running sandbox | Copy a running or suspended sandbox into N warm clones with memory | Restore one memory snapshot into new sandboxes | Fork a running sandbox with its disk |
| Disk between runs | Named sandboxes keep disk and memory while suspended, billed as snapshot storage; disk is 10 to 100 GiB | A sandbox ends with its time to live unless you save an image or use a volume; a Beam VM keeps a 50 GiB root disk | Disk saved every minute and on stop, kept for free while stopped |
| Desktop and computer use | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | No desktop or browser product | 60fps desktop with Chromium, computer use and browser control, embeddable stream |
| Coding agents | You bring and run your own agent | None preinstalled; you install and run them through process exec | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| API keys | Stored secrets are injected into the sandbox | Secrets are exposed as environment variables inside the sandbox | 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 on exposed ports | A public HTTPS URL per exposed port with no built-in auth; no raw TCP | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP and a dedicated IP |
| Outbound rules | Allow or deny lists by domain, IP or CIDR, or no internet at all | Block all outbound traffic, or allow up to 10 CIDR ranges | No provider-side allowlist; you set your own firewall as root |
| GPUs | GPU sandboxes by request (H100 shown in the docs) | GPU sandboxes and serverless GPUs from T4 and RTX 4090 up to H100, H200 and B200 | None, CPU only |
| Where it runs | US and EU, or your own cloud account through BYOC | US only; bring your own cloud for a fee, or self-host the AGPL-3.0 Beta9 runtime | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Tensorlake | Beam | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | 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 | No | 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 | 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 | 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 | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | 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 | Not published | 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 | Not published | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
Neither Tensorlake nor Beam has a result on the StarSling hpc-sandbox-benchmarks CPU test, so we cannot say which of the two is faster at CPU work. bochka did 26.69 runs per second on that test at 4 vCPU / 8 GB, the fastest result measured. On start time, Tensorlake's docs say its default image boots in a few hundred milliseconds, and Beam's guide says its sandboxes cold-boot in 1 to 3 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 Beam 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 | Beam, 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 | $5 · Developer | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Pro | $22 · Developer | $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 | $410 · Team | $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 | $191 · Team | $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 | $259 · Team | $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, and prepaid Usage Credits packs from $5 suit very small workloads.
Beam: Beam sandboxes bill per second for each CPU core (two vCPU) and GiB of RAM you request, until you terminate them or their time to live ends, so an idle tail is billed too. Developer has no fee; Team is $89 a month plus usage, with no usage credit and no egress fees.
Limits in those scenarios
Beam's Developer plan allows 30 CPU containers at once, so 50 parallel agents need the Team plan, which allows 1,000. Beam publishes no price for disk beyond what a VM includes, so the scenarios count no disk cost for it. Tensorlake Pro allows 1,000 sandboxes at once, but its prepaid Usage Credits plan caps each sandbox at 4 vCPU / 16 GB and 24-hour sessions, and resources are fixed when a sandbox is created. Both fit 1,000 short jobs at once, where bochka's start-rate limits queue the burst.
| Scenario | Tensorlake | Beam | 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
your agents must suspend and resume with their memory, when you fan out a thousand rollouts from one warm state, or when you need EU hosting or your own cloud account.
- Suspend with memory, wake up warm. For agents that must pick up mid-process, Tensorlake suspends idle sandboxes with memory and copies one into many warm clones.
- Big rollout fan-outs. For RL rollouts and evals, Tensorlake Pro allows 1,000 sandboxes at once from one prepared state.
- Desktop, domain rules and the EU. Tensorlake ships a desktop for computer use, filters outbound traffic by domain, and runs in the EU as well as the US.
Use Beam when
cost per CPU sandbox matters most, when your agents need GPUs next to their sandboxes, or when you must self-host the runtime.
- Lower bills for CPU sandboxes. Beam costs less than Tensorlake in all five scenarios we price, such as $22 against $250 for one agent that never stops.
- GPUs in the same platform. For work that needs a GPU, Beam has GPU sandboxes and serverless GPUs from T4 up to H100, H200 and B200.
- Open source you can host. Beam's Beta9 runtime is AGPL-3.0 and free to self-host, for teams that must run sandboxes on their own machines.
Where bochka fits
Tensorlake and Beam both hand you a sandbox and leave the agent, the desktop and the keys to you. If your agents do real work for hours, with installs, builds, Docker, emulators and a browser, bochka gives each one a full VM with coding agents built in and keys kept outside. Pick Tensorlake or Beam instead for GPUs, US hosting or thousands of short jobs at once.
A full VM with /dev/kvm
Tensorlake sandboxes set SANDBOX_KVM_AVAILABLE=0 and Beam documents no /dev/kvm, so an Android emulator or a VM an agent needs does not start. Beam sandboxes also lack systemd, which only its separate VMs have.
Agents in, keys out
On both you install and wire up the agent harness yourself, and secrets land inside the sandbox the agent controls, where one prompt injection can leak them. bochka preinstalls the agents and keeps real keys in a proxy outside.
Reach it like a server, keep its disk
Tensorlake carries only HTTP, WebSocket and gRPC, and Beam gives public HTTPS URLs with no auth, so neither reaches a raw TCP service. A Beam sandbox also ends after 10 minutes by default unless you save an image.
Use bochka when your agents do real work for hours: installs, builds, Docker, emulators and a desktop on a full VM, with coding agents built in and keys kept outside the machine. Compare it one to one: bochka vs Tensorlake and bochka vs Beam.
Questions people ask
Is Tensorlake cheaper than Beam?
No. Beam costs less in all five scenarios we price: one coding agent on workdays is $5 a month on Beam and $250 on Tensorlake Pro, and 50 agents in parallel is $410 against $1,030. Beam publishes no disk price, so those figures count no disk cost for it.
Which is faster, Tensorlake or Beam?
We have no comparable CPU measurement for either one. Tensorlake's docs say its default image boots in a few hundred milliseconds, and Beam's guide says its sandboxes cold-boot in 1 to 3 seconds. bochka did 26.69 runs per second on the hpc-sandbox-benchmarks CPU test.
Can Tensorlake and Beam run Docker?
Yes. Tensorlake runs Docker on its tensorlake/ubuntu-systemd image, and Beam runs Docker inside a sandbox with docker_enabled. bochka runs Docker with systemd and /dev/kvm in a full VM.
Is a Beam sandbox a VM like Tensorlake's?
Not by default. Beam sandboxes are containers using runc and gVisor, and Beam sells separate CPU VMs with their own kernel. Tensorlake sandboxes are Firecracker and Cloud Hypervisor microVMs, except GPU sandboxes, which use gVisor.
Which one has GPUs?
Beam has GPU sandboxes and serverless GPUs from T4 and RTX 4090 up to H100, H200 and B200. Tensorlake offers GPU sandboxes by request. bochka is CPU only.
Where do Tensorlake and Beam run?
Tensorlake runs in the US and the EU, and can run in your own cloud account through BYOC. Beam runs in the US, offers bring your own cloud for a fee, and its Beta9 runtime can be self-hosted. bochka runs only in the EU.
Try bochka
Install the CLI, then run bochka new.
Product preview