boat vs Ona
Ona, formerly Gitpod and now part of OpenAI, runs cloud dev environments for engineers and its Codex agent, sold through sales. boat is a sandbox you drive from code: full VMs with nested virtualization, a desktop and coding agents built in, an API on every plan, and disks that keep their files when stopped.
Where boat stands out
An API for agents on every plan
boat is built to be driven from code: you create, fork and stop machines through an API on every plan, and drive Claude Code, Codex, OpenCode and other agents inside them with a prompt, steer and events API. Ona is built around people and its own Codex Agent, and its SDK to create environments from code is on the Enterprise plan only.
Machines that keep their work
boat snapshots the disk every minute and on stop, keeps a stopped sandbox for free, and can fork a running sandbox into copies. Ona keeps the disk across stops, but on Enterprise runners that disk stays on your cloud bill while stopped, Core archives a stopped environment after 3 days, and there is no way to copy an environment.
Nested virtualization, a desktop and open ports
Every boat machine has root, systemd, Docker and /dev/kvm, a 60fps desktop with Chromium for computer use, HTTPS on up to 50 ports and raw TCP. Ona gives you Docker in a Dev Container and HTTPS URLs per port, but documents no /dev/kvm, no graphical desktop and no raw TCP.
The companies and products
boat
boat.dev runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.
You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.
- Isolation
- Full VM per sandbox, own kernel
- Regions
- EU: Germany, Finland, France
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 boat: 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. “3rd cheapest of 367” means 2 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 | boat: price rank | Ona: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month boat fits fully; on Ona each agent gets a VM, but nested virtualization is not documented and the SDK to start them from code is Enterprise only. | 3rd cheapest of 367 $634 a month | 324th of 367, with limits $7,315 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 and the default stops a VM after 30 idle minutes. | 5th cheapest of 366 $657 a month | 83rd of 366, with limits $8,504 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month | 186th of 345, with limits $2,000 a month | 335th of 345, with limits $5,320 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, not for handing machines to your users, and its per-user policy defaults to 10 running environments. | Cheapest of 361 $209 a month | 330th of 361, with limits $5,988 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 34th of 360, with limits $2,000 a month | 283rd of 360, with limits $9,773 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 10th cheapest of 364 $200 a month | 334th of 364, with limits $5,768 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Ona has no fork and no per-minute snapshots, so each CI run starts from a prebuild instead of copying a warm machine. | 4th cheapest of 377 $86 a month | 365th of 377, with limits $5,461 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both fit a dev box well: Ona is a full cloud IDE with Dev Containers and prebuilds, and boat is a full VM you reach over SSH, HTTPS or a desktop. | 18th cheapest of 368 $26 a month | 368th of 368, with limits $5,140 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Ona environments have no graphical desktop to drive, while boat streams a 60fps desktop with Chromium for computer use. | 6th cheapest of 369 $200 a month | 353rd of 369, with limits $5,691 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 7th cheapest of 367 $200 a month | 150th of 367, with limits $5,346 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 6th cheapest of 346 $90 a month | 146th of 346, with limits $5,468 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 71st of 338, with limits $1,800 a month | 261st of 338, with limits $14,360 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month boat can fork one prepared machine into many while it runs; Ona can only start new environments from a config or prebuild. | 2nd cheapest of 360 $200 a month | 93rd of 360, with limits $5,228 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 |
| 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 |
Key features
Every feature Battleships tracks (43)
| Feature | boat | Ona |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | No |
| Root | Yes | Yes |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | No |
| Browser | Yes | Yes |
| Computer-use API | Yes | No |
| SSH | Yes | Yes |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | No |
| Fork/clone | Yes | No |
| Live fork (no pause) | Yes | No |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | Yes |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | No |
| Public IPv4 | No | No |
| Egress allowlist | No | No |
| Secret proxy | Yes | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | Yes |
| MCP server | No | No |
| GPU | No | Yes |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | No |
| BYOC | No | Yes |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Yes |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | No |
| SSO | No | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | No |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement for Ona: it was not in the public benchmark runs we use. boat 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 (Zen 5) hosts.
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 | boat, a month | Ona, 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 | $20 · $20/mo | $5,030 · Enterprise (AWS Marketplace 12-month contract) · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $5,140 · Enterprise (AWS Marketplace 12-month contract) · with limits |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $317 · $20/mo × 3 seats | $6,521 · Enterprise (AWS Marketplace 12-month contract) · with limits |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $200 · $100/mo × 2 seats | $5,432 · Enterprise (AWS Marketplace 12-month contract) · with limits |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $2,000 · $2000/mo · with limits | $5,955 · Enterprise (AWS Marketplace 12-month contract) · with limits |
boat: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
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.
Limits in those scenarios
No Ona scenario fits as published, because a new customer can only buy Enterprise through sales. Ona does not publish an Enterprise concurrency limit, so the table assumes 3 environments at once, as on its old free plan; that is why 50 agents, 300 user sandboxes and 1,000 short jobs also show as too big. Ona's per-user policy defaults to 10 running environments, and an agent stops after 30 idle minutes unless auto-stop is set to Never, because background work does not count as activity. On boat the limit is a sandbox count (100 to 2,000 by plan) plus starts per minute, so the 1,000-job burst gets queued and needs more starts per day than the $2,000 plan allows.
| Scenario | boat | Ona |
|---|---|---|
| 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: Ona has 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, or outside the EU: 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 with 16 vCPU and 64 GB.
Use boat when
your code starts and drives the agents: full VMs with /dev/kvm, a desktop and open ports, an API on every plan, and machines that keep their work and fork while running.
- An API for agents on every plan. If your product starts a machine per agent run, you need an API from day one. On Ona that means an Enterprise contract through sales, and the agent it manages for you is Codex only.
- Machines that keep their work. An agent that waits a week for review keeps paying for its disk on Ona, or loses it on Core. Without fork, every parallel attempt rebuilds from a prebuild instead of starting from the warm machine you already set up.
- Nested virtualization, a desktop and open ports. Android emulators and microVMs need /dev/kvm, computer-use agents need a screen, and databases or game servers need raw TCP. On Ona an agent doing that work has none of the three.
Questions people ask
Is boat cheaper than Ona?
In every scenario we priced, yes, using Ona's Enterprise listing on AWS Marketplace, since new Core subscriptions are closed: one coding agent on workdays is $20 a month on boat and $5,030 on Ona, and one agent running all month is $26 against $5,140. 50 agents in parallel come to $317 against $6,521, and 300 user sandboxes to $200 against $5,432. Ona's real Enterprise price is a sales quote, so yours may differ.
Is Ona the same as Gitpod?
Yes. Gitpod renamed itself Ona in 2025 and moved from cloud dev environments to background coding agents, and Ona is now part of OpenAI. The old app still lives at app.gitpod.io.
Can I still sign up for Ona Core?
No. Ona's billing docs say new Core subscriptions are no longer available, and its pricing page is now a sales form. Existing Core subscribers keep their plan. boat's plans are self-serve, from a free trial up.
Can I run Claude Code on Ona?
You can install and run Claude Code yourself inside an Ona environment, but Ona's managed agent is Codex, and its Anthropic-based Ona Agent is no longer available on Ona Cloud. boat ships Claude Code, Codex, OpenCode and others preinstalled, with one API to prompt, steer and watch them.
Where does my data run?
boat runs only in the EU (Germany, Finland and France), with EU data residency and a zero data retention option. 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.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Start a sandbox
Install the CLI, then run boat new.
7-day free trial
More comparisons
- boat vs exe.dev
- boat vs Amp Orbs
- boat vs Prized
- boat vs Zo Computer
- boat vs Namespace
- boat vs boxes.dev
- boat vs Tencent Cloud Studio
- boat vs Sealos DevBox
- boat vs E2B
- boat vs Daytona
- boat vs Modal
- boat vs Vercel Sandbox
- E2B vs Ona
- Daytona vs Ona
- Modal vs Ona
- Vercel Sandbox vs Ona
- Cloudflare Sandbox vs Ona
- Blaxel vs Ona
- Runloop vs Ona
- Tensorlake vs Ona