exe.dev vs Ona
exe.dev rents Linux VMs you sign up for yourself and reach over SSH and HTTPS, with Claude Code and Codex preinstalled. Ona, formerly Gitpod and now part of OpenAI, is a cloud IDE platform for engineering teams and its Codex agent, which new customers buy through sales and run in their own AWS or GCP account.
The companies and products
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
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. “15th cheapest of 366” means 14 of the other 365 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 | exe.dev: 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 Both run builds and Docker, but neither has a desktop to check a UI or snapshots to roll back a bad agent step; bochka ranks 3rd with both. | 253rd of 367, with limits $3,701 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 exe.dev ranks 15th for always-on assistants because its VMs run until you stop them; on Ona an agent needs auto-stop set to Never, since background work does not count as activity. | 15th cheapest of 366 $3,833 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 None of the three is built as a code interpreter, and all rank low for many tiny runs. | 235th of 345, with limits $175 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 Neither is built to hand machines to your users: exe.dev Personal stops at 50 VMs at once, and Ona's per-user policy defaults to 10 running environments. | 257th of 361, with limits $1,226 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 | 265th of 360, with limits $5,250 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 | 283rd of 364, with limits $1,050 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 exe.dev standalone VMs bill per second, which suits CI better than Ona's Enterprise contract, and bochka ranks 4th with per-second billing and fork. | 288th of 377, with limits $504 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 exe.dev ranks 25th for a 24/7 dev box with a persistent VM from a flat pool, Ona ranks 368th because it is sold only through Enterprise contracts, and bochka ranks 18th. | 25th cheapest of 368 $35 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 Computer-use agents need a screen, and both exe.dev and Ona environments are headless; bochka streams a 60fps desktop with Chromium. | 240th of 369, with limits $1,055 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 | 130th of 367, with limits $530 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 | 124th of 346, with limits $278 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 | 166th of 338, with limits $5,490 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 exe.dev can copy a VM with cp and Ona can only start new environments from a config or prebuild; bochka forks one prepared machine into many while it runs. | 60th of 360, with limits $263 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 | exe.dev | Ona | bochka |
|---|---|---|---|
| Kind of product | Linux VMs for developers and agents, reached over SSH and HTTPS | Cloud dev environment platform with a browser IDE, VS Code, JetBrains and a Codex agent | Sandbox API: full VMs you create, fork and drive from code |
| Isolation | KVM VM with Cloud Hypervisor; you can't choose the kernel | Isolated VM per environment, built from a Dev Container config | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Signing up | Self-serve Personal and Work plans | New Core subscriptions are closed; new customers go through sales | Self-serve plans from a free trial up |
| Docker and nested virtualization | Root, systemd and Docker; nested virtualization on Enterprise only | Docker and root inside the Dev Container; nested virtualization not documented | Docker, root, systemd and /dev/kvm on every plan |
| Starting point | Boot from your own Docker image | Dev Container config per repo, with prebuilds that snapshot the filesystem on a schedule | Named snapshots as templates, shareable by code; no Dockerfile builds |
| Saved state | Disk persists and is streamed to a second server; no snapshots | Disk persists across stops; Core archives a stopped environment after 3 days; no snapshots of a running environment | Snapshots every minute and on stop; a stopped sandbox keeps its disk and costs nothing |
| Fork | cp copies a VM's disk and config into a new VM | No environment copy; you can create a project from an environment's config | Fork a running sandbox into copies with its files |
| Idle stop | No cap; VMs run until you stop them | Stops after 30 idle minutes by default; background work does not count; can be set to Never | No session cap on paid plans; you set the TTL |
| Desktop and computer use | Headless; no desktop | IDE access only; no graphical desktop inside the environment | 60fps desktop and Chromium, computer use, browser control, embeddable stream |
| Coding agents | Claude Code, Codex, Pi and Shelley preinstalled; Shelley takes prompts through the API | Codex Agent started from chat, a Linear issue or an automation; Claude Code you run yourself | Claude Code, Codex, pi, OpenCode and more preinstalled, with a prompt, steer and events API |
| Driving it from code | CLI and HTTPS API, plus an MCP server | Python, TypeScript and Go SDK on the Enterprise plan only | API with TypeScript and Python SDKs on every plan, including the trial |
| Secrets | Integrations inject secrets at the network edge for any HTTP host | Secrets injected as environment variables or files | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| Inbound traffic | HTTPS proxy for ports 3000 to 9999, one of them public; SSH; no raw TCP | HTTPS URL per port (1024 to 65535); SSH; no raw TCP documented | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| GPUs and regions | No GPUs; 9 regions in the US, Europe, Asia and Australia | GPU instance types such as an A10G on Enterprise runners in your own AWS or GCP account | No GPUs; EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | exe.dev | Ona | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | 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 | No | Yes | 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 | 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 | No | 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) | Yes | No | Yes |
| Audit logs | Not published | No | No |
| SSO | Yes | Yes | No |
| SOC 2 | No | Yes | No |
| HIPAA | No | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Neither exe.dev nor Ona was in the public benchmark runs we use, so there is no comparable CPU measurement for them. 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. We don't guess how the other two would score.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. exe.dev 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 | exe.dev, 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 | $35 · Personal | $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 | $35 · Personal | $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 | $1,848 · Personal | $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 | $530 · Personal · 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,050 · Personal · with limits | $5,955 · Enterprise (AWS Marketplace 12-month contract) · with limits | $2,000 · $2000/mo · with limits |
exe.dev: exe.dev Personal is a flat monthly pool your VMs share, from $15 for 2 vCPU / 4 GiB, billed whether used or not. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour.
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 cloud bill. Real Enterprise prices are negotiated with sales.
Ona: Your monthly plan fee from $20 is all usage credit, spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
exe.dev Personal allows 50 VMs at once, so the 300 user sandboxes and 1,000 short jobs don't fit there. No Ona scenario fits as published, because new customers can only buy Enterprise through sales, and the table assumes 3 environments at once since Ona publishes no Enterprise limit. Ona also stops an environment after 30 idle minutes unless auto-stop is set to Never. bochka fits four of the five, but its start-rate limits queue the 1,000-job burst.
| Scenario | exe.dev | Ona | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel | None that bite |
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use exe.dev when
you want a self-serve VM with Claude Code or Codex today, booted from your own Docker image, in a region near your users.
- Sign up and start today. Useful if you want a VM now: exe.dev plans are self-serve, while new Ona customers must go through sales.
- Claude Code and Codex ready to go. exe.dev preinstalls Claude Code, Codex, Pi and Shelley; Ona manages only its Codex agent.
- Your own Docker image, nine regions. exe.dev boots each VM from your Docker image and runs in nine regions across four continents.
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 engineers share environments with their agents: Ona has browser, VS Code and JetBrains IDEs with Dev Containers and prebuilds.
- Runs in your own cloud. Ona's Enterprise runners put environments inside your own AWS or GCP account, in the regions you pick.
- GPU environments. Useful if agents need a GPU: Ona's Enterprise runners can use GPU types such as an A10G VM.
Where bochka fits
If your code starts the machines and drives the agents inside them, look at bochka. It gives every sandbox a full VM with /dev/kvm, a desktop, state saved every minute and one API for the agents inside, on self-serve plans.
A screen your agents can use
Both exe.dev VMs and Ona environments are headless, so an agent that must check a UI or click through a web app has nothing to look at until you set up and stream a desktop yourself.
State saved every minute, and fork
Neither has snapshots to roll back a bad agent step. exe.dev can cp a VM, but Ona has no copy at all, so each parallel attempt rebuilds from a prebuild instead of the warm machine.
Drive agents inside from outside
On exe.dev only Shelley takes prompts through the API, so Claude Code or Codex means scripting shell sessions. On Ona the SDK needs an Enterprise contract and the managed agent is Codex only.
Use bochka when your code starts and drives the agents: full VMs with /dev/kvm, a desktop and open ports, state saved every minute, fork of a running sandbox and one API on every plan. Compare it one to one: bochka vs exe.dev and bochka vs Ona.
Questions people ask
Is exe.dev cheaper than Ona?
In every scenario we priced, yes: one coding agent on workdays is $35 a month on exe.dev against $5,030 on Ona, and 50 agents in parallel is $1,848 against $6,521. Ona's figures use its Enterprise listing, since new Core subscriptions are closed, so a real quote may differ. bochka comes to $20 and $317 for the same two.
Which is faster, exe.dev or Ona?
We can't say: 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.
Can exe.dev and Ona run Docker?
Yes. exe.dev VMs have root, systemd and Docker, and Ona runs Docker inside its Dev Container. Nested virtualization is Enterprise only on exe.dev and not documented on Ona, while bochka has /dev/kvm on every plan.
Can I run Claude Code on exe.dev and Ona?
exe.dev preinstalls Claude Code, Codex, Pi and its own Shelley agent. On Ona you install Claude Code yourself, since its managed agent is Codex. bochka preinstalls Claude Code, Codex, OpenCode and others with one API to prompt, steer and watch them.
Can I still sign up for Ona?
Not on a self-serve plan. Ona's billing docs say new Core subscriptions are no longer available, so new customers go through sales. exe.dev and bochka both have self-serve plans.
Do exe.dev or Ona have a desktop for computer use?
No. exe.dev VMs are headless, and Ona gives you IDEs but no graphical desktop inside the environment. bochka streams a 60fps desktop with Chromium and has APIs for computer use and browser control.
Try bochka
Install the CLI, then run bochka new.
Product preview