Morph Cloud vs Ona
Morph Cloud sells full VMs for AI agents that you drive from code, with self-serve plans and snapshots that copy a running machine with its memory. Ona, formerly Gitpod and now part of OpenAI, is a cloud dev environment platform for engineers and its Codex agent, sold to new customers through sales.
The companies and products
Morph Cloud
Morph Cloud sells full virtual machines for AI agents that can be snapshotted, branched and restored with their memory, which it calls Infinibranch.
You get MorphVM instances as low-level building blocks and Devboxes as ready workspaces on top of them, with SSH, preview URLs and a tmux API for running coding agents you install yourself. Everything is billed in MCUs, where one MCU is 1 vCPU, 4 GB of RAM or 16 GB of disk for an hour. It is built for teams that fan agents out from one saved state, and it also sells managed GitHub Actions runners and a shared filesystem.
- Regions
- Not published
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 bochka: 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.
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. “16th cheapest of 345” means 15 of the other 344 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 | Morph Cloud: price rank | Ona: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 198th of 367, with limits $2,288 a month | 324th of 367, with limits $7,315 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that runs all month on Ona needs auto-stop set to Never, because background work does not count as activity; on Morph it keeps running until you stop it. | 235th of 366, with limits $3,014 a month | 83rd of 366, with limits $8,504 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 Morph fits short code runs well, because a machine can pause with its memory, bill only its snapshot while paused and wake on the next request; Ona and bochka both start from a stopped machine. | 16th cheapest of 345 $154 a month | 335th of 345, with limits $5,320 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 Morph and bochka both fit sandboxes handed to your users, while Ona is built for your own engineers and its per-user policy defaults to 10 running environments. | 12th cheapest of 361 $905 a month | 330th of 361, with limits $5,988 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 Morph's memory branching suits rollouts that all start from the same running state; bochka forks a running machine with its disk, and Ona has no way to copy an environment. | 86th of 360, with limits $4,847 a month | 283rd of 360, with limits $9,773 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 Morph and bochka both start many machines from code on self-serve plans; on Ona the SDK that creates environments from code is on the Enterprise plan only. | 38th cheapest of 364 $675 a month | 334th of 364, with limits $5,768 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 Morph also sells managed GitHub Actions runners; Ona starts each environment from a prebuild, and on bochka you run your own runner inside a sandbox. | 39th cheapest of 377 $355 a month | 365th of 377, with limits $5,461 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Ona is a full cloud IDE with Dev Containers and prebuilds, Morph has Devboxes with SSH and preview URLs, and bochka is a full VM you reach over SSH, HTTPS or a desktop. | 85th cheapest of 368 $116 a month | 368th of 368, with limits $5,140 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 bochka streams a 60fps desktop with Chromium and a computer use API; on Morph you install the browser and agent yourself, and Ona environments have no graphical desktop. | 182nd of 369, with limits $595 a month | 353rd of 369, with limits $5,691 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 | 214th of 367, with limits $250 a month | 150th of 367, with limits $5,346 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 | 239th of 346, with limits $234 a month | 146th of 346, with limits $5,468 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 | 154th of 338, with limits $4,750 a month | 261st of 338, with limits $14,360 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 | 214th of 360, with limits $228 a month | 93rd of 360, with limits $5,228 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 | Morph Cloud | Ona | bochka |
|---|---|---|---|
| Full VM, Docker and nested virtualization | Full VM with its own kernel, root and Docker; nested virtualization is experimental | Isolated VM per environment with Docker and root in a Dev Container; nested virtualization is not documented | Full VM with its own kernel, root, Docker, systemd and /dev/kvm on dedicated AMD Ryzen 9 9950X hosts |
| Copy a running machine | Snapshot and branch a running VM with its memory into many copies in under 250 ms | No environment copy; you can create a project from an environment's config | Fork a running sandbox into copies with its disk; the copy boots fresh |
| Pause and wake on request | Pause keeps memory and bills only the snapshot; a paused VM wakes on the next HTTP request, SSH or exec call | Stops after 30 idle minutes by default; you start it again yourself | No memory pause; a stopped sandbox is started again by API |
| Keeping work after a stop | Saved when you pause or snapshot; a plain stop deletes the instance | Disk persists across stops; on your own cloud its storage stays on your bill, and Core archives a stopped environment after 3 days | Disk saved every minute and on every stop; a stopped sandbox keeps its disk and costs nothing |
| Buying it | Self-serve Developer, Team and Scale plans billed in MCUs | New Core subscriptions are closed; new customers buy Enterprise through sales | Self-serve plans from $20 a month, with a free trial |
| Driving it from code | Python and TypeScript SDKs, open source under Apache-2.0, on self-serve plans | Python, TypeScript and Go SDK on the Enterprise plan only | API and SDK on every plan, including the trial |
| Coding agents | You install the agent, then drive it through a tmux API that sends keys and reads the screen | Codex Agent started from chat, a Linear issue or an automation; Claude Code you run yourself | Seven agents preinstalled, including Claude Code and Codex, with a prompt, steer and events API |
| Desktop and computer use | Browser-based remote desktop; you install the browser and any computer use agent yourself | Browser IDE, VS Code and JetBrains; no graphical desktop inside the environment | 60fps Linux desktop with Chromium and a computer use API, embeddable in your app |
| Keeping keys out of the machine | Responses Proxy for model APIs; other secrets are handed to the machine | Secrets are injected as environment variables or files | Credentials proxy for model providers and any HTTPS API; a credential can switch to another account when credits run out |
| Reaching the machine | Named HTTP services with optional API key auth; SSH through Morph's gateway; no raw TCP | HTTPS URL per port for you, your organization or everyone; SSH; no raw TCP documented | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| IDE for your engineers | Devboxes with SSH and preview URLs | Browser, VS Code and JetBrains IDEs with Dev Container configs and scheduled prebuilds | SSH, HTTPS ports and a desktop; not a team IDE |
| GPUs | None | GPU instance types on Enterprise runners, such as one NVIDIA A10G with 16 vCPU and 64 GB | None |
| Guest systems | Linux, with experimental Windows and macOS (x86) | Linux | Linux |
| Where it runs | Regions not published | Enterprise runners in your own AWS or GCP account, in many regions; Ona Cloud in Frankfurt and North Virginia for existing Core subscribers | EU only (Germany, Finland, France), with zero data retention |
Every feature Battleships tracks (43)
| Feature | Morph Cloud | Ona | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | Yes | 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 | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | No | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | Yes | Yes | Yes |
| MCP server | No | No | No |
| GPU | No | Yes | No |
| Windows | Yes | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Yes | No | No |
| SSO | Not published | Yes | No |
| SOC 2 | Not published | Yes | No |
| HIPAA | Not published | No | No |
| EU data residency | Not published | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Morph Cloud or Ona: neither is in the hpc-sandbox-benchmarks run. bochka 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. Morph's under 250 ms snapshot restore measures start time, not CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Morph Cloud and Ona 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 | Morph Cloud, a month | Ona, a month | bochka, 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 | $32 · Developer | $5,030 · Enterprise (AWS Marketplace 12-month contract) · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $121 · Team | $5,140 · Enterprise (AWS Marketplace 12-month contract) · with limits | $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 | $1,459 · Scale | $6,521 · Enterprise (AWS Marketplace 12-month contract) · 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 | $325 · Scale | $5,432 · Enterprise (AWS Marketplace 12-month contract) · 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 | $869 · Scale | $5,955 · Enterprise (AWS Marketplace 12-month contract) · with limits | $2,000 · $2000/mo · with limits |
Morph Cloud: Morph bills MCUs at $0.05 each: per hour, a machine uses the largest of its vCPUs, its RAM in 4 GiB steps or its disk in 16 GiB steps. Team ($40 a month) and Scale ($250 a month) are prepaid MCU bundles at a discount, and a paused VM bills only its snapshot.
Ona: New Core subscriptions are closed, so the Ona prices here use its Enterprise listing on AWS Marketplace: a 12-month, $60,000 contract, with compute paid on your own AWS bill. Real Enterprise prices are negotiated with sales.
Ona: Plans start at $20 a month, and the whole fee is usage credit spent per second while a sandbox runs. 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 the table assumes 3 environments at once since Ona publishes no Enterprise limit. An Ona agent also stops after 30 idle minutes unless auto-stop is set to Never. Morph fits every scenario, but disk above 16 GiB per MCU raises the bill, egress prices are not published, and its Developer pool of 64 vCPU holds only 16 machines at 4 vCPU. bochka has no session cap, but at 1,000 short jobs at once its $2,000 plan queues the starts, while Morph Scale fits.
| Scenario | Morph Cloud | Ona | bochka |
|---|---|---|---|
| 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 Morph Cloud when
your agents branch from one running state with its memory, sleep between requests and wake on demand, or need experimental Windows and macOS guests.
- Memory branching and wake on request. Useful for agents that fan out from one running state or sleep between requests: copies keep memory and paused VMs wake on demand.
- Self-serve VMs you drive from code. Useful if you want to start agent machines from code today: Morph's plans are self-serve, with Python and TypeScript SDKs.
- Windows and macOS guests. Morph lists experimental Windows and macOS (x86) guests for agents that must work in those systems.
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: browser, VS Code and JetBrains IDEs with Dev Containers and prebuilds.
- Runs in your own cloud. Useful if environments must run inside your own AWS or GCP account: Ona's Enterprise runners do that in many regions.
- GPU environments. Useful if your agents need a GPU: Ona's Enterprise runners can use GPU instance types, such as an A10G VM.
Where bochka fits
Look at bochka if your code starts the agents and you want them to arrive ready: coding agents you prompt and steer by API, a desktop with Chromium, /dev/kvm and keys kept outside the machine. Morph gives you an empty VM to set up yourself, and Ona is a team IDE whose API needs an Enterprise contract.
Coding agents you drive from outside
On Morph you install the agent and drive it through tmux by sending keys and reading the screen. On Ona the managed agent is Codex, and the SDK to start environments from code is Enterprise only.
Machines that keep their work
On Morph a plain stop deletes the instance, so you must pause or snapshot and pay for that storage. Ona cannot copy an environment, and Core archives a stopped one after 3 days. bochka saves the disk every minute and keeps stopped sandboxes free.
A desktop, /dev/kvm, raw TCP and safe keys
Morph's nested virtualization is experimental, and Ona documents no /dev/kvm or graphical desktop. Neither has raw TCP, and both hand most secrets to the machine, where a prompt injection can leak them.
Use bochka when your code starts and drives the agents: coding agents preinstalled, a 60fps desktop with Chromium, /dev/kvm, keys kept outside the machine, and disks that are saved every minute and fork while running. Compare it one to one: bochka vs Morph Cloud and bochka vs Ona.
Questions people ask
Is Morph Cloud cheaper than Ona?
In every scenario we priced, yes, using Ona's Enterprise listing on AWS Marketplace: one coding agent on workdays is $32 a month on Morph and $5,030 on Ona, and one agent running all month is $121 against $5,140. On bochka those are $20 and $26. Ona's real price is a sales quote, so yours may differ.
Which is faster, Morph Cloud or Ona?
Neither has a comparable CPU measurement, so we cannot say. bochka did 26.69 runs per second on the hpc-sandbox-benchmarks Node.js loop at 4 vCPU / 8 GB. Morph restores a snapshot in under 250 ms, which is start time, not CPU speed.
Can Morph Cloud and Ona run Docker?
Both give you root and Docker inside an isolated VM. Morph lists nested virtualization as experimental, and Ona does not document it. bochka exposes /dev/kvm on every machine for Android emulators and VMs.
Can I still sign up for Ona?
Not on a self-serve plan. Ona's billing docs say new Core subscriptions are no longer available, so new customers go through sales for Enterprise. Morph and bochka both have self-serve plans.
Can I run Claude Code on Morph Cloud or Ona?
Yes, on both you install it and run it yourself. On Morph you drive it through a tmux API that sends keys and reads the screen, and Ona's managed agent is Codex. bochka ships Claude Code, Codex and others preinstalled, with one API to prompt, steer and watch them.
Do Morph Cloud or Ona support computer use?
Morph has browser-based remote desktop access, but you install the browser and any computer use agent yourself. Ona environments have no graphical desktop. bochka ships a 60fps desktop with Chromium and a computer use API in every sandbox.
Try bochka
Install the CLI, then run bochka new.
Product preview