Tensorlake vs OpenAI Containers
Tensorlake sells microVM sandboxes with root and Docker that you create through an API and can suspend with their memory. OpenAI Containers are the short-lived boxes behind Code Interpreter and Hosted Shell, where the model runs code until the box expires after 20 minutes without use.
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
OpenAI Containers
OpenAI Containers are the sandboxes OpenAI runs for its own model tools: Code Interpreter, Hosted Shell and the Agents API's hosted sandbox.
This is a different kind of product from boat: a tool inside OpenAI's model API, not a machine you rent. You create a container through the API or let a Responses call make one, and the model runs Python or shell commands in it on a fixed Debian 12 image without sudo, until it expires after 20 minutes without use. It is built for apps that already call OpenAI models and want them to run code, read files and make charts without running any servers.
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 | OpenAI Containers: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Tensorlake gives a coding agent root, Docker and a sandbox it can keep, which a container without sudo that expires after 20 idle minutes does not; boat adds /dev/kvm and preinstalled coding agents. | 5th cheapest of 367 $1,010 a month | 356th of 367, with limits $17,371 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Tensorlake can suspend an assistant with its memory and wake it later, while an OpenAI container has to be touched every 20 minutes or its data is deleted; boat keeps the machine on with no session cap. | 9th cheapest of 366 $1,381 a month | 341st of 366, with limits $13,140 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 OpenAI Containers are built for this: the model writes Python and runs it in the same API call, while Tensorlake needs you to create and manage the sandbox yourself. | 24th cheapest of 345 $250 a month | 194th of 345, with limits $6,000 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 exposes ports through an authenticated HTTP proxy and OpenAI containers accept no inbound connections; boat adds HTTPS URLs on 50 ports and raw TCP for each user sandbox. | 5th cheapest of 361 $471 a month | 361st of 361, with limits $3,780 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 here, since Pro runs 1,000 sandboxes at once and can copy one warm state into many clones; OpenAI publishes no limit on how many containers run at once. | Cheapest of 360 $5,637 a month | 191st of 360, with limits $30,000 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 | 360th of 364, with limits $5,760 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 CI needs Docker and open internet: Tensorlake has both, while OpenAI documents no Docker and its Code Interpreter containers start with no internet. | 54th cheapest of 377 $424 a month | 345th of 377, with limits $1,728 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A box you SSH into and keep all month fits neither well: Tensorlake suspends idle sandboxes and OpenAI has no SSH or disk that persists, while boat stays on. | 185th of 368, with limits $250 a month | 362nd of 368, with limits $1,051 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 gives an XFCE desktop over VNC and OpenAI a hosted browser inside the Agents API beta; boat streams a 60fps desktop you can embed. | 9th cheapest of 369 $294 a month | 351st of 369, with limits $5,280 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 | 328th of 367, with limits $1,440 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 | 328th of 346, with limits $1,755 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 | 311th of 338, with limits $35,100 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 | 308th of 360, with limits $870 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 | OpenAI Containers | boat |
|---|---|---|---|
| What it is | MicroVM sandboxes you create, suspend and clone through an API | A sandbox tool the model uses inside OpenAI's API | A cloud VM you create, keep, stop and reach from outside |
| Isolation | Firecracker and Cloud Hypervisor microVMs; GPU sandboxes use gVisor | A fully sandboxed virtual machine; hypervisor not named | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root, Docker and nested virtualization | Root and Docker on the tensorlake/ubuntu-systemd image; no /dev/kvm | Commands do not run with sudo; no Docker or /dev/kvm documented | Root, systemd, Docker and /dev/kvm on every machine |
| Machine size | Set when created; up to 16 vCPU, 64 GB RAM and 100 GB disk on Pro | 1, 4, 16 or 64 GB of memory; vCPU not published | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB |
| Memory snapshots | Yes: suspend keeps memory and running processes, and restores warm | No snapshots of any kind | No: disk is kept, resume reboots the machine |
| Files after the session | Named sandboxes keep files while suspended, billed as snapshot storage; ephemeral ones end on idle | Data is discarded when the container expires and cannot be recovered | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Clone a running sandbox | Copy a running or suspended sandbox into N warm clones with memory | No fork; templates save configuration, not a running workspace | Fork a running sandbox with its disk |
| Lifetime | Idle timeout of 600 s by default, then suspend or end; no duration cap on Pro | Expires after 20 minutes without use; Agents API sandboxes after an hour | No session cap on paid plans; you set the time to live |
| Inbound access | HTTP, WebSocket and gRPC through an authenticated proxy on exposed ports | None; you reach the container only through the API | SSH, HTTPS URLs for up to 50 ports, raw TCP and a dedicated IP |
| Outbound internet | Open by default; allow_out and deny_out by domain, IP or CIDR, or no internet | Code Interpreter and Hosted Shell: off until an admin sets a domain allowlist | Open internet on every plan; you set your own firewall as root |
| API keys | Stored secrets are injected into the sandbox | domain_secrets: a sidecar adds the real header for approved domains | Credentials proxy for any HTTPS API: real keys never enter the sandbox |
| Coding agents | You bring and run your own agent on plain OS images | Agents API (beta) drives a managed Codex harness from outside | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Desktop and computer use | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | Hosted browser for the Agents API computer_use tool | 60fps desktop and Chromium, computer use, embeddable stream |
| GPUs and where it runs | GPU sandboxes by request; US and EU, or your own cloud through BYOC | No GPUs; US or EU processing for Code Interpreter | No GPUs; EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Tensorlake | OpenAI Containers | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | No | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | Yes | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | No | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | No | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | No | 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 | No | 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 | Yes | 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 | Yes | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
Neither Tensorlake nor OpenAI Containers has a result on the public hpc-sandbox-benchmarks CPU test, and OpenAI does not publish how many vCPU each container size gets, so there is no comparable CPU measurement between them. boat did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB, the fastest result measured. Tensorlake's docs say its default image starts in a few hundred milliseconds.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Tensorlake and OpenAI Containers 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 | OpenAI Containers, 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 | $250 · Pro | $228 · API pay as you go · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Pro | $1,051 · API pay as you go · with limits | $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 | $11,405 · API pay as you go · with limits | $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 | $1,620 · API 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 | $6,000 · API 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 active, and RAM and disk on what you allocate. Small users can buy prepaid Usage Credits packs from $5 instead, and sandboxes stop when the balance hits zero.
OpenAI Containers: OpenAI bills each container session by the minute for the memory size you pick, with a 5-minute minimum, and model tokens are billed on top. There is no plan fee.
OpenAI Containers: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Tensorlake Pro fits all five scenarios, including 1,000 short jobs at once, but an ephemeral sandbox ends after 10 idle minutes by default and the prepaid plan caps sandboxes at 4 vCPU / 16 GB and 24-hour sessions. OpenAI Containers fit none of the five as written: no persistent disk, no Docker, no internet in Code Interpreter until an admin allows domains, and no published vCPU per size. OpenAI also does not publish how many containers can run at once, so 300 user sandboxes or a 1,000-job burst are unconfirmed. On boat the burst is limited by starts per minute, so even the $2,000 plan queues it.
| Scenario | Tensorlake | OpenAI Containers | boat |
|---|---|---|---|
| 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 need a real sandbox with root and Docker that can sleep with its memory, fan out into thousands of warm clones, use GPUs, or run in the US or your own cloud.
- A sandbox you can keep and suspend. Useful for agents that work for days: Tensorlake gives root and Docker, and suspends a sandbox with its memory instead of deleting it.
- Warm clones at large scale. Useful for RL and evals: Pro runs 1,000 sandboxes at once and can copy one prepared sandbox into many warm clones.
- 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.
Use OpenAI Containers when
your app already calls OpenAI models and the model only needs to run short pieces of code or shell commands on files you give it.
- Built into the model call. Useful if your app already calls OpenAI models: one tool line in a request gives the model a place to run code.
- Nothing to run or clean up. There is no plan fee or machine to manage: a container bills by the minute and simply expires when the model stops using it.
- Locked-down network by default. Useful if code must reach only chosen hosts: Code Interpreter and Hosted Shell have no outbound access until an admin allows domains.
Where boat fits
If your agents do long, real work like installs, builds, Docker, emulators and running services, look at boat. It gives each agent a full VM with /dev/kvm, coding agents built in, keys kept outside the machine, and ports you can reach like a server, with no session cap on paid plans.
Run emulators and VMs inside
Tensorlake sandboxes set SANDBOX_KVM_AVAILABLE=0 and OpenAI documents no /dev/kvm or even sudo, so an Android emulator or a VM will not start on either. boat exposes /dev/kvm on every machine.
Coding agents built in, keys kept outside
On Tensorlake you install the agent yourself and secrets are injected into the sandbox it controls. OpenAI's managed harness is Codex only, in beta. boat preinstalls Claude Code, Codex and OpenCode, and a proxy keeps keys for any HTTPS API outside.
Reach it like a server
Tensorlake's proxy carries only HTTP, WebSocket and gRPC, so a database an agent starts cannot be reached, and OpenAI containers accept no inbound traffic at all. boat gives HTTPS URLs on 50 ports, raw TCP and SSH.
Use boat when your agents do real work for hours: installs, builds, Docker, emulators and a desktop, with coding agents built in, keys kept outside and ports you can reach. Compare it one to one: boat vs Tensorlake and boat vs OpenAI Containers.
Questions people ask
Is Tensorlake cheaper than OpenAI Containers?
Mostly, yes. One agent running all month is $250 on Tensorlake against $1,051 on OpenAI, and 50 agents in parallel is $1,030 against $11,405. For one coding agent on workdays OpenAI comes to $228 against $250, but it does not fully fit that scenario and model tokens are billed on top.
Which is faster, Tensorlake or OpenAI Containers?
There is no comparable measurement: neither is in the public CPU benchmark, and OpenAI does not publish vCPU per container size. Tensorlake says its default image starts in a few hundred milliseconds. boat scored 26.69 runs per second on that benchmark at 4 vCPU / 8 GB.
Can Tensorlake or OpenAI Containers run Docker?
Tensorlake runs Docker with root on its tensorlake/ubuntu-systemd image. OpenAI's hosted shell runs commands without sudo and documents no Docker support. boat gives root, systemd, Docker and /dev/kvm on every sandbox.
How long does a sandbox last on each?
An OpenAI container expires after 20 minutes without use, and its data is discarded. On Tensorlake Pro there is no duration cap, but an idle sandbox is suspended or ended after 600 seconds by default, and only named sandboxes keep their state. A boat sandbox has no session cap on paid plans and keeps its disk when it stops.
Can I open a web app running inside the sandbox?
On Tensorlake, yes, over HTTP, WebSocket or gRPC through its authenticated proxy. OpenAI containers have no ports, URLs or SSH. boat gives each sandbox HTTPS URLs for up to 50 ports, raw TCP and SSH.
Which one has GPUs?
Tensorlake offers GPU sandboxes by request, running on gVisor. OpenAI Containers and boat have no GPUs.
Try boat
Install the CLI, then run boat new.
7-day free trial