Ona vs Beam
Ona, formerly Gitpod and now part of OpenAI, sells cloud dev environments for engineers and its Codex agent, through sales. Beam is a self-serve serverless cloud where your code starts gVisor sandboxes, CPU VMs and GPUs from a Python or TypeScript SDK.
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 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.
Beam
Beam is a serverless cloud for GPU inference, sandboxes and background jobs, built on its open-source runtime Beta9.
Beam runs functions, REST endpoints, task queues, pods, sandboxes and VMs on CPUs and GPUs, all from a Python or TypeScript SDK. A sandbox is a container isolated with gVisor that starts in a second or two, lives until you terminate it or its time to live runs out, and can be saved as a filesystem image or a memory snapshot. Beam VMs are a separate CPU product: a microVM with its own kernel, systemd and a root disk that stays when it stops. Much of Beam is a GPU serverless platform for AI teams.
- Bring your own cloud
- Management fee per vCPU and GB of RAM, on top of your own cloud bill
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 | Beam: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither fits fully: Ona's SDK to start environments from code is Enterprise only, and Beam sandboxes have no systemd; boat gives every sandbox Docker, systemd and /dev/kvm. | 324th of 367, with limits $7,315 a month | 69th of 367, with limits $551 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB On Ona an always-on assistant needs auto-stop set to Never, since background work does not count as activity; a Beam VM keeps its disk while stopped. | 83rd of 366, with limits $8,504 a month | 115th of 366, with limits $651 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 Beam fits this well: sandboxes start in a second or two, bill per second and go away on their own when the timer ends, while Ona is built for longer dev sessions. | 335th of 345, with limits $5,320 a month | 8th cheapest of 345 $117 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 Beam gives each of your users a quick container; Ona is built for your own engineers and its per-user policy defaults to 10 running environments. | 330th of 361, with limits $5,988 a month | 3rd cheapest of 361 $290 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 | 341st of 360, with limits $939 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 | 13th cheapest of 364 $251 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 Ona starts each run from a prebuild and Beam from an image or memory snapshot, but CI that builds Android apps or VM images needs /dev/kvm, which only boat documents. | 365th of 377, with limits $5,461 a month | 12th cheapest of 377 $171 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Ona is the fuller dev box for a person, with browser, VS Code and JetBrains IDEs; a Beam VM keeps a 50 GiB root disk and boat saves its disk every minute. | 368th of 368, with limits $5,140 a month | 13th cheapest of 368 $21 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 Beam has a graphical desktop to drive, while boat streams a 60fps desktop with Chromium for computer use. | 353rd of 369, with limits $5,691 a month | 111th of 369, with limits $237 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 | 195th of 367, with limits $176 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 | 200th of 346, with limits $131 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 | 42nd of 338, with limits $923 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 | 175th of 360, with limits $155 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 Beam ranks 1st here with GPUs from RTX 4090 to H100 and B200; Ona has GPU instance types only on Enterprise runners in your own cloud, and boat is CPU only. | Can't run it | Cheapest of 98 $458 a month | 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 | Beam | boat |
|---|---|---|---|
| What it is | A platform for cloud dev environments and the Codex Agent, built for engineering teams | A serverless cloud for GPU inference, sandboxes, VMs and background jobs | A sandbox API: full VMs you start and drive from code, with agents and a desktop built in |
| Isolation | Each environment is an isolated VM with dedicated compute, built from a Dev Container config | Sandboxes are gVisor containers by default; separate Beam VMs are CPU microVMs with their own kernel | Every sandbox is a full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker, systemd and nested virtualization | Docker and root inside the Dev Container; nested virtualization is not documented | Docker in sandboxes with docker_enabled; systemd only in Beam VMs; /dev/kvm not documented | Docker, root, systemd and /dev/kvm on every machine |
| Desktop and computer use | Browser IDE plus VS Code and JetBrains; no graphical desktop inside the environment | No desktop or browser product | 60fps desktop with Chromium, computer use and browser control |
| Files after a stop | The disk persists across stops; Core archives a stopped environment after 3 days, and in your own cloud its storage stays on your bill | A sandbox ends with its time to live unless you save an image or use a volume; a Beam VM keeps a 50 GiB root disk while stopped | Disk saved every minute and on stop; a stopped sandbox keeps it and costs nothing |
| Fork and snapshots | No environment copy; prebuilds snapshot the filesystem on a schedule | Memory snapshot of a running sandbox with its processes, restored into new sandboxes | Fork a running sandbox into copies with its files |
| Idle stop and lifetime | Stops after 30 minutes without SSH, IDE or agent activity by default; can be set to Never | Sandbox time to live is 10 minutes by default; set -1 to run until you terminate it | 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 | Python and TypeScript SDK on every plan | 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 | None preinstalled; you install and run them through process exec | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets are injected as environment variables or files | Secrets are exposed as environment variables inside the sandbox | AI credentials proxy for model providers and any HTTPS API you register |
| Reaching the machine | HTTPS URL per port for you, your organization or everyone; SSH; no raw TCP | Public HTTPS URL per exposed port with no built-in auth; no raw TCP or dedicated IP | Token-protected HTTPS on up to 50 ports, raw TCP, dedicated IPv4 or IPv6 |
| GPUs | GPU instance types on Enterprise runners in your own cloud, such as one NVIDIA A10G | GPU sandboxes and serverless GPUs from T4 and RTX 4090 up to H100, H200 and B200 | None, CPU only |
| Regions and deployment | Enterprise runners in your own AWS or GCP account, in many regions | US only on Beam's cloud; Beta9 is open source to self-host, or bring your own cloud for a fee | EU only: Germany, Finland, France |
| Buying it | New Core subscriptions are closed; new customers go through sales for Enterprise | Self-serve: Developer is pay as you go, Team is $89 a month plus usage | Self-serve plans from $20 a month, all of it usage credit |
Every feature Battleships tracks (43)
| Feature | Ona | Beam | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | No | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | Yes | 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 | Yes | 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 | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | No | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | No | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | 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 Beam: neither was in the StarSling hpc-sandbox-benchmarks runs we use, so we cannot say which of the two is faster. 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 hosts. Beam's own guide says its sandboxes cold-boot in 1 to 3 seconds.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Ona and Beam 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 | Beam, a month | boat, 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 · Developer | $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 · Developer | $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 | $410 · Team | $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 | $191 · Team | $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 | $259 · Team | $2,000 · $2000/mo · with limits |
Ona: New Core subscriptions are closed, so these Ona prices use its Enterprise listing on AWS Marketplace: a 12-month, $60,000 contract, plus the compute on your own AWS bill. Real Enterprise prices are negotiated with sales.
Beam: Beam sandboxes bill per second for each CPU core (one core is two vCPU) and each GiB of RAM until you terminate them or their time to live ends, so an idle tail is billed too. Developer has no fee; Team is $89 a month plus usage, with no egress fees.
Beam: Plans start at $20 a month, and the whole fee is 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 Ona publishes no Enterprise concurrency limit, so the table assumes 3 environments at once. Beam fits all five scenarios, but its Developer plan allows 30 CPU containers at once, so 50 agents and 1,000 short jobs need the Team plan. Beam publishes no price for disk beyond what a VM includes, so no disk cost is counted for it. boat fits every scenario but the 1,000-job burst, where its $2,000 plan queues starts.
| Scenario | Ona | Beam | boat |
|---|---|---|---|
| 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, running inside your own AWS or GCP account.
- A full cloud IDE for your team. Useful if your engineers work in the same environments as their agents, with Dev Containers, prebuilds and browser, VS Code or JetBrains IDEs.
- Runs in your own AWS or GCP account. Useful if environments must live inside your own cloud account, in many regions, under organization policies you set.
- A managed Codex agent. Useful if you want Codex to plan, code, test and open pull requests from chat, a Linear issue or an automation.
Use Beam when
you need GPUs, short self-serve sandboxes billed per second, hosting in the US, or a runtime you can self-host.
- GPUs in the same platform. Useful if your agents or models need a GPU: Beam has GPU sandboxes and serverless GPUs up to H100, H200 and B200.
- Self-serve, per-second sandboxes. Useful for short code runs: sandboxes start in a second or two, bill per second, and Developer has no monthly fee.
- Open source and outbound rules. Useful if you must self-host or lock traffic down: Beta9 is AGPL-3.0, and sandboxes can block outbound traffic or allow 10 CIDR ranges.
Where boat fits
If what you are really running is coding agents started by your own code, look at boat. Ona is a team IDE sold through sales, and Beam is a GPU and sandbox cloud where you build the agent setup yourself. boat gives each agent a full VM with agents, a desktop and a credentials proxy already in place, on a self-serve plan.
A full VM with /dev/kvm and systemd
Android emulators and microVMs need /dev/kvm, which neither Ona nor Beam documents. Beam sandboxes are gVisor containers without systemd, so the workaround is a separate Beam VM, which still has no /dev/kvm.
A desktop for computer use
A computer-use agent needs a screen. Ona has IDEs but no graphical desktop, and Beam has no desktop or browser product, so on either you build and stream one yourself. boat ships a 60fps desktop with Chromium.
Agents driven from outside, keys kept outside
On both, secrets sit as environment variables inside a machine the agent controls, where one prompt injection can leak them. boat keeps keys in a credentials proxy and lets you prompt, steer and follow agents inside through one API.
Use boat when your code starts and drives the agents: full VMs with /dev/kvm, systemd, a desktop and open ports, an API on every plan, and disks that keep their work and fork while running. Compare it one to one: boat vs Ona and boat vs Beam.
Questions people ask
Is Ona cheaper than Beam?
No, Beam costs far less in every scenario we priced, using Ona's Enterprise listing on AWS Marketplace since Core is closed. One agent that never stops is $22 a month on Beam against $5,140 on Ona, and 50 agents in parallel are $410 against $6,521. Ona's real Enterprise price is a sales quote.
Which is faster, Ona or Beam?
We cannot say: neither has a result on the StarSling CPU benchmark we use. Beam's guide says its sandboxes cold-boot in 1 to 3 seconds. boat did 26.69 runs per second on that benchmark at 4 vCPU / 8 GB.
Can Ona and Beam run Docker?
Yes. Ona runs Docker with root inside the Dev Container, and Beam runs Docker inside a sandbox with docker_enabled. Neither documents /dev/kvm, while boat has Docker, systemd and /dev/kvm on every machine.
Do Ona and Beam have GPUs?
Beam does, with GPU sandboxes and serverless GPUs from T4 up to H100, H200 and B200. Ona has GPU instance types, such as one NVIDIA A10G, only on Enterprise runners in your own cloud. boat is CPU only.
Can I sign up for Ona or Beam today?
Beam is self-serve: Developer is pay as you go, and Team adds an $89 fee each month on top of usage. Ona's billing docs say new Core subscriptions are no longer available, so new customers go through sales. boat'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.
Try boat
Install the CLI, then run boat new.
7-day free trial