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 workloadOna: price rankGoogle Agent Runtime: price rankboat: 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 requirementNot ranked: misses a requirementNot 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 requirementNot ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureOnaGoogle Agent Runtimeboat
IsolationEach environment is an isolated VM with dedicated compute, built from a Dev Container configgVisor-isolated container in a Google-managed tenant projectEvery sandbox is a full VM with its own kernel
Root and DockerDocker and root inside the Dev ContainerRuns as appuser with no sudo; images must not need root; Docker inside is not documentedRoot, systemd and Docker on every machine
Nested virtualizationNot documented on its VM classes/dev/kvm not documented/dev/kvm on every machine, for emulators and microVMs
Shell accessSSH, plus browser, VS Code and JetBrains IDEsexecute_bash() API calls; each command runs in a new shell; SSH is not documentedSSH, plus an API for commands
Desktop and computer useA built-in browser that Ona's AI can drive; no full graphical desktopA browser in a container with a VNC live view, a click, type and screenshot API, and CDP (GA); a full desktop is not documented60fps desktop and Chromium, computer use and browser control, embeddable stream
Files after a stopDisk persists across stops, billed on your cloud while stopped; Enterprise archives after 3 days by defaultPause keeps the file system at a lower, unpublished rate; the sandbox is deleted when its TTL ends, but a snapshot (Preview) saves files and memoryDisk saved every minute and at stop, kept at least 14 days; no compute charge while stopped
Fork and snapshotsNo environment copy; prebuilds snapshot the whole Dev Container filesystemSnapshots (Preview) keep memory and files; start many sandboxes from one snapshotFork a running sandbox into copies from its last 1-minute snapshot; resume reboots from disk (no memory snapshots)
How long it runsStops after 30 idle minutes by default; background work does not count; can be set to NeverTTL of up to 7 days for a custom container and 14 days for Code ExecutionAuto-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 codePython, TypeScript and Go SDK and a CLI for external agents, on Enterprise, Ona's only planSandbox API on pay as you go, plus hosting for ADK, LangGraph, LangChain, AG2 and LlamaIndex agentsAPI, SDK and CLI on every plan, including the trial
Coding agentsCodex Agent from chat, Slack, a pull request comment, a Linear issue or an automation; Claude Code you install yourselfManaged Agents API (Preview) runs Google's Antigravity harness; other harnesses go in a custom image you buildSeven harnesses installed, among them Claude Code, Codex and OpenCode, with a prompt, steer and events API
Keeping keys out of the sandboxSecrets injected as environment variables or files; OIDC can swap them for short-lived cloud credentialsYou provision and scope the credentials the agent usesOptional 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 sandboxHTTPS URL per port for you, your organization or everyone; SSH; no raw TCP or public IP documentedThrough Google's API or a private endpoint in your VPC; a public URL is not documentedUp to 50 HTTPS URLs, token-gated by default; SSH; raw ports over public IPv6 (some sandboxes have no IPv4 of their own)
GPUsGPU instance types on Enterprise runners, such as one NVIDIA A10G with 16 vCPU and 64 GBNone documented for sandboxesNone
Regions and deploymentEnterprise runners in your own AWS or GCP account, in many regions; Ona Cloud shut down on October 31, 202623 locations in the US, Europe, the Middle East, Asia, Canada, Australia and BrazilGermany, Finland and France; no US or Asia region; you cannot pick a region
Every feature Battleships tracks (43)
FeatureOnaGoogle Agent Runtimeboat
Full VM (own kernel)YesNo documented wayYes
Docker insideYesNo documented wayYes
Nested virtualizationNo documented wayNo documented wayYes
RootYesNo documented wayYes
SystemdNot publishedNot publishedYes
Desktop GUINo documented wayNot publishedYes
BrowserYesYesYes
Computer-use APINo documented wayYesYes
SSHYesNo documented wayYes
Persistent diskYesYesYes
Pause/resumeYesYesYes
Automatic snapshotsNo documented wayYesYes
Fork/cloneNo documented wayYesYes
Live fork (no pause)No documented wayYesYes
Memory forkNo documented wayYesNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesYesYes
Idle auto-stopYesNo documented wayNo documented way
Wake on requestNo documented wayNo documented wayNo documented way
HTTPS preview URLsYesNo documented wayYes
Raw TCP inboundNo documented wayNot publishedYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistNo documented wayYesNo documented way
Secret proxyNo documented wayNo documented wayYes
Secret proxy for any APINo documented wayNo documented wayYes
Preinstalled agentsYesYesYes
Agent harness APIYesYesYes
MCP serverNo documented wayNo documented wayNo documented way
GPUYesNo documented wayNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64No documented wayYesNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCYesNo documented wayNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsYesNot publishedYes
Usage per sandbox (API)No documented wayYesYes
Audit logsNo documented wayNot publishedNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAANo documented wayYesNo documented way
EU data residencyYesYesNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

OnaNot measured
Google Agent RuntimeNot measured
boat28.06 runs/s

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.

ScenarioOna, a monthGoogle Agent Runtime, a monthboat, 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.

ScenarioOnaGoogle Agent Runtimeboat
One coding agent, workdays
  • negotiated / enterprise price
  • different kind of product: CI runner
  • needs talk to sales: plan "Enterprise (AWS Marketplace 12-month contract)" is negotiated with sales
  • egress price not published
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
One agent that never stops
  • negotiated / enterprise price
  • different kind of product: CI runner
  • needs talk to sales: plan "Enterprise (AWS Marketplace 12-month contract)" is negotiated with sales
  • egress price not published
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
50 agents in parallel
  • Enterprise (AWS Marketplace 12-month contract): max 3 concurrent (not published; assumed like its other plans)
  • negotiated / enterprise price
  • different kind of product: CI runner
  • needs talk to sales: plan "Enterprise (AWS Marketplace 12-month contract)" is negotiated with sales
  • missing Docker inside
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
Sandboxes for your users
  • Enterprise (AWS Marketplace 12-month contract): max 3 concurrent (not published; assumed like its other plans)
  • negotiated / enterprise price
  • different kind of product: CI runner
  • needs talk to sales: plan "Enterprise (AWS Marketplace 12-month contract)" is negotiated with sales
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
1,000 short jobs at once
  • Enterprise (AWS Marketplace 12-month contract): max 3 concurrent (not published; assumed like its other plans)
  • negotiated / enterprise price
  • different kind of product: CI runner
  • needs talk to sales: plan "Enterprise (AWS Marketplace 12-month contract)" is negotiated with sales
  • disk beyond 0 GiB: price unknown
  • egress price not published
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429

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

More comparisons