CodeSandbox SDK vs Ona
CodeSandbox SDK is a self-serve API that starts Firecracker VMs from code, which hibernate with their memory and wake on the next request. Ona, formerly Gitpod and now part of OpenAI, is a cloud dev environment platform for engineers and its Codex Agent, sold through sales and run in your own AWS or GCP account.
The companies and products
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.
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. “46th cheapest of 345” means 45 of the other 344 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 | CodeSandbox SDK: 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 | 178th of 367, with limits $1,939 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 An always-on assistant on Ona needs auto-stop set to Never, because background work does not count as activity; on CodeSandbox SDK an idle VM hibernates after its timeout. | 215th of 366, with limits $2,478 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 CodeSandbox SDK fits short code runs well, with VMs that hibernate with their memory and wake on the next request, while Ona is a dev environment built for people, not quick bursts. | 46th cheapest of 345 $642 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 CodeSandbox SDK wakes a user's sandbox on their next HTTP request but caps Scale at 250 VMs at once, while Ona is built for your own engineers and defaults to 10 running environments per user. | 140th of 361, with limits $1,707 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 CodeSandbox SDK's memory forks let many rollouts branch from the same running state; Ona has no way to copy an environment. | 348th of 360, with limits $3,861 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 CodeSandbox SDK and bochka both fit evals fully, since you start and fork machines from code; on Ona the SDK to do that is Enterprise only. | 64th cheapest of 364 $1,335 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 CodeSandbox SDK and bochka can fork a warm machine for each run, while Ona has no fork and starts each run from a prebuild. | 92nd cheapest of 377 $860 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 the most complete dev box of the two, with Dev Containers, prebuilds and browser, VS Code and JetBrains IDEs; bochka is a full VM you reach over SSH, HTTPS or a desktop. | 310th of 368, with limits $240 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 Neither CodeSandbox SDK nor Ona has a graphical desktop inside the machine, while bochka streams a 60fps desktop with Chromium for computer use. | 206th of 369, with limits $691 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 | 251st of 367, with limits $443 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 | 281st of 346, with limits $508 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 | 193rd of 338, with limits $7,390 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 | 240th of 360, with limits $326 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 | CodeSandbox SDK | Ona | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | Isolated VM with dedicated compute, built from a Dev Container config | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Driving it from code | TypeScript SDK on self-serve plans, from the free Build plan up | Python, TypeScript and Go SDK on the Enterprise plan only; new customers go through sales | API and SDK on every plan, including the trial |
| Pause and resume | Hibernates with a memory snapshot and resumes with processes still running | Disk persists across stops; in your own cloud its storage is billed while stopped, and Core archives a stopped environment after 3 days | Disk saved every minute and on stop; a stopped sandbox costs nothing; resume boots the machine again |
| Fork | Fork a hibernated sandbox from its snapshot, or a running one sharing its memory | No environment copy; you can create a project from an environment's config | Fork a running sandbox with its disk |
| Wake on request | Yes; an HTTP request to a host wakes a hibernated VM | No | No; a stopped sandbox is started by API |
| Idle stop | Hibernates after an idle timeout of up to one day | Stops after 30 minutes without SSH, IDE or agent activity by default; background processes do not count; can be set to Never | Runs until you stop it; no session cap on paid plans |
| Docker and nested virtualization | Docker and root, built from any Dockerfile; nested virtualization not documented | Docker and root inside the Dev Container; nested virtualization not documented | Docker, root, systemd and /dev/kvm on every machine |
| Shell and IDE | Terminals, commands and files through the SDK; no SSH | Browser IDE, VS Code and JetBrains, plus SSH | SSH, plus exec and files over the API |
| Desktop and browser | No desktop; a headless Chromium template | No graphical desktop inside the environment | Linux desktop streamed at 60fps, Chromium and computer-use tools |
| Coding agents | Run your own agent through the command API | 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 API keys out of the sandbox | Secrets passed in as environment variables | Secrets injected as environment variables or files | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Inbound access | HTTPS host per port, public by default, signed tokens for private hosts; no raw TCP or public IP | HTTPS URL per port for you, your organization or everyone; SSH; no raw TCP or public IP documented | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; a dedicated IPv6 or IPv4 |
| GPUs | None | GPU instance types on Enterprise runners in your own cloud, such as one NVIDIA A10G with 16 vCPU and 64 GB | None |
| Regions and deployment | A country hint steers scheduling, for example to Europe, but placement is not guaranteed | Enterprise runners in your own AWS or GCP account in many regions; Ona Cloud in Frankfurt and North Virginia for existing Core subscribers | EU only: Germany, Finland and France |
Every feature Battleships tracks (43)
| Feature | CodeSandbox SDK | Ona | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | 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 | No | 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 | No | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | 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 | No | No | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for CodeSandbox SDK or Ona: neither was in the StarSling hpc-sandbox-benchmarks run we use. bochka did 26.69 Node.js runs per second in that run at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts, so we cannot say which of the two is faster.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. CodeSandbox SDK 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 | CodeSandbox SDK, 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 | $193 · Scale | $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 | $341 · Scale | $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 | $2,500 · Scale | $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 | $815 · Scale · with limits | $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,632 · Scale · with limits | $5,955 · Enterprise (AWS Marketplace 12-month contract) · with limits | $2,000 · $2000/mo · with limits |
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. The Scale plan adds a $170 monthly platform fee that is not usage credit, and a hibernated VM costs nothing.
Ona: New Core subscriptions are closed, so the Ona prices here use its Enterprise listing on AWS Marketplace: a 12-month, $60,000 contract (about $5,000 a month), plus the compute on your own AWS bill. Real Enterprise prices are negotiated with sales.
Ona: 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
CodeSandbox SDK's Scale plan allows 250 VMs at once, so 300 user sandboxes and 1,000 short jobs do not fit without Enterprise, and the price of disk beyond 20 GB is not published. No Ona scenario fits as published, because new customers can only buy Enterprise through sales, and Ona publishes no Enterprise concurrency limit, so the table assumes 3 environments at once. bochka fits every scenario but the 1,000-job burst, where even the $2,000 plan queues starts.
| Scenario | CodeSandbox SDK | Ona | 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 CodeSandbox SDK when
your code starts short-lived sandboxes that sleep between visits and should wake on the next HTTP request with their memory intact, and you are fine building on what Together now calls its legacy SDK.
- Memory hibernation and wake on request. For sandboxes that sleep between visits: an HTTP request wakes a hibernated VM with its processes still running.
- Forks that share memory. For branching many runs from one warm state, such as rollouts or test variants, without booting and setting up again.
- Self-serve sandbox API. For teams that want to start machines from code today: the SDK works on self-serve plans, with no sales call.
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. For engineers who work in the same environments as their agents: browser, VS Code and JetBrains IDEs with Dev Containers and prebuilds.
- Runs in your own cloud. For teams whose environments must run inside their own AWS or GCP account, in many regions.
- GPU environments. For agents that need a GPU: Enterprise runners can use GPU instance types, such as an A10G VM with 16 vCPU and 64 GB.
Where bochka fits
If what you are really running is agents that your code starts and drives, look at bochka. CodeSandbox SDK is a sandbox API built around VMs that hibernate, and Ona is a dev platform for people and its Codex Agent. bochka gives each agent a full machine with /dev/kvm, a desktop, open ports, preinstalled agents and a credentials proxy, on self-serve plans.
A whole machine with a screen
Neither CodeSandbox SDK nor Ona documents /dev/kvm or offers a graphical desktop, so Android emulators, nested VMs and computer-use agents cannot run. On CodeSandbox SDK you build a headless browser template yourself and still have no screen.
Work that is kept and forks while running
Ona stops an agent after 30 idle minutes unless set to Never, has no fork, and Core archives a stopped environment after 3 days. bochka saves the disk every minute, keeps a stopped sandbox for free and forks it while it runs.
Agents and keys driven from outside
Both put secrets inside the machine as environment variables, where one prompt injection can leak them. On CodeSandbox SDK you build the agent harness yourself, and Ona's managed agent is Codex with its SDK on Enterprise only.
Use bochka when your code starts and drives the agents: full VMs with /dev/kvm, a desktop and open ports, coding agents and a credentials proxy built in, on self-serve plans with machines that keep their work and fork while running. Compare it one to one: bochka vs CodeSandbox SDK and bochka vs Ona.
Questions people ask
Is CodeSandbox SDK cheaper than Ona?
In every scenario we priced, yes: one coding agent on workdays is $193 on CodeSandbox SDK against $5,030 on Ona, and 50 agents in parallel come to $2,500 against $6,521. Ona is priced from its Enterprise listing on AWS Marketplace, so a real quote may differ. On bochka the same two cost $20 and $317 a month.
Which is faster, CodeSandbox SDK or Ona?
We have no comparable CPU measurement for either. bochka did 26.69 Node.js runs per second at 4 vCPU / 8 GB in StarSling's benchmark run, on dedicated AMD Ryzen 9 9950X hosts.
Can CodeSandbox SDK and Ona run Docker?
Yes, both run Docker with root inside the machine: CodeSandbox SDK builds from any Dockerfile and Ona runs a Dev Container. Neither documents nested virtualization, while bochka exposes /dev/kvm for Android emulators and VMs.
Is CodeSandbox SDK still maintained?
CodeSandbox is now part of Together AI. Together's docs call the CodeSandbox-based SDK its legacy offering and name together-sandbox as its successor, while self-serve sign-up still runs through CodeSandbox.
Is Ona the same as Gitpod?
Yes. Gitpod renamed itself Ona in 2025 and moved toward background coding agents, and Ona is now part of OpenAI. New Core subscriptions are no longer available, so new customers go through sales.
Can I SSH into CodeSandbox SDK or Ona?
Ona supports SSH, along with its browser IDE, VS Code and JetBrains. CodeSandbox SDK connects through its SDK clients with terminals, commands and files, and no SSH. Every bochka sandbox has SSH as well as an exec and files API.
Try bochka
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs CodeSandbox SDK
- bochka vs Ona
- E2B vs CodeSandbox SDK
- Daytona vs CodeSandbox SDK
- Modal vs CodeSandbox SDK
- Vercel Sandbox vs CodeSandbox SDK
- Cloudflare Sandbox vs CodeSandbox SDK
- Blaxel vs CodeSandbox SDK
- Runloop vs CodeSandbox SDK
- Tensorlake vs CodeSandbox SDK
- Morph Cloud vs CodeSandbox SDK
- CodeSandbox SDK vs Northflank