Tensorlake vs CodeSandbox SDK
Both run each sandbox in a Firecracker microVM that can save its memory and resume warm. Tensorlake is built for running many at once, with a desktop, GPUs by request and your own cloud, while CodeSandbox SDK is strongest at VMs that hibernate for free and wake on the next HTTP request, on what Together now calls its legacy SDK.
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
CodeSandbox SDK
CodeSandbox SDK is an API from CodeSandbox, now a Together AI company, that starts sandboxed development VMs on the same infrastructure as the CodeSandbox editor.
Each sandbox is a Firecracker microVM built from a template or any Dockerfile. When it goes idle it hibernates with a memory snapshot, and it resumes or forks from that snapshot in seconds. You drive it from a TypeScript SDK through terminals, commands, files and HTTPS hosts. Together's docs now call it the legacy offering and point new users to its successor, the together-sandbox SDK.
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 | CodeSandbox SDK: 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 and CodeSandbox SDK is a compromise; bochka ranks 3rd with nested virtualization and coding agents built in. | 5th cheapest of 367 $1,010 a month | 178th of 367, with limits $1,939 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 | 215th of 366, with limits $2,478 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 fit short code runs well, since both keep memory and bill only while running; bochka's start-rate limits make big bursts a compromise. | 24th cheapest of 345 $250 a month | 46th cheapest of 345 $642 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 allows 1,000 sandboxes at once on Pro, while CodeSandbox SDK's Scale plan stops at 250; bochka ranks 1st with HTTPS, raw TCP and SSH per user. | 5th cheapest of 361 $471 a month | 140th of 361, with limits $1,707 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 for rollouts at a thousand at a time; CodeSandbox SDK's 250-VM cap and bochka's start-rate limits make it a compromise. | Cheapest of 360 $5,637 a month | 348th of 360, with limits $3,861 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 | 64th cheapest of 364 $1,335 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 Both run fresh build machines, but neither exposes /dev/kvm for Android or VM builds, which bochka does on its Ryzen 9 9950X hosts. | 54th cheapest of 377 $424 a month | 92nd cheapest of 377 $860 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both are built around sleeping idle sandboxes, so a box that stays on all day is a compromise on each; bochka fits it with no session cap. | 185th of 368, with limits $250 a month | 310th of 368, with limits $240 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 computer-use calls and CodeSandbox SDK has no desktop; bochka streams a 60fps desktop with Chromium. | 9th cheapest of 369 $294 a month | 206th of 369, with limits $691 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 ships Firefox on a desktop, CodeSandbox SDK offers a headless Chromium template, and bochka ships Chromium on a full desktop. | 13th cheapest of 367 $250 a month | 251st of 367, with limits $443 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 | 281st of 346, with limits $508 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 | 193rd of 338, with limits $7,390 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 | 240th of 360, with limits $326 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 | CodeSandbox SDK | bochka |
|---|---|---|---|
| Isolation | Firecracker and Cloud Hypervisor microVMs; GPU sandboxes use gVisor | Firecracker microVM per sandbox | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Memory snapshots | Named sandboxes suspend with memory and running processes | Idle sandboxes hibernate with a memory snapshot and resume with processes running | No: disk is saved every minute and on stop, and resume boots the machine again |
| Clone a running sandbox | Copy a running or suspended sandbox into N warm clones with memory | Fork a hibernated sandbox from its snapshot, or a running one sharing its memory | Fork a running sandbox with its disk |
| Sandboxes at once | 1,000 on Pro, more on Enterprise | 250 on Scale, more on Enterprise | No concurrency cap at these sizes; new starts are rate-limited |
| Idle handling | Idle timeout, 600 s by default, then suspend or terminate | Hibernates after an idle timeout, 1,800 s by default on paid plans, up to one day | Time-to-live (1 h by default, changeable or off); no idle timer |
| Nested virtualization | No: sandboxes set SANDBOX_KVM_AVAILABLE=0 | Not documented | Yes, /dev/kvm inside, so Android emulators and VMs run |
| Docker inside | Yes, on the tensorlake/ubuntu-systemd image | Docker and root; built from any Dockerfile | Docker, systemd and root |
| Desktop and computer use | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | No desktop; a headless Chromium template | 60fps desktop and Chromium, computer-use and browser control, embeddable stream |
| Inbound traffic | HTTP, WebSocket and gRPC through an authenticated proxy | HTTPS host per port, public by default, signed tokens for private hosts | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP and a dedicated IP |
| Outbound rules | allow_out and deny_out lists by domain, IP or CIDR, or no internet at all | No published outbound allowlist | No provider-side allowlist; you set your own firewall as root |
| Coding agents | You bring and run your own agent | Run your own agent through the command API | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| API keys | Stored secrets are injected into the sandbox | Secrets passed in as environment variables | Credentials proxy for model providers and any HTTPS API; real keys never enter the sandbox |
| 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 | No guaranteed region; a country hint steers scheduling | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Tensorlake | CodeSandbox SDK | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | 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 | 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 | No | 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 | 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 | 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 | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
Neither Tensorlake nor CodeSandbox SDK has a result on the StarSling hpc-sandbox-benchmarks CPU run, so there is no comparable CPU measurement between them. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Tensorlake and CodeSandbox SDK 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 | CodeSandbox SDK, 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 | $193 · Scale | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Pro | $341 · Scale | $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 | $2,500 · Scale | $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 | $815 · Scale · 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,632 · Scale · 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 only while it is actively working, RAM and disk on what you allocate while running, and a suspended sandbox pays snapshot storage.
CodeSandbox SDK: You buy VM credits and each size burns a fixed number per hour, billed per started minute while the VM runs, including the idle time before it hibernates. Scale adds a $170 monthly platform fee that is not usage credit, and a hibernated VM costs nothing.
CodeSandbox SDK: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
CodeSandbox SDK's Scale plan allows 250 VMs at once, so the user-sandboxes and 1,000-job scenarios do not fit it without Enterprise, and its 20 GB disk and egress have no published price beyond that. Tensorlake Pro allows 1,000 sandboxes at once and fits every scenario, though an ephemeral sandbox ends after 10 idle minutes by default. bochka fits all but the 1,000-job burst, where even the $2,000 plan queues starts above 90 a minute.
| Scenario | Tensorlake | CodeSandbox SDK | 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 hundreds of rollouts or user sandboxes at once, or need a desktop, GPUs, outbound rules, US regions or sandboxes in your own cloud.
- Built for big fan-outs. Teams running hundreds of sandboxes at once get 1,000 on Tensorlake Pro, where CodeSandbox SDK's Scale plan stops at 250.
- A desktop for computer use. Agents that click through apps get an XFCE desktop with Firefox and screenshot, mouse and keyboard calls; CodeSandbox SDK has no desktop.
- GPUs, outbound rules and your own cloud. Tensorlake offers GPU sandboxes by request, outbound allow and deny lists, US and EU regions, and BYOC on AWS, GCP and Azure.
Use CodeSandbox SDK when
your sandboxes sleep between visits and should wake on the next HTTP request with memory intact, and you are fine building on what Together now calls its legacy SDK.
- Sleep for free, wake on request. Useful for previews used in short bursts: a hibernated VM costs nothing and wakes on its next HTTP request with processes running.
- Lower bill for a workday agent. For one coding agent on workdays, the table comes to $193 a month on CodeSandbox SDK Scale against $250 on Tensorlake Pro.
Where bochka fits
Tensorlake and CodeSandbox SDK are both built around sandboxes that sleep when idle and wake warm. If your agents instead do hours of real work, with builds, emulators, a desktop and servers other people reach, bochka gives each one a full VM that stays on, with coding agents built in and keys kept outside.
Run emulators and VMs inside
Tensorlake sets SANDBOX_KVM_AVAILABLE=0 and CodeSandbox SDK does not document nested virtualization, so an Android emulator or a VM an agent needs has nowhere to start. bochka exposes /dev/kvm in every sandbox.
Agents built in, keys kept outside
On both you install the agent yourself and pass secrets into the machine the agent controls, where one prompt injection can leak them. bochka preinstalls Claude Code and Codex and keeps real keys in a proxy outside.
Reach it like a server
Tensorlake's proxy carries HTTP, WebSocket and gRPC, and CodeSandbox SDK hosts are HTTPS only, so a database or raw TCP service an agent starts cannot be reached. bochka adds raw TCP and a dedicated IP.
Use bochka when your agents do real work for hours: installs, builds, Docker, emulators, a desktop and servers other people reach, with coding agents built in and keys kept outside the machine. Compare it one to one: bochka vs Tensorlake and bochka vs CodeSandbox SDK.
Questions people ask
Is Tensorlake cheaper than CodeSandbox SDK?
It depends on the workload. One coding agent on workdays is $193 a month on CodeSandbox SDK against $250 on Tensorlake, but one agent running 24/7 is $250 on Tensorlake against $341 on CodeSandbox SDK, and 50 agents in parallel is $1,030 against $2,500. On bochka those three come to $20, $26 and $317 a month.
Which is faster?
Neither has a result on the CPU benchmark we use, so there is no fair speed comparison between them. bochka scored 26.69 runs per second on it at 4 vCPU / 8 GB.
Can Tensorlake and CodeSandbox SDK run Docker?
Yes, both run Docker inside the sandbox: Tensorlake on its tensorlake/ubuntu-systemd image, CodeSandbox SDK from any Dockerfile. Neither offers nested virtualization, while bochka exposes /dev/kvm for Android emulators and VMs.
Do both keep a sandbox's memory when it sleeps?
Yes. Tensorlake's named sandboxes suspend with memory and running processes, and CodeSandbox SDK hibernates with a memory snapshot and can wake on an HTTP request. bochka keeps the disk, saved every minute and on stop, but resuming boots the machine again.
Is CodeSandbox SDK still maintained?
CodeSandbox is now part of Together AI. Together's docs call the CodeSandbox-based SDK deprecated and name together-sandbox as its successor, while self-serve sign-up still runs through CodeSandbox.
How many sandboxes can run at once?
Tensorlake Pro allows 1,000 at once and CodeSandbox SDK Scale allows 250, with more on each Enterprise plan. bochka has no concurrency cap at these sizes, but bursts above 90 starts a minute are queued.
Try bochka
Install the CLI, then run bochka new.
Product preview