Ona vs Google Agent Runtime
Ona, formerly Gitpod, gives your engineers and its Codex agent a full dev environment in a VM, with an IDE, Docker and root, sold through sales. Google Agent Runtime, once Vertex AI Agent Engine, hosts the agent code you write and gives it short-lived sandboxes that run as an unprivileged user, with no root and no Docker.
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.
Google Agent Runtime
Google Agent Runtime is the agent hosting part of Gemini Enterprise Agent Platform on Google Cloud, renamed from Vertex AI Agent Engine in April 2026.
It is a hyperscaler service, not a sandbox company. Agent Runtime deploys agents you build with ADK, LangGraph, LangChain, AG2 or LlamaIndex and bills them only while they work on a turn. Next to it, Agent Sandbox gives those agents a place to run code: a Code Execution sandbox, a shell or custom container sandbox, and a Computer Use browser. All of them run as secure containers inside your Google Cloud project.
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 | Google Agent Runtime: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Ona gives each agent a VM with Docker and root, which Google's sandboxes lack, but Ona's SDK is Enterprise only; boat fits fully with Docker, /dev/kvm and an API on every plan. | 324th of 367, with limits $7,315 a month | 295th of 367, with limits $5,801 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Google sandboxes are deleted when their TTL ends (7 days at most for a custom container), and Ona stops an idle VM after 30 minutes unless auto-stop is set to Never; boat has no session cap on paid plans. | 83rd of 366, with limits $8,504 a month | 28th cheapest of 366 $7,519 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 This is where Google fits best: its Code Execution sandbox is a ready Python interpreter, while Ona is a dev environment with no code interpreter API. | 335th of 345, with limits $5,320 a month | 254th of 345, with limits $275 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 Ona is built for your own engineers and defaults to 10 running environments per user, and Google gives your users a shell with no public URL; boat serves HTTPS on up to 50 ports per sandbox. | 330th of 361, with limits $5,988 a month | 280th of 361, with limits $1,916 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 | 128th of 360, with limits $8,240 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 | 79th cheapest of 364 $2,060 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 Google's sandboxes cannot build containers because they have no Docker, and Ona starts each run from a prebuild with no fork; boat runs Docker and can fork a warm machine. | 365th of 377, with limits $5,461 a month | 98th cheapest of 377 $989 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Ona is the better dev box of the two, with browser, VS Code and JetBrains IDEs and SSH, while Google has no SSH and runs each command in a new shell. | 368th of 368, with limits $5,140 a month | 311th of 368, with limits $241 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 Google gives you a browser with a VNC view and a click and type API, Ona has no graphical desktop, and boat streams a full 60fps desktop with Chromium. | 353rd of 369, with limits $5,691 a month | 283rd of 369, with limits $1,648 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 | 102nd of 367, with limits $824 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 | 53rd cheapest of 346 $515 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 | 210th of 338, with limits $8,240 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 Google can start many sandboxes from one memory snapshot, Ona can only start new environments from a config or prebuild, and boat forks a running machine into copies. | 93rd of 360, with limits $5,228 a month | 260th of 360, with limits $412 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 | Google Agent Runtime | boat |
|---|---|---|---|
| Isolation | Each environment is an isolated VM with dedicated compute, built from a Dev Container config | Secure container sandboxing inside your Google Cloud project | Every sandbox is a full VM with its own kernel |
| Root and Docker | Docker and root inside the Dev Container | Runs as appuser with no sudo; images must not need root; no Docker | Root, systemd and Docker on every machine |
| Nested virtualization | Not documented on its VM classes | No /dev/kvm documented | /dev/kvm on every machine, for emulators and microVMs |
| Shell access | SSH, plus browser, VS Code and JetBrains IDEs | execute_bash() API calls; each command runs in a new shell; no SSH | SSH, plus an API for commands |
| Desktop and computer use | No graphical desktop inside the environment | A browser in a container with a VNC live view, a click, type and screenshot API, and CDP | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Files after a stop | Disk persists across stops; billed on your cloud while stopped; Core archives after 3 days | Pause keeps the file system at a lower, unpublished rate; deleted when the TTL ends | Snapshots every minute and on stop; a stopped sandbox keeps its disk and costs nothing |
| Fork and snapshots | No environment copy; prebuilds snapshot the filesystem on a schedule | Snapshots keep memory and files; start many sandboxes from one snapshot | Fork a running sandbox into copies; resume reboots from disk (no memory snapshots) |
| How long it runs | Stops after 30 idle minutes by default; background work does not count; can be set to Never | TTL of up to 7 days for a custom container and 14 days for Code Execution | 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 | Sandbox API on pay as you go, plus hosting for ADK, LangGraph, LangChain, AG2 and LlamaIndex agents | API and SDK on every plan, including the trial |
| Coding agents | Codex Agent from chat, a Linear issue or an automation; Claude Code you run yourself | Managed Agents API (Preview) runs Google's Antigravity harness | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets injected as environment variables or files | You provision and scope the credentials the agent uses | AI 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 for you, your organization or everyone; no raw TCP or public IP | Through Google's API or a private endpoint in your VPC; no public URL documented | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| GPUs | GPU instance types on Enterprise runners, such as one NVIDIA A10G with 16 vCPU and 64 GB | None for sandboxes | None |
| Regions and deployment | Enterprise runners in your own AWS or GCP account, in many regions | 23 locations in the US, Europe, Asia, Canada, Australia and Brazil | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Ona | Google Agent Runtime | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | No | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | No | 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 | 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 | No | Yes |
| Raw TCP inbound | No | Not published | 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 | Yes | Yes |
| Agent harness API | Yes | Yes | Yes |
| MCP server | No | No | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | 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 | Not published | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | No | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Ona or for Google Agent Runtime: neither was 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 hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Ona and Google Agent Runtime 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 | Google Agent Runtime, 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 | $73 · Pay as you go | $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 | $301 · Pay as you go | $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 | $3,626 · Pay as you go · 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 | $5,432 · Enterprise (AWS Marketplace 12-month contract) · with limits | $1,030 · Pay as you go | $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 | $2,060 · Pay as you go | $2,000 · $2000/mo · with limits |
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.
Google Agent Runtime: Google bills $0.085 per vCPU-hour and $0.009 per GiB-hour allocated, rounded to the second, with the first 50 vCPU-hours and 100 GiB-hours free each month. Sandboxes bill while they exist, and disk and egress rates are not published.
Google Agent Runtime: 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.
Limits in those scenarios
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 does not publish an Enterprise limit. Google fits four of five scenarios, but the 50-agent fleet fails because its sandboxes have no Docker, and every Google row leaves disk and egress unpriced. A Google sandbox is deleted when its TTL ends, so an agent that never stops must be recreated. On boat the 1,000-job burst gets queued, because starts are capped at 90 a minute and 2,400 a day on the $2,000 plan.
| Scenario | Ona | Google Agent Runtime | 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, with Docker and root, inside your own AWS or GCP account or with a GPU.
- A full cloud IDE for people and agents. Useful if your engineers work beside their agents: Ona has browser, VS Code and JetBrains IDEs, Dev Containers and prebuilds.
- Docker and root in a real VM. Useful if agents run docker or sudo installs: each Ona environment is a VM with Docker and root, which Google's sandboxes lack.
- Your own cloud, with GPUs. Useful if environments must run in your AWS or GCP account or need a GPU, such as an A10G VM.
Use Google Agent Runtime when
you build agents with ADK or LangGraph on Google Cloud and want them hosted in your own project, with short code runs in a locked sandbox.
- A managed home for agent code. Useful if you build agents with ADK or LangGraph: Agent Runtime hosts them and skips billing for idle time between turns.
- Self-serve, with a code interpreter. Useful if you want to start today without sales: pay as you go, with a ready Python sandbox for short code runs.
- Memory snapshots and a locked network. Useful if you branch sandboxes with their memory, or need egress off by default and routed through your own VPC.
Where boat fits
Ona is a dev platform for your engineers, and Google hosts agent code with locked sandboxes. If what you are really running is many coding agents started from your own code, boat gives each one a full VM with root, Docker and /dev/kvm, a desktop and public ports, with an API on every plan.
A real computer for every agent
Google's sandboxes run as appuser with no sudo or Docker, so docker compose and apt installs fail. Ona has Docker but no documented /dev/kvm or desktop. boat has root, Docker, /dev/kvm and a 60fps desktop on every VM.
Machines that keep their work
A Google sandbox is deleted when its TTL ends, and Ona Core archives a stopped environment after 3 days, while Enterprise disks stay on your cloud bill. boat snapshots every minute, keeps stopped disks free, and forks a running machine.
Coding agents driven from outside
Ona's SDK needs an Enterprise contract and manages only Codex, and Google's managed agent is its own Antigravity harness. boat preinstalls Claude Code, Codex and OpenCode, drives them through one API, and keeps keys out with a credentials proxy.
Use boat when your code starts and drives the agents: full VMs with root, Docker, /dev/kvm, a desktop and public ports, an API on every plan, and machines that keep their work and fork while running. Compare it one to one: boat vs Ona and boat vs Google Agent Runtime.
Questions people ask
Is Ona cheaper than Google Agent Runtime?
In the scenarios we priced, Google comes out lower: one coding agent on workdays is $73 a month on Google against $5,030 on Ona's Enterprise listing, and one agent running all month is $301 against $5,140. Ona's real price is a sales quote, and boat comes to $20 and $26 for the same two.
Which is faster, Ona or Google Agent Runtime?
Neither has a comparable public CPU measurement, so we cannot say. 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.
Can I run Docker on Ona or Google Agent Runtime?
On Ona, yes: each environment is a VM with Docker and root inside the Dev Container. On Google, no: sandbox commands run as appuser with no sudo, and custom images must not need root. boat has root, Docker and /dev/kvm on every VM.
Can I sign up for either without talking to sales?
Google Agent Runtime is pay as you go on Google Cloud. Ona's billing docs say new Core subscriptions are no longer available, so new customers go through sales for Enterprise. boat's plans are self-serve, from a free trial up.
Can I run Claude Code on Ona or Google?
On Ona you can install Claude Code yourself, but its managed agent is Codex. Google's Managed Agents API runs its own Antigravity harness, so other agents go into an image you build, with keys passed in. boat ships Claude Code, Codex and OpenCode preinstalled.
Where does my data run?
New Ona customers run Enterprise runners in their own AWS or GCP account, and Google runs in 23 locations inside your Google Cloud project. boat runs only in the EU (Germany, Finland and France), with EU data residency.
Try boat
Install the CLI, then run boat new.
7-day free trial