Modal vs Ona
Modal is a serverless AI cloud whose sandboxes are short-lived containers you start from code, next to its GPUs. Ona, formerly Gitpod and now part of OpenAI, gives engineers and its Codex agent long-lived cloud dev environments, sold through sales.
The companies and products
Modal
Modal is a serverless cloud for AI work: inference, training, batch jobs and sandboxed code, all driven from Python, TypeScript or Go code.
Modal Sandboxes are containers you create from code, run commands in, and then terminate. By default they run under gVisor, a user-space kernel from Google; since October 2026 you can also pick a VM runtime with its own Linux kernel for Docker and FUSE (Battleships tracks that as a separate card, Modal VM Sandboxes). It suits teams that already run models on Modal and want short-lived, scalable code execution next to their GPUs.
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. “19th cheapest of 345” means 18 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 | Modal: 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 | Can't run it | 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 always-on agent hits Modal's 24-hour sandbox limit, and on Ona it needs auto-stop set to Never; bochka has no session cap on paid plans. | 196th of 366, with limits $1,924 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 Huge numbers of short code runs are what Modal is built for, with fast starts and up to 5,000 containers on Team; Ona is built for long developer sessions instead. | 19th cheapest of 345 $181 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 Modal fits handing short sandboxes to your users, while Ona is built for your own engineers; bochka also fits, and a stopped bochka sandbox keeps its disk for free. | 11th cheapest of 361 $811 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 RL rollouts launch many short sandboxes at once, which suits Modal; Ona's environments start from Dev Container configs for people and agents working for hours. | 5th cheapest of 360 $19,038 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 | 59th cheapest of 364 $1,244 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 CI jobs that build Docker images run on Ona and on Modal's VM runtime but not its default sandbox; bochka runs Docker in every sandbox. | 126th cheapest of 377 $1,793 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, while a Modal sandbox lasts at most 24 hours and resets outside Volumes; bochka is a full VM that keeps its disk. | 138th of 368, with limits $23 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 Neither Modal nor Ona ships a graphical desktop to drive, while bochka streams a 60fps desktop with Chromium and a computer-use API. | 98th of 369, with limits $183 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 | 177th of 367, with limits $136 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 | 267th of 346, with limits $394 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 | 223rd of 338, with limits $8,795 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 | Can't run it | 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 Modal rents GPUs from T4 to B300 next to its sandboxes, so it is the pick for GPU eval jobs; bochka has no GPUs. | 19th cheapest of 98 $1,187 a month | 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 | Modal | Ona | bochka |
|---|---|---|---|
| What it is | Serverless AI cloud; sandboxes are containers you create from code and terminate | Cloud dev environment platform for engineers and the Codex Agent | Sandbox API: full VMs you create, fork and stop from code |
| Isolation | gVisor by default; VM runtime with its own kernel available | Isolated VM per environment, built from a Dev Container config | Full VM with its own kernel, every sandbox |
| Docker and nested virtualization | Docker only with the VM runtime; nested virtualization on request on Team and Enterprise | Docker and root inside the Dev Container; nested virtualization not documented | Docker, root, systemd and /dev/kvm on every machine |
| Desktop and computer use | Not offered; an example shows how to set up VNC yourself | Browser IDE, VS Code and JetBrains; no graphical desktop | 60fps desktop, Chromium and computer-use API built in |
| Files after a stop | No paused state; a finished sandbox is gone, only Volumes keep files | Disk persists across stops; storage billed while stopped in your cloud, Core archives after 3 days | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Longest session | 24 hours (default 5 minutes) | No hard cap; stops after 30 idle minutes by default, can be set to Never | No cap on paid plans |
| Fork | Snapshot the filesystem into an image and boot new sandboxes from it | No environment copy; start new environments from a config or prebuild | Fork a running sandbox without stopping it |
| Starting point | Build images in code or pull any linux/amd64 registry image | Dev Container config per repo, with scheduled prebuilds | Named snapshots used as templates; no Dockerfile builds |
| Driving it from code | Python, TypeScript and Go code, self-serve | SDK on the Enterprise plan only | API and SDK on every plan, including the trial |
| Coding agents and keys | Examples only; secrets are environment variables or your own sidecar proxy | Codex Agent built in; secrets injected as environment variables or files | Claude Code, Codex and others preinstalled with an API; credentials proxy keeps real keys out |
| Reaching the sandbox | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | HTTPS URL per port and SSH; no raw TCP documented | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | GPU instance types on Enterprise runners, such as one A10G | None |
| Where it runs | Modal's cloud in the US, EU and Asia-Pacific; region pinning costs 1.15x to 1.75x | Enterprise runners in your own AWS or GCP account | EU only: Germany, Finland, France |
| Buying it | Self-serve: free Starter, Team at $250 a month | Through sales; new Core subscriptions are closed | Self-serve plans from $20 a month, with a free trial |
Every feature Battleships tracks (43)
| Feature | Modal | Ona | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | No | 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 | No | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | No | No | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Not published | No | Yes |
| Audit logs | Yes | No | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In the same public benchmark run on 29 September 2026 at 4 vCPU / 8 GB, Modal's default gVisor sandbox finished 12.79 Node.js build-and-test runs per second and bochka finished 26.69, about twice the work. Ona was not in that benchmark, so there is no comparable measurement for it.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal measured on: Sandbox (gVisor), request = size, any region. 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 | Modal, 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 | $15 · Starter · with limits | $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 | $178 · Starter · with limits | $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 | $2,229 · Starter · with limits | $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 | $792 · Team | $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 | $3,193 · Team · with limits | $5,955 · Enterprise (AWS Marketplace 12-month contract) · with limits | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for the higher of what you request and what you use, and an idle sandbox pays until it is terminated. Starter is free with $30 of monthly credit; Team is $250 a month with $100 of credit.
Ona: New Core subscriptions are closed, so these prices use Ona's 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.
Ona: bochka 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.
Limits in those scenarios
On Modal, a sandbox lives at most 24 hours and only Volumes keep files, and the 50-agent fleet does not fit the default sandbox because Docker needs the VM runtime. No Ona scenario fits as published, because new customers can only buy Enterprise through sales, and Ona publishes no Enterprise concurrency limit, so the table assumes 3 environments at once. On bochka the limit is starts per minute, so 1,000 jobs at once queue for several minutes.
| Scenario | Modal | 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 |
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Modal when
your sandboxes need GPUs, run outside Europe, or come in huge bursts of short jobs that finish in minutes.
- GPUs on the same platform. Useful if your agent trains or runs models: Modal rents GPUs from T4 to B300 next to its sandboxes.
- Huge bursts of short jobs. Useful for code runs and rollouts that finish in minutes: Modal starts fast and runs up to 5,000 containers on Team.
- Self-serve and driven from code. Useful if you want to start today: Modal has a free Starter plan and is driven from Python, TypeScript or Go code.
Use Ona when
your engineers want a governed cloud IDE shared with a Codex agent, running inside your own AWS or GCP account.
- A full cloud IDE for your team. Useful if engineers share environments with agents: Ona has browser, VS Code and JetBrains IDEs, Dev Containers and prebuilds.
- Runs in your own cloud. Useful if environments must live inside your own AWS or GCP account: Ona's Enterprise runners do that.
- Long sessions with a kept disk. Useful for work that spans days: an Ona environment keeps its disk across stops and has no hard session cap.
Where bochka fits
If your code starts and drives agents that work for hours or days, look at bochka. Modal's sandboxes end within 24 hours and Ona sells its SDK only on Enterprise, while bochka gives every plan an API to full VMs that keep their disk, fork while running and have a desktop built in.
A full VM that keeps its work
On Modal a sandbox ends within 24 hours and its root disk goes with it unless your code saves to a Volume. On Ona the disk stays on your cloud bill while stopped. bochka saves every minute and stops for free.
Fork a warm machine
Neither Modal nor Ona can copy a running machine: Modal boots new sandboxes from a filesystem snapshot, and Ona rebuilds from a config or prebuild. bochka forks a running sandbox, with its files, without stopping it.
Desktop, /dev/kvm and agents inside
Neither ships a desktop to drive, Modal needs its VM runtime for Docker, and Ona documents no /dev/kvm. bochka has all three, plus Claude Code and Codex you drive from outside, with real keys kept out by a credentials proxy.
Use bochka when your code starts and drives agents that work for hours or days: full VMs with Docker, /dev/kvm and a desktop, an API on every plan, and machines that keep their disk and fork while running. Compare it one to one: bochka vs Modal and bochka vs Ona.
Questions people ask
Is Modal cheaper than Ona?
In every scenario we priced, yes: one agent running all month is $178 on Modal against $5,140 on Ona, and 300 user sandboxes are $792 against $5,432. Ona's numbers use its Enterprise listing on AWS Marketplace, since new Core subscriptions are closed, so a sales quote may differ. On bochka those two scenarios cost $26 and $200 a month.
Which is faster, Modal or Ona?
We cannot say: Ona was not in the public benchmark we use. Modal's default sandbox finished 12.79 Node.js build-and-test runs per second at 4 vCPU / 8 GB, and bochka finished 26.69 in the same run.
Can Modal or Ona run Docker?
Ona runs Docker with root inside its Dev Container. Modal runs Docker only with its VM runtime, not in the default gVisor sandbox. Every bochka sandbox runs Docker with no extra setting.
How long can a session last?
A Modal sandbox lasts at most 24 hours, with a 5-minute default. Ona has no hard cap, but stops an environment after 30 idle minutes by default unless auto-stop is set to Never. bochka has no session cap on paid plans.
Is Ona the same as Gitpod?
Yes. Gitpod renamed itself Ona in 2025, and Ona is now part of OpenAI. New customers buy it through sales.
Which one has GPUs?
Both. Modal rents GPUs from T4 to B300 on its own platform, and Ona's Enterprise runners can use GPU instance types such as an A10G in your own cloud. bochka has no GPUs.
Try bochka
Install the CLI, then run bochka new.
Product preview