Ona vs Islo
Ona, formerly Gitpod and now part of OpenAI, is a cloud dev environment platform for engineering teams and its Codex agent, sold through sales and run in your own AWS or GCP account. Islo, from Incredibuild, is an agent sandbox you can sign up for yourself: a microVM per agent, with a gateway that controls and logs what it reaches.
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.
Islo
Islo is an agent sandbox from Incredibuild: each coding agent gets its own microVM, with network rules and credentials handled at a gateway.
An Islo sandbox is a Linux microVM with its own kernel, built from a container image, with Claude Code, Cursor CLI and Codex preinstalled. Outbound traffic can pass through a gateway that allows or blocks hosts, injects credentials and logs every request. It is built for teams that run coding agents, evals and RL rollouts in the background, on Islo's cloud or in their own cloud account.
- Launched
- May 4, 2026
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 | Islo: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both run Docker inside a VM, but neither Ona nor Islo documents /dev/kvm or a desktop, so emulators and on-screen browser tests need boat. | 324th of 367, with limits $7,315 a month | 326th of 367, with limits $7,402 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Islo keeps a sandbox running with no session cap and can pause an idle assistant with its memory, while Ona stops after 30 idle minutes unless auto-stop is set to Never, because background work does not count as activity. | 83rd of 366, with limits $8,504 a month | 30th cheapest of 366 $9,928 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 | 335th of 345, with limits $5,320 a month | 153rd of 345, with limits $503 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, with a per-user default of 10 running environments, and Islo's Team plan is reported at 50 running sandboxes, so 300 at once needs a contract on either; boat ranks first here. | 330th of 361, with limits $5,988 a month | 171st of 361, with limits $3,160 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 | 167th of 360, with limits $15,265 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 Islo has a Harbor integration with $250 of credit for Harbor users and gateway rules that stop trials from looking up answers; Ona has no eval tooling and its SDK is Enterprise only. | 334th of 364, with limits $5,768 a month | 198th of 364, with limits $2,456 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 Islo fits CI runs from a container image and can start new sandboxes from a snapshot, while Ona starts each run from a prebuild and has no way to copy an environment. | 365th of 377, with limits $5,461 a month | 119th cheapest of 377 $1,507 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 people, with browser, VS Code and JetBrains IDEs, Dev Containers and prebuilds; Islo and boat give you a VM you reach over SSH. | 368th of 368, with limits $5,140 a month | 112th cheapest of 368 $402 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 Islo has a graphical desktop or a computer-use API, while boat streams a 60fps desktop with Chromium that agents can see and click. | 353rd of 369, with limits $5,691 a month | 310th of 369, with limits $2,210 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 | 113th of 367, with limits $1,105 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 | 66th cheapest of 346 $748 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 | 265th of 338, with limits $14,966 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 boat forks one prepared machine into many while it runs, Islo snapshots a running sandbox's files and starts new ones from it, and Ona starts each environment from a config or prebuild. | 93rd of 360, with limits $5,228 a month | 47th of 360, with limits $746 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 | Islo | boat |
|---|---|---|---|
| Isolation | Every environment is an isolated VM with dedicated compute, built from a Dev Container config | Every sandbox is a microVM with its own kernel, built from a container image | Every sandbox is a full VM with its own kernel |
| Docker and nested virtualization | Docker and root inside the Dev Container; nested virtualization not documented | Docker inside and sudo; no /dev/kvm or nested virtualization 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 | A browser inside the sandbox for testing; no desktop or computer-use API | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Stop, pause and resume | Disk persists across stops and is billed in your own cloud while stopped; Core archives a stopped environment after 3 days | Pause keeps files, processes and memory; can pause after idle time and resume on the next exec, file access or webhook | Snapshots every minute and on stop; a stopped sandbox keeps its disk and costs nothing; resume reboots from disk |
| Fork | No environment copy; you can create a project from an environment's config | Snapshot a running sandbox's files, then start new sandboxes from it | Fork a running sandbox into copies with its files |
| Starting point | Dev Container config per repo, with prebuilds that snapshot the filesystem on a schedule | A container image you choose | Named snapshots (templates), shareable by code; no Dockerfile builds |
| Signing up and driving it from code | New customers go through sales for Enterprise; Python, TypeScript and Go SDK on Enterprise only | Self-serve, with signup credits and no card; API and CLI, pay as you go | Self-serve from a free trial; API and SDK on every plan |
| Coding agents | Codex Agent started from chat, a Linear issue or an automation; Claude Code you run yourself | Claude Code, Cursor CLI and Codex preinstalled; factory lines with events and steer, on a schedule, webhook or GitHub, Slack and Linear events | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets are injected into the environment as environment variables or files | Gateway injects stored credentials into outbound requests for any host; credentials never reach the sandbox | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out |
| Outbound rules and request logs | No per-host outbound rules or request logs documented | Gateway allows or denies by host, path and HTTP method, with default deny, and logs every request to your SIEM | Open internet on every plan; usage API and spend limits, no per-request log |
| Reaching the sandbox | HTTPS URL per port for you, your organization or everyone; SSH; no raw TCP or public IP documented | HTTPS share links anyone with the URL can open, expiring after 24 hours by default; SSH and port-forward through the CLI | HTTPS URLs for up to 50 ports, token-protected; raw TCP; its own IP |
| Machines at once | Enterprise limit not published; the per-user policy defaults to 10 running environments | Free 5 and Team 50 running sandboxes per launch coverage; paused ones do not count; more by contract | 100 to 2,000 running sandboxes by plan, raised by adding seats |
| GPUs | GPU instance types on Enterprise runners in your own cloud, such as one NVIDIA A10G with 16 vCPU and 64 GB | None | None |
| Where it runs | Enterprise runners in your own AWS or GCP account, in many regions; Ona Cloud in Frankfurt and North Virginia for existing Core subscribers | US West, or inside your own cloud account with BYOC | EU only: Germany, Finland, France; EU data residency and zero data retention |
Every feature Battleships tracks (43)
| Feature | Ona | Islo | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | 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 | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | Yes | 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 | Yes | Yes |
| Secret proxy for any API | No | Yes | 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 | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | Yes | 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 | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | No | Not published | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Ona or Islo: neither was in StarSling's public sandbox benchmark run or the other public results we use. In StarSling's run of 2026-09-29, boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB 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 and Islo 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 | Islo, 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 | $101 · Free | $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 | $420 · Free | $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 | $4,863 · 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 | $1,382 · Team · with limits | $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 | $3,053 · Team · with limits | $2,000 · $2000/mo · with limits |
Ona: New Core subscriptions are closed, so the Ona prices here use its Enterprise listing on AWS Marketplace: a 12-month, $60,000 contract, plus the compute, which runs on your own AWS bill. Real Enterprise prices are negotiated with sales.
Islo: Islo bills each CPU core and each GB of memory and disk you give a sandbox while it runs, billed per hour, with no plan fee. An idle sandbox keeps billing until a pause-after-idle timer fires, which can only be set at creation, and egress has no published price.
Islo: 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 a new customer can only buy Enterprise through sales, and Ona publishes no Enterprise concurrency limit, so the table assumes 3 environments at once, as on its old free plan. Islo fits one agent, one always-on agent and 50 agents in parallel, but its Team plan is reported at 50 running sandboxes, so 300 user sandboxes and 1,000 short jobs at once need a custom contract. Neither publishes an egress price, so those totals leave egress out. On boat the 1,000-job burst gets queued and needs more starts per day than the $2,000 plan allows.
| Scenario | Ona | Islo | 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, 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.
- 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.
- Your own cloud, in many regions. Useful if environments must run in your own AWS or GCP account outside the US: Ona's runners work across many regions.
Use Islo when
you want a self-serve agent sandbox with per-host egress rules, a log of every outbound call, and sandboxes that pause with memory and wake on request.
- Sign up and start today. Useful if you want to try it this week: Islo is self-serve with signup credits and no card, while Ona goes through sales.
- Egress rules and request logs. Useful if you must control what agents reach: Islo allows or blocks each host, path and method, and logs every call.
- Pause with memory, wake on request. Useful for agents that sit idle between tasks: Islo pauses them with memory kept and resumes on the next request.
Where boat fits
If your code starts and drives the agents, and they need more than a shell, look at boat. It gives every agent a full VM with /dev/kvm, a desktop and ports you can host on, self-serve with an API on every plan, and up to 2,000 sandboxes at once. Neither Ona nor Islo offers the desktop, the /dev/kvm or raw TCP.
A desktop agents can see and use
A computer-use agent needs a screen. Ona gives people an IDE and Islo a headless browser, but neither has a desktop or a computer-use API, so you would install a VNC stack and a control layer in every image.
/dev/kvm for emulators and VMs
Android emulators, Firecracker and tools that start their own VMs stop at the first boot without /dev/kvm. Ona and Islo both run Docker, but neither documents nested virtualization, and software emulation runs many times slower where it works at all.
Ports you can host on
A preview a teammate opens next week or a database a test client dials needs a stable, private address. Islo share links are open to anyone with the URL and expire after 24 hours by default, and Ona documents no raw TCP.
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, up to 2,000 sandboxes at once, and machines that keep their work and fork while running. Compare it one to one: boat vs Ona and boat vs Islo.
Questions people ask
Is Ona cheaper than Islo?
Not in the scenarios we priced, using Ona's Enterprise listing on AWS Marketplace since new Core subscriptions are closed. One coding agent on workdays comes to $5,030 a month on Ona and $101 on Islo, and 50 agents in parallel to $6,521 against $4,863. boat comes to $20 and $317 for the same two, and Ona's real price is a sales quote.
Which is faster, Ona or Islo?
We have no comparable CPU measurement for either: neither was in StarSling's public benchmark run. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that run.
Can Ona and Islo run Docker?
Yes. Ona runs Docker with root inside the Dev Container, and Islo runs Docker with sudo inside its microVMs. Neither documents /dev/kvm or nested virtualization, which boat has on every machine along with systemd.
Can I sign up for Ona today?
Not on your own. Ona's billing docs say new Core subscriptions are no longer available, so new customers buy Enterprise through sales. Islo and boat are both self-serve.
Does Ona or Islo have a desktop for computer use?
No. Ona gives people a browser IDE, VS Code and JetBrains, and Islo has a headless browser for tests, and neither has a graphical desktop or a computer-use API. boat streams a 60fps desktop with Chromium and has a computer-use API on every sandbox.
Where does my data run?
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. Islo runs in US West or in your own cloud account with BYOC. 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