Tensorlake vs Ona
Tensorlake is a sandbox API: your code starts microVMs that can freeze their memory and wake up warm. Ona, formerly Gitpod and now part of OpenAI, is a cloud dev environment for engineers and its Codex agent, sold to new customers only through sales.
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
Ona
Ona, formerly Gitpod, is a platform for cloud dev environments and background coding agents, and is now part of OpenAI.
Ona is a different kind of product from bochka: a dev-environment platform, not a sandbox API. Each task or developer gets an isolated VM built from a Dev Container config, which people open in a browser IDE, VS Code or JetBrains, and where Ona's Codex Agent can plan, code, test and open pull requests. It is built for engineering teams who want the same governed environment for every developer and agent; new customers run it in their own AWS or GCP account on an Enterprise contract.
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 | Ona: 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 fully and Ona only as a compromise, since its SDK is Enterprise only; bochka adds /dev/kvm and preinstalled coding agents. | 5th cheapest of 367 $1,010 a month | 324th of 367, with limits $7,315 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Tensorlake keeps an idle agent's memory while it sleeps, Ona stops it after 30 idle minutes unless auto-stop is set to Never, and bochka keeps it on with no session cap. | 9th cheapest of 366 $1,381 a month | 83rd of 366, with limits $8,504 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 Tensorlake fits lots of one-minute runs best of the three, because bochka's start-rate limits queue big bursts and Ona is not built for it. | 24th cheapest of 345 $250 a month | 335th of 345, with limits $5,320 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 creates a sandbox per user through an API, while Ona is built for your own engineers; bochka also gives each sandbox HTTPS URLs and raw TCP. | 5th cheapest of 361 $471 a month | 330th of 361, with limits $5,988 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, with warm clones and 1,000 sandboxes at once on Pro; bochka's start-rate limits make it a compromise. | Cheapest of 360 $5,637 a month | 283rd of 360, with limits $9,773 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 | 334th of 364, with limits $5,768 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 Tensorlake and bochka start fresh build machines from code, and bochka's Ryzen 9 9950X hosts are the fastest measured; Ona starts each run from a prebuild. | 54th cheapest of 377 $424 a month | 365th of 377, with limits $5,461 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Ona is a full cloud IDE with Dev Containers and prebuilds, Tensorlake is built around suspending idle sandboxes, and bochka is a VM that stays on all day. | 185th of 368, with limits $250 a month | 368th of 368, with limits $5,140 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 over VNC and Ona has no graphical desktop, while bochka streams a 60fps desktop with Chromium. | 9th cheapest of 369 $294 a month | 353rd of 369, with limits $5,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 | 13th cheapest of 367 $250 a month | 150th of 367, with limits $5,346 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 | 146th of 346, with limits $5,468 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 | 261st of 338, with limits $14,360 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 | 93rd of 360, with limits $5,228 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 | Ona | bochka |
|---|---|---|---|
| Isolation | Firecracker and Cloud Hypervisor microVMs with their own kernel; GPU sandboxes use gVisor | An isolated VM per environment with dedicated compute, built from a Dev Container config | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Buying it | Self-serve: Free, prepaid Usage Credits packs from $5, Pro and Enterprise | New Core subscriptions are closed; new customers buy Enterprise through sales | Self-serve monthly plans from $20, all of it usage credit |
| Driving it from code | Sandboxes are created through an API on every plan | Python, TypeScript and Go SDK on the Enterprise plan only | API and SDK on every plan, including the trial |
| Docker and nested virtualization | Docker on the tensorlake/ubuntu-systemd image; no KVM (SANDBOX_KVM_AVAILABLE=0) | Docker and root inside the Dev Container; nested virtualization is not documented | Docker, root, systemd and /dev/kvm on every machine, so Android emulators and VMs run |
| Memory snapshots | Yes: suspend and memory snapshots keep running processes and restore warm | No: the disk persists across stops, processes do not | No: disk is kept, resume reboots the machine |
| Copy a running machine | Copy a running or suspended sandbox into N warm clones with memory | No environment copy; you can create a project from an environment's config | Fork a running sandbox into copies with its files |
| Files after a stop | Named sandboxes suspend, billed as snapshot storage; ephemeral ones end on timeout | Disk persists, billed on your cloud while stopped; Core archives a stopped environment after 3 days | Snapshots every minute and on stop; a stopped sandbox keeps its disk and costs nothing |
| Idle stop | Idle timeout, 600 s by default, then suspend or terminate | Stops after 30 minutes without SSH, IDE or agent activity by default; can be set to Never | Time-to-live (1 h by default, changeable or off); no idle timer and no session cap on paid plans |
| Desktop and computer use | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | Browser IDE plus VS Code and JetBrains; no graphical desktop inside the environment | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Coding agents | You bring and run your own agent on plain OS images | Codex Agent started from chat, a Linear issue or an automation; Claude Code you run yourself | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Stored secrets are injected into the sandbox | Secrets are injected as environment variables or files | AI credentials proxy for model providers and any HTTPS API you register; real keys never enter the machine |
| Reaching the machine | HTTP, WebSocket and gRPC through an authenticated proxy on exposed ports | HTTPS URL per port for you, your organization or everyone; SSH; no raw TCP documented | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP and a dedicated IP |
| GPUs | GPU sandboxes by request (H100 shown in the docs) | GPU instance types on Enterprise runners in your own cloud, such as one NVIDIA A10G | None |
| Where it runs | US and EU, or your own AWS, GCP, Azure, CoreWeave, Nebius or bare-metal account through BYOC | Enterprise runners in your own AWS or GCP account; Ona Cloud in Frankfurt and North Virginia for existing Core subscribers | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Tensorlake | Ona | 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 | Yes | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | 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 | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | 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 | No | No |
| Secret proxy | No | No | 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 | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | Yes | 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 | No | Yes |
| Audit logs | Not published | No | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
Neither Tensorlake nor Ona has a result on the hpc-sandbox-benchmarks CPU test, so there is no comparable speed measurement between them. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's run of 2026-09-29, on dedicated AMD Ryzen 9 9950X hosts. 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 Ona 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 | Ona, 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,030 · Enterprise (AWS Marketplace 12-month contract) · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Pro | $5,140 · Enterprise (AWS Marketplace 12-month contract) · 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 | $6,521 · Enterprise (AWS Marketplace 12-month contract) · 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 | $5,432 · Enterprise (AWS Marketplace 12-month contract) · 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 | $5,955 · Enterprise (AWS Marketplace 12-month contract) · 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 small users can buy prepaid packs from $5 instead.
Ona: New Core subscriptions are closed, so the prices here use Ona's Enterprise listing on AWS Marketplace: a 12-month, $60,000 contract, plus compute on your own AWS bill. Real Enterprise prices are negotiated with sales.
Ona: You pick a monthly plan from $20, and the whole fee 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, with 1,000 sandboxes at once, but its prepaid packs cap each sandbox at 4 vCPU / 16 GB and 24-hour sessions, and an ephemeral sandbox ends after 10 idle minutes by default. No Ona scenario fits as published, because a new customer can only buy Enterprise through sales, and the table assumes 3 environments at once since Ona publishes no Enterprise limit. On bochka the limit is how fast new machines start, so 1,000 short jobs at once gets queued and does not fit.
| Scenario | Tensorlake | Ona | 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 code fans out many short sandboxes, such as RL rollouts or evals, from one warm memory state, or you need GPUs or your own cloud account.
- Start today, from code. Useful if you want a sandbox API now: Tensorlake is self-serve, with a free tier and prepaid packs, while Ona goes through sales.
- Memory snapshots and warm clones. Useful when agents must pick up mid-process or fan out: Tensorlake saves a sandbox's memory and copies it into warm clones.
- Big bursts of sandboxes. Useful for RL rollouts and evals: Tensorlake Pro runs 1,000 sandboxes at once, each booting in a few hundred milliseconds.
Use Ona when
your engineers want a governed cloud IDE with Dev Containers, prebuilds and a Codex agent, inside your own AWS or GCP account.
- A full cloud IDE for your team. Useful if engineers work in the same environments as their agents: Ona has browser, VS Code and JetBrains IDEs.
- Dev Containers and prebuilds. Useful for big repos: Ona builds each environment from a Dev Container config and warms the filesystem with scheduled prebuilds.
- A managed Codex agent. Useful if you want an agent you do not wire up: Ona's Codex Agent starts from chat, a Linear issue or an automation.
Where bochka fits
If your code starts the agents and they do long, real work, look at bochka. Each sandbox is a full VM with /dev/kvm, a desktop and open ports, coding agents come preinstalled, and keys stay outside the machine. Unlike Ona it is self-serve with an API on every plan, and unlike Tensorlake a stopped machine keeps its disk for free.
Run emulators and VMs inside
Tensorlake sandboxes set SANDBOX_KVM_AVAILABLE=0 and Ona documents no nested virtualization, so an agent testing an Android app or booting a VM has nowhere to run it. Every bochka machine has /dev/kvm.
Keys that never enter the machine
Both Tensorlake and Ona inject secrets into the machine the agent controls, where one prompt injection can leak them. bochka's credentials proxy keeps real keys outside, and Claude Code, Codex and OpenCode come preinstalled.
Reach it like a server
Tensorlake's proxy carries only HTTP, WebSocket and gRPC, and Ona documents no raw TCP, so a database an agent starts cannot be reached. bochka gives HTTPS on up to 50 ports, raw TCP and a dedicated IP.
Use bochka when your code starts and drives the agents for hours: full VMs with /dev/kvm, a desktop and open ports, coding agents built in, keys kept outside and disks that stay free when stopped. Compare it one to one: bochka vs Tensorlake and bochka vs Ona.
Questions people ask
Is Tensorlake cheaper than Ona?
In every scenario we price, yes: one coding agent on workdays is $250 a month on Tensorlake Pro and $5,030 on Ona, and 50 agents in parallel are $1,030 against $6,521. Ona's price uses its Enterprise listing on AWS Marketplace, so a sales quote may differ. On bochka the same two scenarios are $20 and $317.
Which is faster, Tensorlake or Ona?
There is no comparable CPU measurement for either one. bochka scores 26.69 runs per second on the same Node.js benchmark, the fastest result measured. Tensorlake says its sandboxes boot in a few hundred milliseconds.
Can Tensorlake and Ona run Docker?
Yes. Tensorlake runs Docker on its tensorlake/ubuntu-systemd image, and Ona runs Docker with root inside the Dev Container. Neither offers nested virtualization, while bochka has Docker, systemd and /dev/kvm on every machine.
Is Ona the same as Gitpod?
Yes. Gitpod renamed itself Ona in 2025, moved toward background coding agents, and is now part of OpenAI. New Core subscriptions are no longer available, so new customers go through sales.
Can I run Claude Code on Tensorlake or Ona?
On both you install and run it yourself: Tensorlake's images are plain OS bases, and Ona's managed agent is Codex. bochka ships Claude Code, Codex, OpenCode and others preinstalled, with one API to prompt, steer and watch them.
Where do Tensorlake and Ona run?
Tensorlake runs in the US and the EU, and in your own cloud through BYOC. New Ona customers run Enterprise runners in their own AWS or GCP account. bochka runs only in the EU (Germany, Finland and France), with EU data residency.
Try bochka
Install the CLI, then run bochka new.
Product preview