Ona vs Agent 37
Ona, formerly Gitpod and now part of OpenAI, gives engineering teams cloud dev environments shared with its Codex agent, and new customers buy it through sales. Agent 37 hosts one always-on sandbox per agent behind one API, paid from a prepaid wallet by the minute.
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.
Agent 37
Agent 37 hosts AI agents, one isolated, always-on sandbox per user, behind one API.
You create an instance from a template (Hermes, OpenClaw, Claude Code, Codex, OpenCode, Pi, Grok or your own Docker image) and talk to it through a chat API, files, exec, SSH and HTTPS URLs. The default instance is a container enforced by gVisor; a VM type gives a full Linux machine with its own kernel for Docker, Kubernetes and Android emulators. It is built for companies that give each of their customers an agent.
- Where it runs
- Dedicated servers in the United States
- Instance types
- Default (shared), Performance (dedicated cores), VM
- Compliance
- SOC 2 Type I, Type II in progress
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 | Agent 37: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Agent 37 and bochka both fit fully; Docker on Agent 37 needs its VM type at 2.5 times the compute rate, and on Ona the SDK to start environments from code is Enterprise only. | 324th of 367, with limits $7,315 a month | 2nd cheapest of 367 $551 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Agent 37 ranks 1st here: it is built for one always-on assistant per user that sleeps when idle and wakes on the next message, while Ona stops a VM after 30 idle minutes unless auto-stop is set to Never. | 83rd of 366, with limits $8,504 a month | Cheapest of 366 $279 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 Agent 37 ranks 1st for short code runs on its small default sandboxes; bochka's start limits make large bursts a poor fit, and Ona is sold for people, not bursts. | 335th of 345, with limits $5,320 a month | Cheapest of 345 $22 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 bochka ranks 1st for handing machines to your users; Agent 37 tops out at 200 instances on self-serve, and Ona is built for your own engineers, with 10 running environments per user by default. | 330th of 361, with limits $5,988 a month | 30th of 361, with limits $79 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 | 6th of 360, with limits $363 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 | 90th of 364, with limits $58 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 Agent 37 and bochka both fit; Ona has no fork, so each run starts from a prebuild rather than a copy of a warm machine. | 365th of 377, with limits $5,461 a month | 2nd cheapest of 377 $84 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, Agent 37 is cheaper to keep idle, and bochka keeps a full VM with systemd and raw TCP. | 368th of 368, with limits $5,140 a month | 3rd cheapest of 368 $12 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 Agent 37 adds a noVNC desktop through a template build and bochka streams a 60fps desktop in every sandbox; Ona environments have no graphical desktop. | 353rd of 369, with limits $5,691 a month | Cheapest of 369 $53 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 | 48th of 367, with limits $29 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 | Cheapest of 346 $32 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 | 36th of 338, with limits $648 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 Agent 37 ranks 1st and bochka ranks 2nd; only bochka can fork one prepared machine into many while it runs. | 93rd of 360, with limits $5,228 a month | Cheapest of 360 $43 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 | Agent 37 | bochka |
|---|---|---|---|
| Kind of product | Cloud dev environments for engineering teams, shared with the Codex Agent | Hosted agent sandboxes, one isolated instance per agent behind one API | A sandbox you drive from code: full VMs for agents, with an API on every plan |
| Isolation | Each environment is an isolated VM with dedicated compute, built from a Dev Container config | gVisor by default; a full VM as an opt-in instance type | Every sandbox is a full VM with its own kernel |
| Docker and nested virtualization | Docker and root inside the Dev Container; nested virtualization is not documented | Docker and /dev/kvm only on the VM type, at 2.5x the default compute rate; no init system | Docker, root, systemd and /dev/kvm on every machine |
| Buying it | New Core subscriptions are closed; new customers buy Enterprise through sales | Self-serve prepaid wallet, metered per minute, no plan fee | Self-serve monthly plan from $20, all of it usage credit |
| Driving it from code | Python, TypeScript and Go SDK on the Enterprise plan only | One API with chat, files, exec, SSH and HTTPS URLs per instance | API and SDK on every plan, including the trial, with a prompt, steer and events API for coding agents |
| When idle | Stops after 30 minutes without SSH, IDE or agent activity by default; background work does not count; can be set to Never | Opt-in auto-sleep after a quiet period (default 15 minutes); memory is kept and it wakes on the next request | No idle timer; a time limit you set (default 1 hour), or no limit; a resume reboots the machine |
| Files after a stop | Disk persists; in your own cloud its storage stays on your bill; Core archives a stopped environment after 3 days | Disk kept, billed at $0.09 per GB a month even while stopped or asleep | Snapshots every minute and on stop; a stopped sandbox keeps its disk and costs nothing |
| Fork | No environment copy; you can create a project from an environment's config | No fork; daily backups plus one on-demand backup, restored in place only | Fork a running sandbox into copies with its files |
| Starting point | Dev Container config per repo, with prebuilds that snapshot the filesystem on a schedule | Templates such as Hermes, OpenClaw or Claude Code, or your own linux/amd64 Docker image | Named snapshots as shareable templates; no Dockerfile builds |
| Desktop and computer use | Browser IDE plus VS Code and JetBrains; no graphical desktop inside the environment | noVNC desktop through a template build or the Ubuntu VM template | 60fps desktop and Chromium in every sandbox, computer use, embeddable stream |
| Keeping keys out of the sandbox | Secrets are injected into the environment as environment variables or files | Managed models, search and Composio through a per-instance token; your own keys go in as env vars | Credentials proxy for model providers and any HTTPS API you register; switch to another account when credits run out |
| Reaching the sandbox | HTTPS URL per port and SSH; no raw TCP or public IP documented | HTTPS URL per port, signed URLs, custom domains; no public IP, SSH through a WebSocket tunnel | HTTPS URLs for up to 50 ports, raw TCP, dedicated IPv6 or IPv4 per machine |
| GPUs | GPU instance types on Enterprise runners in your own cloud, such as one NVIDIA A10G with 16 vCPU and 64 GB | None | None |
| Where it runs | Enterprise runners in your own AWS or GCP account, in many regions; Ona Cloud in Frankfurt and North Virginia for existing Core subscribers | Dedicated servers in the United States | EU only: Germany, Finland and France, with EU data residency |
Every feature Battleships tracks (43)
| Feature | Ona | Agent 37 | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | Yes | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | No | 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 | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | No | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | Yes | Yes | 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 | Yes | Yes |
| Audit logs | No | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Ona or Agent 37: 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. Agent 37 says its default instances share host resources and sells a Performance type on dedicated cores.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Ona and Agent 37 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 | Agent 37, 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 | $6 · Wallet (any top-up) | $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 | $12 · Wallet (any top-up) | $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 | $329 · Wallet ($100 lifetime top-ups) | $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 | $33 · Wallet ($250 lifetime top-ups) · 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 | $73 · Wallet ($250 lifetime top-ups) · 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), with compute on your own AWS bill. Real Enterprise prices are negotiated with sales.
Agent 37: A prepaid wallet with no plan fee, metered per minute: $0.80 per vCPU and $0.70 per GB of RAM a month while running, and $0.09 per GB of disk a month even while stopped or asleep. Performance compute costs 4x and VM compute 2.5x the default rate.
Agent 37: A monthly plan from $20, all of it usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
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. Agent 37's instance cap is 10 after a first top-up, 50 at $100 of total top-ups and 200 at $250, counting sleeping and stopped instances, so 300 user sandboxes and 1,000 short jobs at once do not fit. The 50-agent scenario needs Docker, so Agent 37 is priced on its VM type there. bochka is stopped only by its cap on starts in the 1,000-job burst.
| Scenario | Ona | Agent 37 | 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 browser, VS Code and JetBrains IDEs and prebuilds.
- Runs in your own cloud. Useful if environments must run inside your own AWS or GCP account, in the region you choose.
- GPU environments. Useful if your agents need a GPU: Enterprise runners can use GPU instance types, such as an A10G VM.
Use Agent 37 when
you host one mostly idle assistant per customer in the US that should sleep with its memory kept and wake on the next message.
- Sign up and pay by the minute. Useful if you want to start today: a prepaid wallet, no plan fee and no sales call, metered per minute.
- Sleeps when idle and keeps its memory. Useful for assistants that sit idle most of the day: an instance sleeps, keeps its memory and wakes on the next message.
- Bring a Dockerfile, pick dedicated cores. Useful if your setup lives in a Docker image: Agent 37 builds templates from it, and sells a Performance type on dedicated cores.
Where bochka fits
Ona is built for engineers in a shared IDE, and Agent 37 for many light assistants that mostly sleep. If your code starts agents that do hours of real work, installs, builds, Docker and emulators, look at bochka: every sandbox is a full VM, it forks while running, and it has an API on every plan.
A full VM is the default
Agents start databases, run Docker and boot emulators. Ona documents no /dev/kvm, and Agent 37's default gVisor type cannot run Docker; its VM type costs 2.5 times as much and has no systemd. bochka gives every machine all of it.
Fork a machine while it runs
Neither Ona nor Agent 37 can copy a running machine, so every parallel try rebuilds from a prebuild or from scratch. bochka forks the warm machine and saves the disk every minute.
Keys stay outside, for any API
On Ona secrets land in the environment as variables or files, and on Agent 37 your own keys sit inside as env vars, where a prompt injection can leak them. bochka's proxy keeps them outside for any HTTPS API.
Use bochka when your code starts agents that work for hours: Docker, systemd and /dev/kvm on a full VM, forks of running machines, a desktop, and keys kept outside for any API. Compare it one to one: bochka vs Ona and bochka vs Agent 37.
Questions people ask
Is Ona cheaper than Agent 37?
No. Using Ona's Enterprise listing on AWS Marketplace, one coding agent on workdays is $5,030 a month on Ona and $6 on Agent 37, and 50 agents in parallel are $6,521 on Ona against $329 on Agent 37. bochka comes to $20 and $317 for the same two scenarios.
Which is faster, Ona or Agent 37?
There is no comparable measurement for either one. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB on the benchmark we use. Agent 37 sells a Performance type on dedicated cores if you need steady speed.
Can Ona and Agent 37 run Docker?
Ona runs Docker with root inside the Dev Container. Agent 37 runs Docker only on its VM type, at 2.5 times the default compute rate; the default gVisor type cannot run a Docker daemon. bochka runs Docker in every sandbox.
Can I sign up for Ona or Agent 37 today?
Agent 37 is self-serve: add a card, top up the wallet and start. Ona's billing docs say new Core subscriptions are no longer available, so new customers go through sales. bochka's plans are self-serve, from a free trial up.
Where do Ona and Agent 37 run?
New Ona customers run Enterprise runners in their own AWS or GCP account, and Ona Cloud runs in Frankfurt and North Virginia for existing Core subscribers. Agent 37 runs on dedicated servers in the United States. bochka runs only in the EU, in Germany, Finland and France.
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.
Try bochka
Install the CLI, then run bochka new.
Product preview