Ona vs Modal VM Sandboxes
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. Modal VM Sandboxes are real Linux VMs you start from Python, TypeScript or Go code, built for many short jobs that end within 24 hours.
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 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.
Modal VM Sandboxes
Modal is a serverless cloud for AI work, and VM Sandboxes are the version of its sandboxes that run in a virtual machine with their own Linux kernel.
You create a VM Sandbox from Python, TypeScript or Go code with runtime="vm", run commands in it, and terminate it when the job is done. Modal built the runtime on the Rust-based Cloud Hypervisor, so Docker, FUSE, systemd and nested cgroups work, with the same API, images and prices as its gVisor sandboxes. It became generally available on 1 October 2026 and suits teams that want many short-lived agent machines next to Modal's inference and training.
- Funding
- Over $466M raised
- Generally available
- 1 October 2026; early customers launched over 20 million VMs before that
- Session length
- Default 5 minutes, maximum 24 hours
- Compliance
- SOC 2 on every plan; HIPAA on Enterprise
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 | Modal VM Sandboxes: price rank | bochka: 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 but its SDK is Enterprise only, Modal ends each VM within 24 hours, and bochka keeps a full VM with its disk and a desktop to check the app. | 324th of 367, with limits $7,315 a month | 84th of 367, with limits $759 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on agent on Ona needs auto-stop set to Never, Modal VM Sandboxes stop at 24 hours, and bochka has no session cap on paid plans. | 83rd of 366, with limits $8,504 a month | Can't run it | 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 | Can't run it | 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, not for handing machines to your users; Modal fits short user sessions, and bochka keeps a returning user's disk for free while stopped. | 330th of 361, with limits $5,988 a month | Can't run it | 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 Huge bursts of short rollouts are what Modal is built for; Ona is not made for this, and bochka's per-plan start limits queue very large bursts. | 283rd of 360, with limits $9,773 a month | 171st of 360, with limits $16,322 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 | Can't run it | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Ona starts each run from a prebuild and Modal from an image or filesystem snapshot, while bochka can fork a warm machine and gives /dev/kvm on every plan. | 365th of 377, with limits $5,461 a month | 188th of 377, with limits $1,064 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Ona is the stronger dev box of the two, with Dev Containers, prebuilds and browser, VS Code and JetBrains IDEs; a Modal VM ends within 24 hours. | 368th of 368, with limits $5,140 a month | Can't run it | 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 Modal ships a graphical desktop; bochka streams a 60fps desktop with Chromium and a computer-use API. | 353rd of 369, with limits $5,691 a month | Can't run it | 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 | Can't run it | 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 | Can't run it | 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 | Can't run it | 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 bochka can fork one prepared machine into many while it runs; Modal boots new sandboxes from a filesystem snapshot, and Ona starts new environments from a config. | 93rd of 360, with limits $5,228 a month | 294th of 360, with limits $642 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 | Modal VM Sandboxes | bochka |
|---|---|---|---|
| Isolation | Isolated VM per environment with dedicated compute, built from a Dev Container config | VM per sandbox on Cloud Hypervisor, with its own Linux kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker and root | Docker and root inside the Dev Container | Docker, systemd and root; you start dockerd yourself as the entrypoint | Docker, root and systemd in every sandbox |
| Nested virtualization | Not documented on its VM classes | Team and Enterprise plans only, on request | /dev/kvm on every plan |
| CPU benchmark (4 vCPU / 8 GB) | Not measured | 15.54 runs/s | 26.69 runs/s |
| Longest session | No hard cap; stops after 30 idle minutes by default, background work does not count, can be set to Never | 24 hours at most (default 5 minutes) | No cap on paid plans; runs until you stop it |
| Files after a stop | Disk persists, billed on your cloud while stopped; Core archives a stopped environment after 3 days | No paused state; only Volumes and snapshots keep files | Saved every minute and on stop; a stopped sandbox keeps its disk and costs nothing |
| Copies of a machine | No environment copy; you can create a project from an environment's config | Snapshot the filesystem into an image and boot many new sandboxes from it | Fork a running sandbox with its disk |
| Memory snapshots | No | Alpha: snapshotting ends the sandbox and snapshots expire after 7 days | No; resume boots the VM again |
| Driving it from code | Python, TypeScript and Go SDK on the Enterprise plan only | Python, TypeScript and Go on every plan | API and SDK on every plan, including the trial |
| Desktop and computer use | Browser IDE, VS Code and JetBrains; no graphical desktop | Not offered; an example shows how to set up Xvfb and VNC yourself | 60fps desktop, Chromium and computer-use API built in |
| Coding agents and keys | Managed Codex Agent; secrets injected as environment variables or files | Examples only; secrets are environment variables, or your own proxy in a sidecar | Claude Code, Codex and more preinstalled with a prompt, steer and events API; a credentials proxy keeps real keys out |
| Network | HTTPS URL per port and SSH; no raw TCP or public IP documented | Encrypted and raw TCP tunnels, inbound IP allowlist, outbound block or domain allowlist | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP; open outbound internet |
| GPUs | GPU instance types on Enterprise runners, such as one NVIDIA A10G | None on the VM runtime; GPU sandboxes need gVisor | None |
| Where it runs | Enterprise runners in your own AWS or GCP account, in many regions | Modal's cloud in the US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Ona | Modal VM Sandboxes | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Yes | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | No | No | 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 | Yes | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Yes | 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 | No | Yes |
| Agent harness API | Yes | No | 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 | 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 | Not published | Yes |
| Audit logs | No | Yes | 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: it was not in the public benchmark runs we use. In StarSling's run of 29 September 2026 at 4 vCPU / 8 GB, Modal's VM runtime did 15.54 Node.js build-and-test runs per second and bochka did 26.69, so bochka did about 1.7 times the CPU work in the same time. This measures CPU speed only, not start time.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal VM Sandboxes measured on: VM Sandbox, request = size. Ona has 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 | Modal VM Sandboxes, 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 | $5,030 · Enterprise (AWS Marketplace 12-month contract) · with limits | $15 · Starter · with limits | $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 | $178 · Starter · 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 | $6,521 · Enterprise (AWS Marketplace 12-month contract) · with limits | $2,229 · Starter · 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 | $792 · Team | $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,193 · 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.
Modal VM Sandboxes: Modal bills VM Sandboxes by the second for the higher of what you request and what you use, until the sandbox ends. Starter is free with $30 of monthly credit, Team is $250 a month with $100 of credit, and egress above the free allowance costs $0.04 per GiB.
Modal VM Sandboxes: Plans start at $20 a month and the whole fee becomes usage credit, spent by the 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. A Modal VM Sandbox lives at most 24 hours and keeps only files in a Volume or snapshot, so the workday, always-on and fleet scenarios do not fit there; its 1,000-job burst runs on shared CPU above the request. On bochka the limit that bites is start speed: even the $2,000 plan starts 90 sandboxes a minute, so 1,000 jobs at once queue and exceed the daily start limit.
| Scenario | Ona | Modal VM Sandboxes | 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 | 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 engineers work next to their agents: Ona has Dev Containers, prebuilds and browser, VS Code and JetBrains IDEs.
- Runs in your own cloud. Useful if environments must live inside your own AWS or GCP account: Ona's Enterprise runners provision them there.
- GPU environments. Useful if agents need a GPU: Ona's Enterprise runners can use GPU instance types, which Modal's VM runtime does not offer.
Use Modal VM Sandboxes when
you run huge bursts of short jobs that finish within a day, need strict outbound rules or regions outside Europe, or already run models on Modal.
- Self-serve, from code. Useful if you want to start today: Modal has a free Starter plan and an SDK on every plan, while Ona goes through sales.
- Very large bursts of short jobs. Useful for huge bursts that finish within a day: Modal runs 5,000 containers at once on Team.
- Network rules. Useful if agents must reach only chosen hosts: Modal can block outbound traffic or allow only certain IP ranges or domains.
Where bochka fits
If your code starts and drives agents that work for hours or days, look at bochka. Ona is a team IDE whose API sits behind an Enterprise contract, and Modal's VMs end within 24 hours; bochka gives every plan full VMs that keep their disk, fork while running and come with a desktop and agents ready.
Machines that keep their work
A Modal VM is gone after 24 hours unless you write snapshot or Volume code, and Ona's stopped disk stays on your cloud bill or is archived after 3 days on Core. bochka saves every minute and a stopped sandbox costs nothing.
/dev/kvm, a desktop and agents built in
Ona documents no /dev/kvm or desktop, and Modal gives /dev/kvm only on Team or Enterprise on request, with VNC and the agent harness left to you. bochka has /dev/kvm, a 60fps desktop and Claude Code, Codex and others on every plan.
Faster CPU, fork and kept-out keys
bochka did 26.69 runs/s against Modal's 15.54, so each build waits less. It forks a running machine instead of rebuilding from a prebuild or image, and its credentials proxy keeps real keys out of env vars an injected prompt could read.
Use bochka when your code drives agents that work for hours or days: full VMs with /dev/kvm, a desktop and open ports, an API on every plan, and machines that keep their disk and fork while running. Compare it one to one: bochka vs Ona and bochka vs Modal VM Sandboxes.
Questions people ask
Is Ona cheaper than Modal VM Sandboxes?
No, not in any scenario we priced, using Ona's Enterprise listing on AWS Marketplace: one agent all month is $5,140 on Ona against $178 on Modal, and 300 user sandboxes are $5,432 against $792. On bochka those cost $26 and $200. Ona's real Enterprise price is a sales quote.
Which is faster, Ona or Modal VM Sandboxes?
Ona has no comparable measurement. On the same CPU test at 4 vCPU / 8 GB, Modal's VM runtime did 15.54 runs per second and bochka did 26.69.
Can Ona and Modal VM Sandboxes run Docker?
Yes. Ona runs Docker with root inside the Dev Container, and Modal runs Docker in its VM once you start dockerd as the entrypoint. For Android emulators, Modal offers nested virtualization on Team and Enterprise on request, Ona does not document it, and bochka has /dev/kvm on every plan.
How long can a session run on each?
A Modal VM Sandbox runs 5 minutes by default and 24 hours at most. Ona has no hard cap but stops after 30 idle minutes by default, and background work does not count as activity unless auto-stop is set to Never. bochka has no session cap on paid plans.
Can I sign up for either today?
Modal has a free Starter plan with $30 of monthly credit. Ona's billing docs say new Core subscriptions are no longer available, so new customers go through sales for Enterprise. bochka's plans are self-serve, from a free trial up.
Is bochka SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.
Try bochka
Install the CLI, then run bochka new.
Product preview