Tensorlake vs Agent 37
Tensorlake gives every sandbox its own microVM kernel and can copy a running one into many warm clones, aimed at evals and RL rollouts. Agent 37 hosts one always-on agent per user in a lighter gVisor sandbox that sleeps when idle and wakes on the next message.
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
Agent 37
Agent 37 hosts AI agents, one isolated, always-on sandbox per user, behind one API.
You create an instance from a template (Hermes, OpenClaw, Claude Code, Codex, OpenCode, Pi, Grok or your own Docker image) and talk to it through a chat API, files, exec, SSH and HTTPS URLs. The default instance is a container enforced by gVisor; a VM type gives a full Linux machine with its own kernel for Docker, Kubernetes and Android emulators. It is built for companies that give each of their customers an agent.
- Where it runs
- Dedicated servers in the United States
- Instance types
- Default (shared), Performance (dedicated cores), VM
- Compliance
- SOC 2 Type I, Type II in progress
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 | Agent 37: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month All three fit; on Agent 37 Docker needs the VM type, Tensorlake has no nested virtualization, and bochka gives every agent Docker, systemd, /dev/kvm and a desktop. | 5th cheapest of 367 $1,010 a month | 2nd cheapest of 367 $551 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Agent 37 ranks first here, since it is built for one always-on assistant per user that sleeps, keeps its memory and wakes on the next message. | 9th cheapest of 366 $1,381 a month | Cheapest of 366 $279 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 Agent 37 ranks first for short code runs on its small default sandboxes billed per minute; bochka's start-rate limits queue big bursts of new machines. | 24th cheapest of 345 $250 a month | Cheapest of 345 $22 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 bochka ranks first; Agent 37's top self-serve tier holds 200 instances, counting sleeping ones, so 300 at once does not fit, and Tensorlake ranks 5th. | 5th cheapest of 361 $471 a month | 30th of 361, with limits $79 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 first for RL rollouts: Pro allows 1,000 sandboxes at once and copies one warm state into many clones, while Agent 37 has no fork and stops at 200 instances. | Cheapest of 360 $5,637 a month | 6th of 360, with limits $363 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 | 90th of 364, with limits $58 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 | 2nd cheapest of 377 $84 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Agent 37 ranks 3rd for a box that stays on, while Tensorlake's model is built around suspending idle sandboxes; bochka adds systemd and raw TCP on a full VM. | 185th of 368, with limits $250 a month | 3rd cheapest of 368 $12 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 Agent 37 ranks first; Tensorlake ships an XFCE desktop over VNC, and bochka streams a 60fps desktop with Chromium in every sandbox. | 9th cheapest of 369 $294 a month | Cheapest of 369 $53 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 | 48th of 367, with limits $29 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 | Cheapest of 346 $32 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 | 36th of 338, with limits $648 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 Agent 37 ranks first and bochka 2nd; bochka can fork a running VM to try many paths at once, and Tensorlake can clone one with its memory. | 4th cheapest of 360 $250 a month | Cheapest of 360 $43 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 | Agent 37 | bochka |
|---|---|---|---|
| Isolation | Firecracker and Cloud Hypervisor microVMs with their own kernel; GPU sandboxes use gVisor | gVisor by default; full VM with its own kernel as an opt-in instance type | Every sandbox is a full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker inside | Yes, on the tensorlake/ubuntu-systemd image | Only on the VM type, at 2.5x the default compute rate | Yes, in every sandbox, with root and systemd |
| systemd and init | Yes, on the ubuntu-systemd image | Your entrypoint is PID 1 with no init system, even on the VM type | systemd runs as on any Linux server |
| Nested virtualization | No: sandboxes set SANDBOX_KVM_AVAILABLE=0 | /dev/kvm on the VM type, with a ready Android template | /dev/kvm in every sandbox, so Android emulators and VMs run |
| Memory across sleep | Memory snapshots and suspend keep running processes and restore warm | Memory checkpointed on auto-sleep; processes resume when the restore works | Disk kept through snapshots every minute; a resume reboots the machine |
| Clone a running sandbox | Copy a running or suspended sandbox into N warm clones with memory | No fork; daily backups plus one on-demand backup, restored in place only | Fork a running sandbox (disk); named snapshots as shareable templates |
| Idle handling | Idle timeout, 600 s by default, then suspend (named) or terminate (ephemeral) | Opt-in auto-sleep after a quiet period (default 15 minutes), wakes on the next request | No idle timer; a time limit you set (1 h by default) or none; a stopped sandbox costs nothing |
| Built-in agents | You bring and run your own agent; managed images are plain OS bases | Hermes, OpenClaw, Claude Code, Codex, Grok, OpenCode, Pi, with a chat API per instance | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| API keys | Stored secrets are injected into the sandbox | Managed LLM, search and Composio through a per-instance token; your own keys go in as env vars | Credentials proxy for model providers and any HTTPS API you register; real keys never enter the sandbox |
| Desktop and computer use | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | noVNC desktop through a template build or the Ubuntu VM template | 60fps desktop and Chromium in every sandbox, computer use and an embeddable stream |
| Inbound traffic | HTTP, WebSocket and gRPC through an authenticated proxy on exposed ports | HTTPS URL per port, signed URLs, custom domains; no public IP, SSH through a WebSocket tunnel | 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 at all | No provider-side allowlist documented | No provider-side allowlist; you set your own firewall as root |
| GPUs | GPU sandboxes by request (H100 shown in the docs) | None | None |
| Where it runs | US and EU, or your own cloud account through BYOC | Dedicated servers in the United States | EU only: Germany, Finland, France, with EU data residency |
Every feature Battleships tracks (43)
| Feature | Tensorlake | Agent 37 | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | Yes | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | 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 | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | No | No | 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 | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
Neither Tensorlake nor Agent 37 has a published result on the hpc-sandbox-benchmarks Node.js build-and-test loop, so there is no comparable CPU measurement between them. bochka scores 26.69 runs/s at 4 vCPU / 8 GB, the fastest result measured. Agent 37 says its default instances share host resources and sells a Performance type on dedicated cores.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Tensorlake and Agent 37 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 | Agent 37, 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 | $6 · Wallet (any top-up) | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Pro | $12 · Wallet (any top-up) | $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 | $329 · Wallet ($100 lifetime top-ups) | $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 | $33 · Wallet ($250 lifetime top-ups) · 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 | $73 · Wallet ($250 lifetime top-ups) · with limits | $2,000 · $2000/mo · with limits |
Tensorlake: Pro is $250 per billing cycle, which includes 25,000 CU of usage, then $0.01 per CU; CPU is billed while active and RAM and disk on allocation while running. Small users can buy prepaid Usage Credits packs from $5 instead, which the table does not price.
Agent 37: A prepaid wallet with no plan fee, metered per minute: $0.80 per vCPU and $0.70 per GB of RAM per month while running, and $0.09 per GB of disk per month even while asleep. Performance compute costs 4x and VM compute 2.5x the default rate.
Agent 37: A monthly plan from $20, all of it usage credit, billed per second while running. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Agent 37 holds at most 200 instances on its top self-serve tier, counting sleeping and stopped ones, so 300 user sandboxes at once and 1,000 short jobs at once do not fit; the 50-agent scenario is priced on its VM type because it needs Docker. Tensorlake's Pro plan allows 1,000 sandboxes at once and fits all five scenarios, but its prepaid Usage Credits plan caps each sandbox at 4 vCPU / 16 GB and 24-hour sessions, and an ephemeral sandbox ends after 10 idle minutes by default. bochka's limit is how fast new machines start, which is what stops it in the 1,000-at-once burst.
| Scenario | Tensorlake | Agent 37 | 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, or need GPUs, outbound rules, US and EU regions or sandboxes in your own cloud.
- Warm clones from memory. For evals and RL rollouts: Tensorlake saves a sandbox's memory and copies it into many clones that start warm.
- GPUs and your own cloud. Tensorlake offers GPU sandboxes by request and can run in your own AWS, GCP, Azure, CoreWeave, Nebius or bare-metal account.
- A kernel and outbound rules per sandbox. Every Tensorlake sandbox is a microVM that can run Docker, with allow and deny lists for outbound traffic, in the US or EU.
Use Agent 37 when
you host one mostly idle assistant per customer in the US that should sleep with its memory kept and wake on the next message.
- Hosted agents behind a chat API. For giving each customer an agent: start Hermes, OpenClaw, Claude Code or Codex from a template and talk to it over a chat API.
- Sleeps and wakes on the next message. Useful for assistants idle most of the day: an instance sleeps, keeps its memory and wakes when a request arrives.
- Pay per minute with no plan fee. Agent 37 bills a prepaid wallet per minute with no plan or seat fee, so one small always-on agent costs very little.
Where bochka fits
Look at bochka when your agents do hours of real work in one machine: installs, builds, Docker, emulators and a desktop. Every bochka sandbox is a full VM with /dev/kvm, systemd and Docker on dedicated AMD Ryzen 9 9950X hosts, with coding agents built in and keys kept outside. Pick Tensorlake for warm memory clones or GPUs, and Agent 37 for many mostly idle assistants in the US.
Docker and emulators in every sandbox
Tensorlake has no /dev/kvm, so an Android emulator does not start. Agent 37 runs Docker and KVM only on its VM type, at 2.5x the compute rate and with no init system, so services do not start on their own.
Keys stay outside the machine
Tensorlake injects stored secrets into the sandbox, and on Agent 37 your own keys sit as env vars. One prompt injection can leak them. bochka's proxy keeps real keys outside for any HTTPS API you register.
Reach it like a server
Tensorlake's proxy carries only HTTP, WebSocket and gRPC, and Agent 37 gives no public IP and tunnels SSH over WebSocket. A database an agent starts cannot be reached directly. bochka gives HTTPS on 50 ports, raw TCP and its own IP.
Use bochka when your agents do real work for hours: installs, builds, Docker, emulators and a desktop on a full VM, with forks of running machines and keys kept outside for any API. Compare it one to one: bochka vs Tensorlake and bochka vs Agent 37.
Questions people ask
Is Tensorlake cheaper than Agent 37?
No, in the scenarios we price Agent 37 is lower every time: 50 agents in parallel is $329 a month on Agent 37 against $1,030 on Tensorlake Pro, and one agent that never stops is $12 against $250. But Agent 37 does not fit 300 user sandboxes at once or 1,000 short jobs at once, because of its 200-instance cap, while Tensorlake fits all five.
Which is faster, Tensorlake or Agent 37?
Neither has a published result on the hpc-sandbox-benchmarks CPU test, so there is no fair comparison. bochka scores 26.69 runs/s there, the fastest measured. Agent 37 sells a Performance type on dedicated cores at 4x the compute rate for steady speed.
Can Agent 37 or Tensorlake run Docker?
Tensorlake runs Docker on its tensorlake/ubuntu-systemd image. Agent 37 runs Docker only on its VM type, which bills compute at 2.5x; the default gVisor type cannot run a Docker daemon. bochka runs Docker in every sandbox.
Do they keep a sandbox's memory while it sleeps?
Both do. Tensorlake's named sandboxes suspend with memory and running processes, and can be copied into warm clones. Agent 37 checkpoints memory on auto-sleep and wakes on the next request. bochka keeps the disk but reboots on resume.
Where do Tensorlake and Agent 37 run?
Tensorlake runs in the US and the EU, and can run in your own cloud account through BYOC. Agent 37 runs on dedicated servers in the United States. bochka runs only in the EU, in Germany, Finland and France.
Are Tensorlake and Agent 37 SOC 2 compliant?
Tensorlake lists SOC 2 Type II on every tier. Agent 37 says it has SOC 2 Type I, with Type II in progress. For bochka, SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.
Try bochka
Install the CLI, then run bochka new.
Product preview