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. Since Ona Cloud shut down on October 31, 2026, Ona sells only Enterprise, through sales, on runners in your own AWS or GCP account. Google Agent Runtime, once Vertex AI Agent Engine, hosts the agent code you write and gives it gVisor container sandboxes that run as an unprivileged user, with no sudo and no documented 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. People open it in a browser IDE, VS Code or JetBrains, and Ona's Codex Agent can plan, code, test and open pull requests in it. Ona has a built-in web browser that its AI can drive, prebuilds and Enterprise warm pools. It is built for engineering teams who want the same governed environment for every developer and agent. Since Ona Cloud shut down on October 31, 2026, every customer runs 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. Each sandbox runs in a gVisor-isolated container in a Google-managed tenant project. Teams on GKE can also run the open-source GKE Agent Sandbox in their own cluster, with gVisor or Kata Containers, and manage it themselves.
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. “334th cheapest of 365” means 333 of the other 364 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 managed sandboxes do not document, and its SDK is on Enterprise, Ona's only plan. On Google you bake tools into a custom image and run Docker elsewhere. boat gives each agent Docker and /dev/kvm with an API on every plan. | 334th of 365, with limits $7,315 a month | 310th of 365, with limits $5,801 a month | 5th cheapest of 365 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB A Google sandbox is deleted when its TTL ends (7 days at most for a custom container); a snapshot (Preview) carries files and memory into a new sandbox. Ona stops an idle VM after 30 minutes unless auto-stop is set to Never. On boat you turn auto-stop off on a paid plan, and a resume is like a reboot. | 147th of 361, with limits $8,504 a month | 34th cheapest of 361 $7,519 a month | 6th cheapest of 361 $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 and JavaScript interpreter, billed only for use. Ona is a dev environment with no code interpreter API. | 326th of 336, with limits $5,320 a month | 251st of 336, with limits $275 a month | 189th of 336, 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. Your users reach a Google sandbox through Google's API or a private endpoint in your VPC; Google documents no public URL. boat serves HTTPS on up to 50 ports per sandbox, token-gated by default. | 325th of 349, with limits $5,988 a month | 275th of 349, with limits $1,916 a month | 3rd cheapest of 349 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 277th of 349, with limits $9,773 a month | 132nd of 349, with limits $8,240 a month | 39th of 349, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 332nd of 359, with limits $5,768 a month | 90th cheapest of 359 $2,060 a month | 10th cheapest of 359 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Google documents no Docker inside its sandboxes, so you build images outside and push them to Artifact Registry. Ona starts each run from a prebuild or an Enterprise warm pool. boat runs Docker and can fork a warm machine from its last 1-minute snapshot. | 366th of 374, with limits $5,461 a month | 104th cheapest of 374 $989 a month | 2nd cheapest of 374 $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. Google documents no SSH, and each execute_bash() call runs in a new shell. | 371st of 371, with limits $5,140 a month | 317th of 371, with limits $241 a month | 19th cheapest of 371 $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, a click, type and screenshot API and CDP. Ona's AI drives a built-in browser. Neither documents a full desktop, and boat streams a 60fps desktop with Chromium. | 355th of 367, with limits $5,691 a month | 85th of 367, with limits $1,648 a month | 7th cheapest of 367 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 219th of 356, with limits $5,346 a month | 132nd of 356, with limits $824 a month | 7th cheapest of 356 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 220th of 343, with limits $5,468 a month | 56th cheapest of 343 $515 a month | 6th cheapest of 343 $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 327, with limits $14,360 a month | 212th of 327, with limits $8,240 a month | 73rd of 327, 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 (Preview). Ona starts new environments from a config, a prebuild or a warm pool. boat forks a running machine's disk into copies, without memory. | 150th of 351, with limits $5,228 a month | 281st of 351, with limits $412 a month | 3rd cheapest of 351 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
Key features
| Feature | Ona | Google Agent Runtime | boat |
|---|---|---|---|
| Isolation | Each environment is an isolated VM with dedicated compute, built from a Dev Container config | gVisor-isolated container in a Google-managed tenant 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; Docker inside is not documented | Root, systemd and Docker on every machine |
| Nested virtualization | Not documented on its VM classes | /dev/kvm not 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; SSH is not documented | SSH, plus an API for commands |
| Desktop and computer use | A built-in browser that Ona's AI can drive; no full graphical desktop | A browser in a container with a VNC live view, a click, type and screenshot API, and CDP (GA); a full desktop is not documented | 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; Enterprise archives after 3 days by default | Pause keeps the file system at a lower, unpublished rate; the sandbox is deleted when its TTL ends, but a snapshot (Preview) saves files and memory | Disk saved every minute and at stop, kept at least 14 days; no compute charge while stopped |
| Fork and snapshots | No environment copy; prebuilds snapshot the whole Dev Container filesystem | Snapshots (Preview) keep memory and files; start many sandboxes from one snapshot | Fork a running sandbox into copies from its last 1-minute snapshot; 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 | Auto-stop 1 hour after create or resume by default; up to 30 days, or off on a paid plan with no session cap |
| Driving it from code | Python, TypeScript and Go SDK and a CLI for external agents, on Enterprise, Ona's only plan | Sandbox API on pay as you go, plus hosting for ADK, LangGraph, LangChain, AG2 and LlamaIndex agents | API, SDK and CLI on every plan, including the trial |
| Coding agents | Codex Agent from chat, Slack, a pull request comment, a Linear issue or an automation; Claude Code you install yourself | Managed Agents API (Preview) runs Google's Antigravity harness; other harnesses go in a custom image you build | Seven harnesses installed, among them Claude Code, Codex and OpenCode, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets injected as environment variables or files; OIDC can swap them for short-lived cloud credentials | You provision and scope the credentials the agent uses | Optional AI credentials proxy ($1 a day plus $1 per 1,000 requests): with it on, real keys of supported providers stay outside; other secrets still enter |
| Reaching the sandbox | HTTPS URL per port for you, your organization or everyone; SSH; no raw TCP or public IP documented | Through Google's API or a private endpoint in your VPC; a public URL is not documented | Up to 50 HTTPS URLs, token-gated by default; SSH; raw ports over public IPv6 (some sandboxes have no IPv4 of their own) |
| GPUs | GPU instance types on Enterprise runners, such as one NVIDIA A10G with 16 vCPU and 64 GB | None documented for sandboxes | None |
| Regions and deployment | Enterprise runners in your own AWS or GCP account, in many regions; Ona Cloud shut down on October 31, 2026 | 23 locations in the US, Europe, the Middle East, Asia, Canada, Australia and Brazil | Germany, Finland and France; no US or Asia region; you cannot pick a region |
Every feature Battleships tracks (43)
| Feature | Ona | Google Agent Runtime | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | No documented way | Yes |
| Docker inside | Yes | No documented way | Yes |
| Nested virtualization | No documented way | No documented way | Yes |
| Root | Yes | No documented way | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No documented way | Not published | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | No documented way | Yes | Yes |
| SSH | Yes | No documented way | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No documented way | Yes | Yes |
| Fork/clone | No documented way | Yes | Yes |
| Live fork (no pause) | No documented way | Yes | Yes |
| Memory fork | No documented way | Yes | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | No documented way | No documented way |
| Wake on request | No documented way | No documented way | No documented way |
| HTTPS preview URLs | Yes | No documented way | Yes |
| Raw TCP inbound | No documented way | Not published | Yes |
| Public IPv4 | No documented way | No documented way | No documented way |
| Egress allowlist | No documented way | Yes | No documented way |
| Secret proxy | No documented way | No documented way | Yes |
| Secret proxy for any API | No documented way | No documented way | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | Yes | Yes | Yes |
| MCP server | No documented way | No documented way | No documented way |
| GPU | Yes | No documented way | No documented way |
| Windows | No documented way | No documented way | No documented way |
| Arm64 | No documented way | Yes | No documented way |
| Self-hosting | No documented way | No documented way | No documented way |
| BYOC | Yes | No documented way | No documented way |
| Open source | No documented way | No documented way | No documented way |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No documented way | Yes | Yes |
| Audit logs | No documented way | Not published | No documented way |
| SSO | Yes | Yes | No documented way |
| SOC 2 | Yes | Yes | No documented way |
| HIPAA | No documented way | Yes | No documented way |
| EU data residency | Yes | Yes | No documented way |
| Zero data retention | Not published | Not published | Yes |
Performance
Ona and Google Agent Runtime are not in the public benchmarks we use, so we cannot say which is faster. boat did 28.06 runs per second on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15 in StarSling's run of 3 October 2026 (run 37073680030). That boat sandbox ran on an AMD Ryzen 9 9950X host; boat also places sandboxes on Ryzen 7 9700X hosts and does not promise a CPU model.
V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Ona and Google Agent Runtime are not in the public benchmarks we use, so we cannot say which is faster.
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. Start limits, per-start fees and plan minimums are in the price, boat's included.
| 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 | $8,800 · $2000/mo · with limits |
Ona: Ona Cloud and Core shut down on October 31, 2026, 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 for what you allocate, rounded to the second. The pricing page lists 50 vCPU-hours and 100 GiB-hours free each month but does not say they cover sandboxes, so our totals do not subtract them. Sandboxes bill while they exist, and disk, snapshot and egress rates are not published.
Google Agent Runtime: Plans cost $20, $100, $500 or $2,000 a month. The whole plan price comes back as VM time for that month, billed per second while a sandbox runs. A stopped sandbox has no compute charge, but saved snapshots above the included count and the AI credentials proxy still charge. The $20 plan includes 200 starts a day; extra starts cost $0.03 to $0.07, up to 1,200 a day.
Limits in those scenarios
No Ona scenario fits as published, because Ona sells only 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. The 50-agent fleet does not fit because Google documents no Docker inside its sandboxes, and every Google row leaves disk and egress unpriced. A Google sandbox is deleted when its TTL ends, so an agent that never stops is carried forward by a snapshot (Preview) into a new sandbox. On boat the 1,000-job burst does not fit: the $2,000 plan includes 90 starts a minute and 2,400 a day, and starts above 270 a minute fail with 429.
| Scenario | Ona | Google Agent Runtime | boat |
|---|---|---|---|
| One coding agent, workdays |
|
| None for this scenario |
| One agent that never stops |
|
| None for this scenario |
| 50 agents in parallel |
|
| None for this scenario |
| Sandboxes for your users |
|
| None for this scenario |
| 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, prebuilds and warm pools.
- 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 managed sandboxes do not document.
- 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 with your own network rules and regions, with short code runs or large bursts in a gVisor 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.
- Pay as you go, with a code interpreter. Useful if you want to start today without sales: pay as you go, with a ready Python and JavaScript 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 you run 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 self-serve plan.
A real computer for every agent
Google's managed sandboxes run as appuser with no sudo, and Google documents no Docker inside them, so sudo apt installs and Docker builds run somewhere else. Ona has Docker but no documented /dev/kvm or full 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, unless you carry it forward with a snapshot (Preview). Ona archives a stopped environment after 3 days by default, and its disk stays on your cloud bill. boat saves the disk every minute, keeps a stopped disk at least 14 days with no compute charge, and forks a running machine.
Coding agents driven from outside
Ona's SDK comes with an Enterprise contract, and its managed agent is Codex. Google's managed agent is its own Antigravity harness, in Preview. boat installs Claude Code, Codex, OpenCode and four other agents and drives them through one API.
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 self-serve plan, and disks saved every minute that fork while running. boat runs only in the EU, does not keep memory across a stop and limits starts per plan. Compare it one to one: boat vs Ona and boat vs Google Agent Runtime.
boat's own limits
- Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
- Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
- A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
- Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
- boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
- Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
- Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
- Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source
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. For 1,000 short jobs at once, Google comes to $2,060 and boat to $8,800 with paid starts.
Which is faster, Ona or Google Agent Runtime?
We cannot say: neither is in the public benchmarks we use. boat did 28.06 runs per second on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB in StarSling's run of 3 October 2026.
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. In Google's managed sandboxes, commands run as appuser with no sudo, custom images must not need root, and Google documents no Docker inside. Teams on GKE can also run the open-source GKE Agent Sandbox in their own cluster and manage it themselves. 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 Cloud and Core shut down on October 31, 2026, so new Ona customers buy Enterprise through sales. boat's plans are self-serve, from a 7-day trial (card required) 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 (Preview) runs its own Antigravity harness, so other agents go into a custom image you build. boat installs Claude Code, Codex and OpenCode, among seven harnesses.
Where does my data run?
Ona runs only as Enterprise runners in your own AWS or GCP account. Google runs Agent Runtime and sandboxes in 23 locations, with sandbox code in a Google-managed tenant project. boat runs sandboxes on machines in Germany, Finland and France; you cannot pick a region, and snapshot copies can be stored outside the EU.
Try boat
Install the CLI, then run boat new.
7-day free trial