Ona vs Deno Sandbox
Ona, formerly Gitpod and now part of OpenAI, gives engineering teams and its Codex agent full cloud dev environments, sold through sales. Deno Sandbox runs short, locked-down pieces of code in 2 vCPU Firecracker microVMs that start in under 200 ms and live up to 30 minutes.
The companies and products
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.
Deno Sandbox
Deno Sandbox is part of Deno Deploy, the hosting platform from the company behind the Deno runtime, and runs untrusted or AI-generated code in Linux microVMs.
Each sandbox is a Firecracker microVM with 2 vCPU, up to 4 GB of memory and a 10 GB disk that is wiped when it ends, created from a TypeScript or Python SDK. Outbound traffic goes through a proxy that can enforce a host allowlist and swap placeholder secrets for real ones. It is built for short runs of agent or user code, and a sandbox can be promoted to a Deno Deploy app.
- Isolation
- Firecracker microVM per sandbox
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. “324th cheapest of 367” means 323 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 | Ona: price rank | Deno Sandbox: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory runs builds and Docker for hours: Deno stops a sandbox after 30 minutes on 2 vCPU, Ona needs an Enterprise contract for its SDK, and bochka fits fully. | 324th of 367, with limits $7,315 a month | 290th of 367, with limits $5,665 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant on Ona needs auto-stop set to Never, while a Deno sandbox ends after 30 minutes and wipes its disk; bochka keeps the machine and its files. | 83rd of 366, with limits $8,504 a month | 287th of 366, with limits $5,803 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 Deno Sandbox suits short code runs best of the three: it starts in under 200 ms and bills CPU only while code is running. | 335th of 345, with limits $5,320 a month | 141st of 345, with limits $329 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 Deno can give each user a sandbox but caps Builder at 20 at once per region, Ona is built for your own engineers, and bochka's plans go to hundreds of sandboxes. | 330th of 361, with limits $5,988 a month | 148th of 361, with limits $1,863 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 | 283rd of 360, with limits $9,773 a month | 122nd of 360, with limits $7,963 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 | 334th of 364, with limits $5,768 a month | 296th of 364, with limits $1,563 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 jobs that build Docker images or start emulators need Docker and /dev/kvm; Ona has Docker in a Dev Container, Deno documents neither, and bochka has both. | 365th of 377, with limits $5,461 a month | 304th of 377, with limits $731 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, while Deno's 30-minute lifetime rules out a dev box; bochka is a full VM that stays up. | 368th of 368, with limits $5,140 a month | 179th of 368, with limits $200 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 Neither Ona nor Deno Sandbox has a graphical desktop, while bochka streams a 60fps desktop with Chromium for computer use. | 353rd of 369, with limits $5,691 a month | 280th of 369, with limits $1,583 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 | 150th of 367, with limits $5,346 a month | 284th of 367, with limits $783 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 | 146th of 346, with limits $5,468 a month | 286th of 346, with limits $573 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 | 261st of 338, with limits $14,360 a month | 247th of 338, with limits $11,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 bochka can fork one prepared machine into many while it runs; Ona starts new environments from a config or prebuild, and Deno boots new sandboxes from a volume snapshot. | 93rd of 360, with limits $5,228 a month | 251st of 360, with limits $367 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 | Ona | Deno Sandbox | bochka |
|---|---|---|---|
| Kind of product | Cloud dev environments for engineers and the Codex agent, with browser, VS Code and JetBrains IDEs | A sandbox API for short runs of untrusted or AI-generated code, part of Deno Deploy | A sandbox API for agents: full VMs you create, fork and drive from code |
| Isolation | An isolated VM per environment, built from a Dev Container config | Firecracker microVM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | VM classes in your own cloud, such as 4 vCPU / 16 GiB | 2 vCPU fixed, 768 MB to 4 GB memory, 10 GB disk | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB on the $100 plan and above |
| Session length | No hard cap; stops after 30 idle minutes by default, background work does not count, can be set to Never | Up to 30 minutes; longer work can be promoted to a Deno Deploy app | No cap on paid plans; you set the time to live |
| Files after a stop | Disk persists, billed on your cloud while stopped; Core archives a stopped environment after 3 days | Root disk wiped when the sandbox ends; opt-in volumes of 300 MB to 20 GB, Chicago only | Whole disk saved every minute and on stop; a stopped sandbox costs nothing |
| Fork and snapshots | Prebuilds snapshot the filesystem on a schedule; no copy of an environment | Read-only volume snapshots that new sandboxes boot from; no fork of a running sandbox | Automatic disk snapshots; fork a running sandbox with its files |
| Docker and nested virtualization | Docker and root inside the Dev Container; nested virtualization not documented | Root access; Docker and nested virtualization not documented | Docker, root, systemd and /dev/kvm on every machine |
| Desktop and computer use | IDEs only; no graphical desktop | No desktop; a VS Code editor in the browser and SSH | 60fps Linux desktop with Chromium, computer use and browser control |
| Driving it from code | Python, TypeScript and Go SDK on the Enterprise plan only | TypeScript and Python SDK on Pro and Builder | API and SDK on every plan, including the trial |
| Coding agents | Codex Agent from chat, a Linear issue or an automation; Claude Code you run yourself | A root image with Claude Code, run through the shell command API | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Outbound rules and secrets | Secrets injected as environment variables or files; no outbound allowlist | Host allowlist per sandbox, and placeholder secrets swapped for real ones at a proxy outside the VM | Credentials proxy for model providers and any HTTPS API; open internet, no provider-side allowlist |
| Inbound access | HTTPS URL per port for you, your organization or everyone; SSH; no raw TCP | HTTPS URL per exposed port, public without authentication; SSH | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Start time | Starts a VM from a Dev Container config or prebuild | Under 200 ms | Boots a full VM |
| GPUs and regions | GPU instance types such as an A10G; runs in your own AWS or GCP account in many regions | No GPUs; Amsterdam and Chicago | No GPUs; EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Ona | Deno Sandbox | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | Yes | 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 | Yes | Yes | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | No | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Ona or Deno Sandbox: neither is in the StarSling hpc-sandbox-benchmarks runs we use, and Deno's fixed 2 vCPU shape could not run the 4 vCPU test as set up. 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.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Ona and Deno Sandbox 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 | Ona, a month | Deno Sandbox, 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 | $5,030 · Enterprise (AWS Marketplace 12-month contract) · with limits | $53 · Pro · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $5,140 · Enterprise (AWS Marketplace 12-month contract) · with limits | $200 · Builder · 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 | $6,521 · Enterprise (AWS Marketplace 12-month contract) · with limits | $2,779 · Builder · 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 | $5,432 · Enterprise (AWS Marketplace 12-month contract) · with limits | $783 · Builder · 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 | $5,955 · Enterprise (AWS Marketplace 12-month contract) · with limits | $1,563 · Builder · with limits | $2,000 · $2000/mo · with limits |
Ona: New Core subscriptions are closed, so Ona is priced here from its Enterprise listing on AWS Marketplace: a 12-month, $60,000 contract, with the compute on your own AWS bill. Real Enterprise prices are negotiated with sales.
Deno Sandbox: Sandboxes need Pro at $20 a month or Builder at $200 a month, which include CPU, memory and egress allowances shared with Deno Deploy apps. Past those, CPU is $0.10 per hour of active CPU time and memory $0.025 per GiB-hour for the whole life of the sandbox.
Deno Sandbox: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Neither Ona nor Deno Sandbox fits any of the five scenarios as published. Ona can only be bought on an Enterprise contract through sales, and with no published Enterprise concurrency the table assumes 3 environments at once. Deno caps a sandbox at 30 minutes and 2 vCPU / 4 GiB, and Builder at 20 at once per region, so the workday agent, the always-on agent and 50 agents in parallel do not fit. bochka fits four of the five; at 1,000 short jobs at once its top plan queues starts above 90 a minute.
| Scenario | Ona | Deno Sandbox | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Ona when
your engineers want a governed cloud IDE shared with a Codex agent, inside your own AWS or GCP account or with a GPU.
- A full cloud IDE for your team. Useful if your engineers work in the same environments as their agents, with Dev Containers, prebuilds and browser, VS Code or JetBrains IDEs.
- Runs in your own cloud. Useful if environments must run inside your own AWS or GCP account, in regions well beyond Deno's Amsterdam and Chicago.
- Bigger machines and GPUs. Useful if an agent needs more than 2 vCPU and 4 GB, or a GPU such as an A10G on a 16 vCPU VM.
Use Deno Sandbox when
you run short pieces of untrusted code that must start in milliseconds and reach only the hosts you allow, especially if you already deploy on Deno Deploy.
- Fast starts for short runs. Good for short bursts of code: a sandbox starts in under 200 ms and CPU bills only while code runs.
- Locked-down outbound traffic. Useful for untrusted code: each sandbox can be limited to a list of hosts, enforced by a proxy outside the VM.
- Self-serve, with a path to Deno Deploy. Fits teams who want to sign up and start today, and whose sandbox code can go live as a Deno Deploy app.
Where bochka fits
Ona is built around people working in IDEs, and Deno Sandbox around code that runs for seconds or minutes. If what you are really running is agents started from your own code that work for hours, need Docker or a screen, and come back to their files tomorrow, bochka is built for that middle ground.
A machine that stays, and forks
A Deno sandbox ends at 30 minutes and wipes its root disk, and an Ona environment keeps its disk but bills storage while stopped and cannot be copied. bochka saves the disk every minute, stops for free and forks while running.
An API for agents on every plan
Ona's SDK needs an Enterprise contract through sales, and Deno runs Claude Code only through shell commands you parse yourself. bochka has an API on every plan and drives Claude Code, Codex and others with prompt, steer and events.
Nested virtualization, a desktop and open ports
Neither documents /dev/kvm or a graphical desktop, and neither offers raw TCP, so emulators, microVMs, computer use and game servers are out. bochka has all of them, plus HTTPS on up to 50 token-protected ports.
Use bochka when your code starts and drives agents that work for hours: full VMs with Docker, /dev/kvm, a desktop and open ports, an API on every plan, and disks that keep their work and fork while running. Compare it one to one: bochka vs Ona and bochka vs Deno Sandbox.
Questions people ask
Is Ona cheaper than Deno Sandbox?
No, in every scenario we priced Deno Sandbox comes out lower, because Ona is sold on an Enterprise contract: one agent running all month is $5,140 on Ona and $200 on Deno Builder, and 300 user sandboxes $5,432 against $783. Neither fits those scenarios as published; bochka comes to $26 and $200.
Which is faster, Ona or Deno Sandbox?
Neither is in the CPU benchmark we use, so there is no fair speed comparison. Deno says a sandbox starts in under 200 ms but is fixed at 2 vCPU, while Ona can run bigger VM classes in your own cloud. bochka did 26.69 runs per second at 4 vCPU / 8 GB.
Can Ona or Deno Sandbox run Docker?
Ona runs Docker with root inside its Dev Container, but documents no nested virtualization. Deno's docs mention root access but not Docker or nested virtualization. bochka runs Docker and systemd and exposes /dev/kvm on every machine.
How long can a session run?
A Deno sandbox lives up to 30 minutes, and longer work has to be promoted to a Deno Deploy app. Ona has no hard cap but stops an environment after 30 idle minutes by default unless auto-stop is set to Never. bochka has no session cap on paid plans.
Can I sign up for Ona today?
Not self-serve. Ona's billing docs say new Core subscriptions are no longer available, so new customers go through sales for Enterprise. Deno Sandbox is self-serve on Pro or Builder, and bochka's plans are self-serve from a free trial up.
Is bochka SOC 2 compliant?
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