Ona vs Together Code Sandbox
Ona, formerly Gitpod and now part of OpenAI, is a cloud dev environment platform for engineers and its Codex agent, sold through sales. Together Code Sandbox starts VMs from Docker-image snapshots on Together's AI cloud, can save their memory when they end, and must be turned on for your organization by Together.
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.
Together Code Sandbox
Together AI is a cloud for running and training AI models, and Code Sandbox is its product for running code in isolated VMs.
You build a snapshot from a Docker image or Dockerfile on Together's builder, then start sandboxes from it and run commands and file operations through the together-sandbox SDK or CLI. When a sandbox ends you can save its disk, and its memory too, as a new snapshot to start more sandboxes from. It is aimed at model-generated code, agent tool calls and reinforcement learning rollouts, and it must be enabled for your organization by Together. Together also sells Code Interpreter, a separate API that runs Python code in short sessions.
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 | Together Code Sandbox: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Ona gives each agent a VM with Docker in a Dev Container, Together's new SDK does not document Docker inside, and only bochka documents /dev/kvm for emulators and nested VMs. | 324th of 367, with limits $7,315 a month | 65th of 367, with limits $528 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, and Together sandboxes have no idle detection or wake on request, so your backend starts and stops them. | 83rd of 366, with limits $8,504 a month | 152nd of 366, with limits $1,095 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 Together's Code Interpreter suits short Python runs billed per 60-minute session; Ona is a dev environment, not a code runner. | 335th of 345, with limits $5,320 a month | 326th of 345, with limits $2,190 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 Ona is built for your own engineers, with a per-user default of 10 running environments, and on Together every port of a sandbox is public, while bochka gives each user token-protected HTTPS URLs. | 330th of 361, with limits $5,988 a month | 234th of 361, with limits $900 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 Together can save a sandbox with its memory and start many copies from it, which suits rollouts that branch from one warm state; Ona can only start new environments from a config or prebuild. | 283rd of 360, with limits $9,773 a month | 315th of 360, with limits $21,900 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 | 258th of 364, with limits $450 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 Neither Ona nor Together can copy a running machine, so each run starts from a prebuild or a snapshot; bochka can fork a warm sandbox while it runs. | 365th of 377, with limits $5,461 a month | 251st of 377, with limits $180 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Ona is the stronger dev box of the two, with browser, VS Code and JetBrains IDEs over Dev Containers; Together has no SSH, and bochka is a full VM you reach over SSH, HTTPS or a desktop. | 368th of 368, with limits $5,140 a month | 210th of 368, with limits $22 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 Together Code Sandbox has a graphical desktop to drive, while bochka streams a 60fps desktop with Chromium for computer use. | 353rd of 369, with limits $5,691 a month | 184th of 369, with limits $600 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 | 301st of 367, with limits $900 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 | 219th of 346, with limits $180 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 | 124th of 338, with limits $3,600 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 | 93rd of 360, with limits $5,228 a month | 167th of 360, with limits $150 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 | Together Code Sandbox | bochka |
|---|---|---|---|
| Kind of product | Cloud dev environments: an isolated VM per task or developer, built from a Dev Container config, with a Codex agent | A VM per sandbox, started from a Docker-image snapshot and driven through an SDK or CLI; plus a separate Python Code Interpreter API | A full VM with its own kernel per sandbox, driven from code, on dedicated AMD Ryzen 9 9950X hosts |
| Getting started | New Core subscriptions are closed; new customers buy Enterprise through sales | The VM SDK and CLI must be enabled for your organization by Together; Code Interpreter is self-serve from prepaid credits | Sign up and start a sandbox from the API, CLI or dashboard |
| Docker, root and systemd | Docker and root inside the Dev Container | Commands run as user 1000 by default, root on request; Docker inside not documented; Dev Containers and Docker Compose are not read | Docker, systemd and root on every machine |
| Nested virtualization | Not documented on its VM classes | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Shell and IDE access | SSH, a browser IDE, VS Code and JetBrains | Commands, interactive shells and files through the SDK and CLI; no SSH | SSH, plus exec and files over the API |
| Files after a stop | The disk persists across stops; in your own cloud its storage is billed while stopped, and Core archives a stopped environment after 3 days | End a sandbox with a snapshot of its disk to start new sandboxes from | Disk saved every minute and on stop; a stopped sandbox keeps its disk and costs nothing |
| Memory snapshots | None; prebuilds snapshot the filesystem on a schedule | Save disk and memory when a sandbox ends; new sandboxes resume with their processes running | None; resume boots the machine again |
| Fork | No environment copy; you can create a project from an environment's config | No live fork: the parent ends, then you start many sandboxes from its snapshot | Fork a running sandbox into copies with its files; the original keeps running |
| Idle stop | Stops after 30 minutes without SSH, IDE or agent activity by default; background work does not count; can be set to Never | Time to live counts from creation; no idle detection and no wake on request | Runs until you stop it; no session cap on paid plans |
| Driving it from code | Python, TypeScript and Go SDK on the Enterprise plan only | together-sandbox SDK and CLI, once Together enables them | API and SDK on every plan, including the trial |
| Coding agents | Codex Agent started from chat, a Linear issue or an automation; Claude Code you run yourself | Run your own agent through execs; a Harbor guide for agent evals | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Reaching the sandbox | HTTPS URL per port for you, your organization or everyone; no raw TCP or public IP documented | All ports public; preview URLs coming soon; an experimental inbound allowlist by IP or token | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv6 or IPv4 |
| Desktop and computer use | No graphical desktop inside the environment | None; headless command and file access only | Linux desktop streamed at 60fps, Chromium and computer-use tools |
| GPUs | GPU instance types on Enterprise runners in your own cloud, such as one NVIDIA A10G with 16 vCPU and 64 GB | None in the sandbox | None |
Every feature Battleships tracks (43)
| Feature | Ona | Together Code 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 | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | 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 | No | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | No | Yes | 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 | Yes | Yes |
| Audit logs | No | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | No | No |
| EU data residency | Yes | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Ona or for Together Code Sandbox: neither was in the public benchmark runs we use. 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 Together Code 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 | Together Code 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 | $5 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · 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 | $22 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · 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 | $264 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · 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 | $900 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · 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 | $6,000 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $2,000 · $2000/mo · with limits |
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, which runs on your own AWS bill. Real Enterprise prices are negotiated with sales.
Together Code Sandbox: Together lists Code Sandbox at $0.0446 per vCPU-hour and $0.0149 per GiB-hour, but the VMs must be enabled for your organization, so the table prices Code Interpreter: $0.03 per 60-minute session from prepaid credits, with a $5 minimum.
Together Code Sandbox: Plans start at $20 a month, 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
No Ona or Together scenario fits as published. Ona sells new customers only Enterprise through sales and publishes no concurrency limit, so the table assumes 3 environments at once, as on its old free plan. The Together column is Code Interpreter: sessions last 60 minutes, nothing is kept after a session, it runs only Python and its machine size is not published. On bochka the limit that bites is starts, so 1,000 short jobs at once get queued and need more starts per day than the $2,000 plan allows.
| Scenario | Ona | Together Code 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: browser, VS Code and JetBrains IDEs with Dev Containers and prebuilds.
- Runs in your own cloud. Useful if environments must run inside your own AWS or GCP account: Ona's Enterprise runners provision them there, in many regions.
- GPU environments. Useful if your agents need a GPU: Ona's Enterprise runners can use GPU instance types, such as an A10G VM with 16 vCPU and 64 GB.
Use Together Code Sandbox when
you already run models on Together and want light sandboxes you can save with their memory and branch from, or a simple Python runner billed per session.
- Memory snapshots to branch from. Useful for rollouts and test variants: save a sandbox with its memory and start many copies with processes still running.
- Sandboxes next to your models. Handy if you already run inference or fine-tuning on Together: sandboxes and models share one account and API key.
- Very small machines and a Python runner. Good for many light jobs: sandboxes start at a tenth of a core, and a self-serve Python interpreter API bills per session.
Where bochka fits
If what you are really running is agents started from your own code, neither is easy to get: Ona sells new customers Enterprise through sales, and Together has to switch its VMs on for you. bochka is a full VM you can sign up for today, with Docker, /dev/kvm, a desktop, open ports and coding agents built in.
A whole machine on every plan
Ona's SDK is Enterprise only and documents no /dev/kvm; Together's VMs need enabling, run commands as a normal user and document neither Docker inside nor nested virtualization. bochka has root, systemd, Docker and /dev/kvm on every plan.
Work that survives and forks while running
Ona cannot copy an environment, and a stopped disk stays on your cloud bill or is archived after 3 days on Core. Together forks only after the parent ends. bochka saves every minute, stops for free and forks a running sandbox.
Desktop, ports and keys built in
Neither has a desktop for computer use. Ona has no raw TCP and injects secrets as variables; Together makes every port public and has no credentials proxy. bochka streams a 60fps desktop, token-protects 50 HTTPS ports and keeps keys outside the sandbox.
Use bochka when your code starts and drives the agents: full VMs with Docker and /dev/kvm, a desktop and open ports, an API on every plan, and machines that keep their work and fork while running. Compare it one to one: bochka vs Ona and bochka vs Together Code Sandbox.
Questions people ask
Is Ona cheaper than Together Code Sandbox?
Together usually looks cheaper, but neither fits our scenarios as published. Ona is priced from its Enterprise contract and Together from Code Interpreter, which ends sessions after 60 minutes and keeps no disk: 50 agents in parallel come to $264 against $6,521 on Ona, and 300 user sandboxes to $900 against $5,432. On bochka, which fits both, they are $317 and $200 a month.
Which is faster, Ona or Together Code Sandbox?
We cannot say: neither was in the public CPU benchmark runs we use. 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.
Can Ona or Together Code Sandbox run Docker?
Ona gives you Docker and root inside the Dev Container. Together builds sandboxes from Docker images, but its new SDK runs commands as user 1000 by default and does not document Docker inside a sandbox. Neither documents /dev/kvm, which bochka has on every machine along with Docker and systemd.
Can I sign up for either today?
Not for the VMs. Ona's new Core subscriptions are closed and new customers go through sales, and Together's VM SDK must be enabled for your organization. Together's Code Interpreter is self-serve from prepaid credits, with a $5 minimum, and bochka's plans are self-serve from a free trial up.
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.
Can either save a sandbox with its memory?
Together can: when a sandbox ends it can save disk and memory, and new sandboxes come back with their processes running. Ona's prebuilds snapshot only the filesystem. bochka saves the disk every minute and on stop, so resuming boots the machine again, but it can fork a sandbox while it runs.
Try bochka
Install the CLI, then run bochka new.
Product preview