Runloop vs Ona
Runloop is a sandbox platform you drive from code, with devboxes for building, running and testing AI coding agents. Ona, formerly Gitpod and now part of OpenAI, is a cloud dev environment for engineers and its Codex agent, and new customers buy it only through sales.
The companies and products
Runloop
Runloop is a US platform of sandboxes, called devboxes, for building, running and testing AI coding agents.
You get Linux devboxes built from Dockerfile-style blueprints, disk snapshots, HTTPS tunnels, agent gateways that hide API keys, and Axons, event streams that drive agents such as Claude Code. Each devbox runs in a micro-VM on Runloop's own bare-metal hypervisor, with a container layer inside. It is built for teams shipping coding agents, plus evaluation and RL fine-tuning work on the Enterprise plan.
- Compliance
- SOC 2 Type 2
- Architectures
- x86_64 and arm64 base blueprints
- Own-cloud deploy
- Deploy to VPC on AWS, GCP and Azure (Enterprise)
- Regions
- Not documented or selectable
- Company
- Runloop AI, Inc.
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. “20th cheapest of 367” means 19 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 | Runloop: 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 Runloop fits fully and ranks 20th; Ona is a compromise because its SDK is Enterprise only and nested virtualization is not documented; bochka ranks 3rd with /dev/kvm on every machine. | 20th cheapest of 367 $8,152 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 Runloop can suspend an idle devbox and wake it on an HTTP request (Pro plan), while an always-on agent on Ona needs auto-stop set to Never, because background work does not count as activity. | 32nd cheapest of 366 $10,194 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 Runloop ranks 44th here, well ahead of bochka and Ona, because it starts big waves of short runs without published start limits, while bochka's start limits queue very large bursts. | 44th cheapest of 345 $525 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 Runloop fits; Ona is built for your own engineers, not for handing machines to your users, and its per-user policy defaults to 10 running environments. | 26th cheapest of 361 $3,301 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 Runloop ranks 4th for RL rollouts: it starts large waves without published start limits and sells RL fine-tuning on Enterprise. | 4th cheapest of 360 $15,922 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 | 81st cheapest of 364 $2,562 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 bochka's faster CPUs finish builds sooner than Runloop's, and Ona has no fork, so each run starts from a prebuild instead of a warm machine. | 121st cheapest of 377 $1,554 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 for people; Runloop has no public IP or raw TCP; bochka is a full VM you reach over SSH, HTTPS or a desktop. | 113th cheapest of 368 $410 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 Runloop and bochka both ship a desktop and a browser an agent can control, and bochka streams it at 60fps; Ona environments have no graphical desktop. | 39th cheapest of 369 $2,306 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 | 40th cheapest of 367 $1,153 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 | 68th cheapest of 346 $781 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 | 266th of 338, with limits $15,611 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 | 10th cheapest of 360 $770 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 | Runloop | Ona | bochka |
|---|---|---|---|
| Kind of product | Sandbox platform of devboxes for building, running and testing AI coding agents | Cloud dev environment platform for engineers and its Codex agent | Sandbox API: full VMs for agents, driven from code |
| Isolation | Micro-VM on a custom bare-metal hypervisor, plus a container layer | Isolated VM per environment, built from a Dev Container config | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker and nested virtualization | Docker on the Docker-in-Docker blueprints, as root; nested virtualization not documented | Docker and root inside the Dev Container; nested virtualization not documented | Docker, root, systemd and /dev/kvm on every machine, so Android emulators and VMs run inside |
| Driving it from code | API and SDKs, from the usage-only Basic plan with no sales call | Python, TypeScript and Go SDK on the Enterprise plan only | API and SDK on every plan, including the trial |
| Keeping files | Disk kept through suspend (Pro plan) or manual disk snapshots; shutdown ends the devbox | Disk persists across stops; in your own cloud it is billed while stopped, and Core archives a stopped environment after 3 days | Snapshot every minute and on stop, on every plan; a stopped sandbox keeps its disk and costs nothing |
| Copies of a machine | New devboxes from disk snapshots, files only | No environment copy; you can create a project from an environment's config | Fork a running sandbox into copies with its files |
| Long runs and idle stop | Fixed lifetime 1 hour by default, 48 hours max; an idle policy replaces it, with suspend and wake on HTTP on Pro | Stops after 30 minutes without SSH, IDE or agent activity by default; background processes do not count; can be set to Never | No session cap on paid plans; default TTL 1 hour, changeable |
| Desktop and computer use | Desktop and browser an agent can control | Browser IDE, VS Code and JetBrains; no graphical desktop inside the environment | 60fps desktop with Chromium, computer use and browser control, embeddable stream |
| Reaching the sandbox | One HTTPS tunnel per devbox; SSH through a TLS proxy; no public IP | HTTPS URL per port; SSH; no raw TCP or public IP documented | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Egress rules | Hostname allowlist with wildcards, or block all | No egress allowlist documented | Open internet, no provider-side allowlist |
| Keeping keys out of the sandbox | Agent gateways for any API endpoint with bearer, header or basic auth | Secrets injected as environment variables or files | AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Claude Code, Codex, OpenCode, Gemini CLI and DeepAgents, driven through Axons and Broker | Codex Agent 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 |
| Where it runs | Regions not documented; Deploy to VPC on AWS, GCP or Azure (Enterprise) | 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, France), with EU data residency |
| GPUs | None | GPU instance types on Enterprise runners, such as one NVIDIA A10G with 16 vCPU and 64 GB | None |
Every feature Battleships tracks (43)
| Feature | Runloop | 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 | 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 | 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 | 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 | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | Yes | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | No | Yes | No |
| Windows | No | No | No |
| Arm64 | Yes | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Yes | 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 | Not published | No | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
On the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB (run 36498291449, 2026-09-29), bochka scored 26.69 runs a second and Runloop 8.29, about 3.2 times apart. There is no comparable measurement for Ona: it was not in the benchmark runs we use. The test measures CPU work only, not start time or network speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Ona has 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 | Runloop, 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 | $113 · Basic | $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 | $429 · Basic | $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 | $5,268 · Basic | $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 | $1,441 · Basic | $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 | $3,184 · Basic | $5,955 · Enterprise (AWS Marketplace 12-month contract) · with limits | $2,000 · $2000/mo · with limits |
Runloop: Runloop bills per second for the CPU and memory you allocate, and bills disk for a devbox's whole life. Basic has no plan fee; Pro adds $250 a month that is not usage credit and unlocks suspend and resume.
Ona: New Core subscriptions are closed, so Ona prices here use its 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: Plans start at $20 a month and the whole fee is usage credit, billed per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
No Ona scenario fits as published: new customers can only buy Enterprise through sales, and since Ona publishes no Enterprise concurrency limit, the table assumes 3 environments at once. Runloop fits every scenario on Basic, but publishes no egress price, tops out disk at 64 GiB and caps a fixed lifetime at 48 hours unless an idle policy replaces it. bochka fits all but 1,000 short jobs at once, where its start limits queue the burst.
| Scenario | Runloop | 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 Runloop when
you want a self-serve sandbox API for coding agents today, with hostname allowlists, arm64, or very large bursts of short jobs.
- Self-serve sandbox API. Useful if you want to start building today: Runloop's Basic plan is usage only, with an API and no sales call.
- Lock down the network. Useful if a sandbox must only reach a fixed list of hosts: Runloop allows listed hostnames, with wildcards, or blocks everything.
- Big bursts and arm64. Useful for waves of short jobs or RL rollouts: Runloop publishes no start limits, and it offers arm64 devboxes too.
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: Ona has browser, VS Code and JetBrains IDEs with prebuilds.
- Runs in your own cloud. Useful if environments must run inside your own AWS or GCP account, in many regions: Ona's Enterprise runners do that.
- GPU environments. Useful if your agents need a GPU: Ona's Enterprise runners can use GPU instance types, such as an A10G VM.
Where bochka fits
If what you are really running is agents that install, build, test and serve things for hours, look at bochka. Each sandbox is a full VM with /dev/kvm, a desktop and open ports, its disk is saved every minute, and it ran 3.2 times faster than Runloop on the same CPU benchmark. You drive it from code on every plan, with no sales call.
A full Linux machine
Neither Runloop nor Ona documents /dev/kvm, so Android emulators and VMs do not start, and both reach sandboxes over HTTPS only, so raw TCP servers have no way in. Ona also has no desktop for computer-use agents.
Work kept, forks while running
On Runloop a devbox is gone after shutdown unless you pay $250-a-month Pro for suspend or write snapshot code. On Ona a stopped disk stays on your cloud bill, and nothing copies a warm environment.
Agents that run as long as you want
Runloop's fixed lifetime tops out at 48 hours unless you set an idle policy. Ona stops a VM after 30 idle minutes and ignores background work, so a busy agent stops unless auto-stop is set to Never.
Use bochka when your code starts and drives agents that do real work for hours: full VMs with /dev/kvm, a desktop and open ports, faster CPUs, and machines that keep their work and fork while running. Compare it one to one: bochka vs Runloop and bochka vs Ona.
Questions people ask
Is Runloop cheaper than Ona?
In every scenario we priced, yes. One coding agent on workdays is $113 a month on Runloop and $5,030 on Ona, using Ona's Enterprise listing on AWS Marketplace, and one agent running all month is $429 against $5,140. On bochka those are $20 and $26 a month.
Which is faster, Runloop or Ona?
We can only compare Runloop: it ran 8.29 Node.js build-and-test loops a second at 4 vCPU / 8 GB, and Ona was not in the benchmark. bochka ran 26.69 on the same test.
Can Runloop and Ona run Docker?
Yes. Runloop runs Docker on its Docker-in-Docker blueprints as root, and Ona runs Docker with root inside the Dev Container. Neither documents nested virtualization; bochka exposes /dev/kvm, so Android emulators and VMs run inside.
Can I sign up for Ona like I can for Runloop?
No. Ona's billing docs say new Core subscriptions are no longer available, so new customers go through sales. Runloop's Basic plan is usage only with no plan fee, and bochka's plans are self-serve from a free trial up.
Can I run Claude Code on Runloop or Ona?
Runloop drives Claude Code, Codex, OpenCode and others through Axons. Ona's managed agent is Codex, and you install and run Claude Code yourself. bochka ships Claude Code, Codex, OpenCode and more preinstalled, with one API to prompt, steer and watch them.
Can I run Runloop or Ona in my own cloud?
Yes, on Enterprise for both: Runloop deploys into your AWS, GCP or Azure account, and Ona's runners provision environments in your AWS or GCP account. bochka runs only on its own hosts in the EU.
Try bochka
Install the CLI, then run bochka new.
Product preview