Daytona vs Ona
Daytona is a sandbox API: your code creates containers or Linux VMs for agent jobs, paid from a prepaid wallet. 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
Daytona
Daytona is a cloud for running AI-generated code: you create sandboxes from code through its API and SDKs.
By default a Daytona sandbox is a Linux container with its own namespaces and reserved vCPU, memory and disk. You can also pick a Linux VM class (pause, fork, memory snapshots, /dev/kvm), a Windows VM class, or a GPU class with Nvidia and AMD cards. It is built for teams that run agent code, code interpreters and evals through Python, TypeScript, Ruby, Go or Java SDKs.
- Founded
- 2023
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. “15th cheapest of 367” means 14 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 | Daytona: 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 Daytona fits a software factory through its API, while Ona needs the Enterprise SDK to start environments from code; bochka adds /dev/kvm on every machine. | 15th cheapest of 367 $4,111 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 | 24th cheapest of 366 $6,104 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 Daytona creates hundreds of sandboxes a minute with no plan fee, which suits short code runs; Ona, a dev environment platform, is not built for that. | 25th cheapest of 345 $271 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 Daytona hands sandboxes to your users through an API but needs a custom limit above 500 vCPU, while Ona is built for your own engineers and defaults to 10 running environments per user. | 154th of 361, with limits $2,000 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 | 130th of 360, with limits $8,261 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 | 189th of 364, with limits $2,000 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 Neither is a great CI fit: Daytona caps a sandbox at 4 vCPU by default and Ona starts each run from a prebuild, while bochka has /dev/kvm and forks warm machines. | 308th of 377, with limits $805 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 Daytona keeps billing the disk of a stopped sandbox; bochka is a full VM that costs nothing while stopped. | 183rd of 368, with limits $245 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 Daytona has a VNC desktop and a computer-use API on Linux and Windows, and Ona has no graphical desktop; bochka streams a 60fps desktop with Chromium. | 26th cheapest of 369 $1,198 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 | 93rd of 367, with limits $598 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 | 38th cheapest of 346 $404 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 | 202nd of 338, with limits $8,073 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 | 12th cheapest of 360 $2,000 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 Only Daytona fits here: it rents Nvidia and AMD GPUs by the hour, while Ona's GPUs run in your own cloud and bochka has none. | 20th cheapest of 98 $1,190 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 | Daytona | Ona | bochka |
|---|---|---|---|
| What it is | A sandbox API with Python, TypeScript, Ruby, Go and Java SDKs | A cloud dev environment platform for engineers and its Codex Agent | A sandbox API with full VMs and coding agents built in |
| Signing up and driving it from code | Self-serve from a prepaid wallet with $200 of free compute; API and SDKs on every tier | New Core subscriptions are closed; Enterprise through sales, with the SDK on Enterprise only | Self-serve plans from a free trial up; API and SDK on every plan |
| Isolation | Container by default; Linux VM and Windows VM classes with their own kernel | Isolated VM with dedicated compute, built from a Dev Container config | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| CPU benchmark (4 vCPU / 8 GB) | 21.52 runs/s on the Linux VM class; the default container class reported no result | Not measured | 26.69 runs/s |
| Docker and nested virtualization | Docker in all classes; /dev/kvm only on Linux VMs, once KVM is turned on for your organization | Docker and root inside the Dev Container; nested virtualization not documented | Docker, root, systemd and /dev/kvm on every machine |
| Idle stop | Containers stop after 15 idle minutes and VMs pause after 60 by default; can be set to run indefinitely | Stops after 30 idle minutes by default; background work does not count; can be set to Never | Runs until you stop it; no session cap on paid plans |
| Files after a stop | Disk kept and billed while stopped; archived containers are free | Disk persists across stops; in your own cloud it is billed while stopped; Core archives after 3 days | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Pause and fork | Linux VM and Windows: pause, resume and fork with memory kept; containers: no pause or fork | No environment copy; you can create a project from an environment's config | Fork a running sandbox with its disk; resume boots from disk |
| Starting point | Docker images and declarative builds for containers; VM snapshots from an image | Dev Container config per repo, with prebuilds that snapshot the filesystem on a schedule | Named snapshots (templates), shareable by code; no Dockerfile builds |
| Desktop and computer use | VNC desktop and a computer-use API on Linux and Windows | Browser IDE plus VS Code and JetBrains; no graphical desktop | 60fps desktop with Chromium, computer use and an embeddable stream |
| Reaching the sandbox | HTTPS preview URLs on any port, token-protected or public; SSH; no raw TCP or public IP | HTTPS URL per port for you, your organization or everyone; SSH; no raw TCP or public IP documented | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Coding agents | Guides install agents and run them through process exec | Codex Agent started from chat, a Linear issue or an automation | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets proxy swaps placeholders in HTTPS request headers for allowed hosts | Secrets injected as environment variables or files | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| GPUs, Windows and regions | Nvidia and AMD GPUs by the hour; Windows VMs; US and EU, plus your own machines | GPU types such as an A10G in your own cloud; Enterprise runners in your AWS or GCP account | No GPUs or Windows guests; EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Daytona | Ona | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | 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) | 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 | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | Yes | Yes | No |
| Windows | Yes | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | 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 | 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
On StarSling's hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, in the run of 2026-09-29, bochka did 26.69 runs per second and Daytona's Linux VM class did 21.52, so each build takes about a quarter longer on Daytona. Daytona's default container class reported no result, and Ona was not in the benchmark, so there is no comparable measurement for either.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Daytona measured on: Linux VM sandbox (same rates; KVM / nested virt per-org feature). 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 | Daytona, 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 | $56 · Tier 3 ($500 top-up) | $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 | $245 · Tier 3 ($500 top-up) | $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,682 · Tier 3 ($500 top-up) | $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 | $2,000 · Tier 4 ($2,000 top-up every 30 days) · with limits | $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 | $2,000 · Tier 4 ($2,000 top-up every 30 days) · with limits | $5,955 · Enterprise (AWS Marketplace 12-month contract) · with limits | $2,000 · $2000/mo · with limits |
Daytona: Daytona bills per second for the vCPU, memory and disk you reserve, and keeps billing the disk while a sandbox is stopped. You pay from a prepaid wallet: open internet needs a $500 top-up (Tier 3), and the biggest pool needs $2,000 every 30 days (Tier 4).
Ona: New Core subscriptions are closed, 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.
Ona: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Daytona limits the total vCPU running at once, up to 500 vCPU on Tier 4, so 300 user sandboxes (600 vCPU) and 1,000 short jobs at once need a custom limit, and Tier 1 and 2 reach only package registries, git and AI APIs. No Ona scenario fits as published, because new customers can only buy Enterprise through sales, and the table assumes 3 environments at once since Ona publishes no Enterprise limit. For 1,000 short jobs at once, bochka's $2,000 plan also falls short, because it caps starts per hour and per day.
| Scenario | Daytona | 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 Daytona when
your code creates sandboxes through an API and needs GPUs, Windows, memory pause or a US region.
- A self-serve sandbox API. If your code starts the machines, Daytona has self-serve tiers and SDKs, while Ona's SDK needs an Enterprise contract.
- Memory pause, Windows and fork. If a sandbox must pause and come back with its memory, or run Windows, Daytona's VM classes do both.
- GPUs by the hour. If your agents train or test models, Daytona rents Nvidia and AMD GPUs by the hour, from RTX 4090 to B300.
Use Ona when
your engineers want a governed cloud IDE shared with a Codex agent, inside your own AWS or GCP account.
- A full cloud IDE for your team. If engineers work in the same environments as their agents, Ona has browser, VS Code and JetBrains IDEs with prebuilds.
- Runs in your own cloud. If environments must run inside your own AWS or GCP account, Ona's Enterprise runners do that by default.
- One config per repo. If every developer and agent should get the same setup, Ona builds each environment from the repo's Dev Container config.
Where bochka fits
If your code starts agents that build, test and run Docker for hours, look at bochka. Daytona's default is a shared-kernel container and Ona is a team IDE sold through sales, while bochka gives each agent a full, faster VM with an API on every plan. bochka is not the pick for GPUs, Windows, runs outside the EU or memory pause.
A full VM with /dev/kvm on every machine
Android emulators and microVMs need /dev/kvm. On Daytona you get it only on the Linux VM class once KVM is turned on for your organization, and Ona does not document it. bochka has it on every machine.
Machines that keep their work for free
Daytona and Ona both keep billing the disk of a stopped machine, and Core archives it after 3 days. Ona has no fork. bochka saves the disk every minute, stops for free and forks a running sandbox.
Faster CPUs and agents built in
bochka did 26.69 runs per second against 21.52 for Daytona's VM class, and Ona was not measured. Claude Code, Codex and more come preinstalled, with a 60fps desktop, raw TCP and a credentials proxy for any HTTPS API.
Use bochka when your agents do real work for hours: builds, Docker, emulators and a desktop on a faster full VM that stops for free, driven by an API on every plan. Compare it one to one: bochka vs Daytona and bochka vs Ona.
Questions people ask
Is Daytona cheaper than Ona?
In the scenarios we priced, yes: one coding agent on workdays is $56 a month on Daytona and $5,030 on Ona, and 50 agents in parallel are $2,682 against $6,521. Ona's numbers use its Enterprise listing, since new Core plans are closed, and real quotes come from sales. bochka is $20 and $317 for the same two.
Which is faster, Daytona or Ona?
Ona has no comparable CPU measurement. Daytona's Linux VM class did 21.52 runs per second on the hpc-sandbox-benchmarks test at 4 vCPU / 8 GB, and bochka did 26.69 in the same run.
Can Daytona and Ona run Docker?
Both run Docker inside the sandbox. Daytona gives /dev/kvm only on its Linux VM class, once KVM is turned on for your organization, and Ona does not document nested virtualization. bochka has /dev/kvm on every machine.
Can I still sign up for Ona?
Not self-serve. Ona's billing docs say new Core subscriptions are no longer available, so new customers go through sales for Enterprise. Daytona and bochka both have self-serve plans.
Are Daytona sandboxes containers or VMs?
Both. The default class is a Linux container, and Daytona also offers Linux VM and Windows VM classes with their own kernel, which add pause, fork and memory snapshots. Ona gives each environment its own VM, and so does bochka.
Is Ona the same as Gitpod?
Yes. Gitpod renamed itself Ona in 2025, and Ona is now part of OpenAI. Its managed agent is Codex.
Try bochka
Install the CLI, then run bochka new.
Product preview