Ona vs smol machines
Ona, formerly Gitpod and now part of OpenAI, gives engineering teams and its Codex agent governed cloud dev environments, sold through sales and run in your own AWS or GCP account. smol machines gives code its own Linux microVMs through a self-serve API, with live branching and an open-source engine that also runs on your laptop or servers.
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.
smol machines
smol machines makes fast, isolated Linux microVMs that run the same way on your laptop, in their hosted cloud, or on your own servers.
The core is smolvm, an open-source microVM engine built on libkrun, where each machine has its own guest kernel. smol cloud is the paid hosted service that runs fleets of those machines behind a REST API and Node, Python and Rust SDKs. It is built for developers who want one VM model from local development to production, with live branching of running machines.
- Uptime SLA
- 99.95% on Pro, Startup and 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 | smol machines: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Ona and smol machines both run Docker inside the VM, but neither documents /dev/kvm on hosted machines, and Ona's SDK to start them from code is Enterprise only; bochka has both. | 324th of 367, with limits $7,315 a month | 73rd of 367, with limits $604 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB On Ona an always-on assistant needs auto-stop set to Never, and smol cloud has no desktop, browser or key proxy; bochka has all three built in. | 83rd of 366, with limits $8,504 a month | 148th of 366, with limits $1,038 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 smol machines fits short code runs well, with a one-minute minimum and a /code endpoint for Python and JavaScript, while Ona is a dev environment sold through sales. | 335th of 345, with limits $5,320 a month | 12th cheapest of 345 $140 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 rather than your users; smol machines wakes a stopped machine on the next command, and bochka adds a desktop, 50 ports and a credentials proxy. | 330th of 361, with limits $5,988 a month | 7th cheapest of 361 $531 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 smol machines can branch a running machine with its memory and processes, Ona cannot copy an environment at all, and bochka forks a running sandbox with its disk. | 283rd of 360, with limits $9,773 a month | 111th of 360, with limits $6,978 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 | 36th cheapest of 364 $670 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 Ona starts each run from a prebuild with no fork; smol machines and bochka both fit, but only bochka exposes /dev/kvm for Android builds or VMs. | 365th of 377, with limits $5,461 a month | 66th cheapest of 377 $514 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, but only on an Enterprise contract today; smol cloud has no SSH and bills a stopped disk, while bochka is a full VM over SSH that costs nothing stopped. | 368th of 368, with limits $5,140 a month | 216th of 368, with limits $29 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 smol cloud has a hosted desktop, so a computer-use agent has no screen until you build one; bochka streams a 60fps desktop with Chromium. | 353rd of 369, with limits $5,691 a month | 90th of 369, with limits $156 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 | 176th of 367, with limits $136 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 | 241st of 346, with limits $242 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 | 148th of 338, with limits $4,344 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 | 93rd of 360, with limits $5,228 a month | 252nd of 360, with limits $377 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 | smol machines | bochka |
|---|---|---|---|
| Isolation | Each environment is an isolated VM with dedicated compute, built from a Dev Container config | libkrun microVM with its own guest kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker and nested virtualization | Docker and root inside the Dev Container; nested virtualization not documented | Docker inside the VM; nested virtualization not exposed in the cloud API, a local smolvm flag only | Docker, root, systemd and /dev/kvm on every machine |
| Desktop and computer use | Browser IDE plus VS Code and JetBrains; no graphical desktop in the environment | No hosted desktop; a guide shows running your own Chromium inside a machine | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Files after a stop | Disk persists, and in your own cloud it is billed while stopped; Core archives a stopped environment after 3 days | Filesystem survives, /tmp and memory paths are emptied; stopped disk keeps billing | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Fork | No environment copy; you can create a project from an environment's config | Branch a running machine with its memory and processes; checkpoints capture RAM to a file | Fork a running sandbox with its disk |
| Starting point | Dev Container config per repo, with prebuilds that snapshot the filesystem on a schedule | OCI images, registry images and packed .smolmachine artifacts | Named snapshots (templates), shareable by code; no Dockerfile builds |
| Idle stop and wake | Stops after 30 minutes without SSH, IDE or agent activity by default; background work does not count; can be set to Never | A command or terminal starts a stopped machine; idle apps wake on the next request | Runs until you stop it, no session cap on paid plans; a stopped sandbox is started by API |
| Driving it from code | Python, TypeScript and Go SDK on the Enterprise plan only | REST API with Node, Python and Rust SDKs | API and SDK on every plan, including the trial |
| Coding agents | Codex Agent started from chat, a Linear issue or an automation; Claude Code you run yourself | Registry images with the Codex CLI and the Harbor eval harness, run through the command API | Seven agents preinstalled, including Claude Code and Codex, with a prompt, steer and events API |
| Reaching the machine | SSH and IDEs; an HTTPS URL per port; no raw TCP or public IP documented | Command API and a WebSocket terminal capped at one hour, no SSH; up to 16 published ports; no dedicated IP | SSH; HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Keeping keys out of the sandbox | Secrets are injected as environment variables or files | Cloud secrets are environment variables the guest can read; credential swapping only in self-hosted smolvm | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| GPUs | GPU instance types on Enterprise runners in your own cloud, such as one NVIDIA A10G with 16 vCPU and 64 GB | None on the hosted cloud; self-hosted smolvm supports GPU work through Vulkan and CUDA remoting | 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 | Hosted smol cloud with no region choice, or open-source smolvm on your laptop or your own servers | EU only (Germany, Finland, France), with EU data residency |
| Getting started | New Core subscriptions are closed; new customers go through sales for Enterprise | Self-serve: a free Standard plan with no card, and $100 of credit once for new accounts | Self-serve plans from $20 a month, with a free trial |
Every feature Battleships tracks (43)
| Feature | Ona | smol machines | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | 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 | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | 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 | Yes | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | No | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | No | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | No | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Ona or smol machines: neither was in the StarSling hpc-sandbox-benchmarks runs we use. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. smol machines publishes a boot time under 200ms for smolvm, which is a start-time figure, 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. Ona and smol machines 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 | smol machines, 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 | $25 · Standard | $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 | $93 · Standard | $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 | $1,139 · Pro | $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 | $465 · Startup | $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 | $1,389 · Startup | $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 (about $5,000 a month), plus compute on your own AWS bill. Real Enterprise prices are negotiated with sales.
smol machines: smol cloud charges $0.04 for every hour a machine runs, plus $0.05 per active vCPU-hour and $0.0162 per active GB-hour of memory, with a one-minute minimum and disk billed even while stopped. Pro and Startup are fees added on top of usage, not credit.
smol machines: 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. smol machines caps the machines you hold by plan (20 on Standard, 100 on Pro, 1,000 on Startup), and stopped machines still take a slot, so 50 agents need Pro and 1,000 short jobs need Startup. On bochka the limit that bites is starts: the 1,000-job burst is queued above 90 starts a minute.
| Scenario | Ona | smol machines | bochka |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
| None that bite | None that bite |
| 50 agents in parallel |
| None that bite | None that bite |
| Sandboxes for your users |
| None that bite | None that bite |
| 1,000 short jobs at once |
| None that bite |
|
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 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 stay inside your own AWS or GCP account, in a region you choose.
- GPU environments. Useful if your agents need a GPU: Enterprise runners can use GPU types, such as an A10G VM with 16 vCPU and 64 GB.
Use smol machines when
you want a self-serve microVM API with one open-source engine from laptop to servers, live branches with memory, or outbound allowlists.
- Open source, from laptop to your own servers. Useful if you want one VM engine that runs the same locally, in a hosted cloud and on your own servers.
- Live branches with memory. Useful for RL and test fan-out: branch a running machine with its memory and processes, and wake stopped machines on demand.
- Outbound allowlists and arm64. Useful if a machine may only reach listed hosts and CIDR ranges, or you need arm64 images.
Where bochka fits
If what you are really running is agents started and driven by your own code, look at bochka too. Ona is a governed dev platform sold through sales, and smol machines is a lean microVM API; bochka gives each agent a whole machine with a desktop, nested virtualization, open ports and coding agents built in, on self-serve plans.
Emulators, VMs and a screen
Neither Ona nor smol cloud documents /dev/kvm on hosted machines, so Android emulators and nested VMs cannot start, and neither has a desktop. On smol you build and maintain your own browser and screen stack.
Keys that never enter the sandbox
Both put secrets inside the machine as environment variables or files, so one prompt injection can leak them. bochka keeps real keys in a credentials proxy for model providers and any HTTPS API.
Work that survives a long wait
On Ona a stopped disk stays on your cloud bill, or Core archives it after 3 days; on smol cloud a stopped disk keeps billing and /tmp is emptied. bochka saves the disk every minute and a stopped sandbox costs nothing.
Use bochka when your code starts and drives the agents and they need a whole machine: Docker and /dev/kvm, SSH, a desktop, open ports, keys kept outside, and disks that keep their work. Compare it one to one: bochka vs Ona and bochka vs smol machines.
Questions people ask
Is Ona cheaper than smol machines?
No, in every scenario we priced, using Ona's Enterprise listing on AWS Marketplace: one coding agent on workdays is $5,030 on Ona against $25 on smol machines, and 50 agents in parallel are $6,521 against $1,139. bochka comes to $20 and $317 for the same two. Ona's real price is a sales quote, so yours may differ.
Which is faster, Ona or smol machines?
We cannot say: neither has a comparable CPU measurement in the benchmark runs we use. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. smol machines publishes a boot time under 200ms, which measures starting, not CPU speed.
Can Ona and smol machines run Docker?
Yes, both run Docker inside the VM; smol's guide says Docker data must live on the machine's ext4 disk. Neither documents /dev/kvm on hosted machines, so Android emulators and nested VMs are out. bochka runs Docker and exposes /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. smol machines has a free Standard plan with no card, and bochka's plans are self-serve from a free trial up.
Can either fork a running machine?
smol machines can: it branches a running machine into children that keep its memory and processes. Ona has no way to copy an environment and starts new ones from a config or prebuild. bochka forks a running sandbox with its disk, and the fork boots fresh.
Is smol machines open source? Is Ona?
The smolvm engine and the smol SDK are open source and run on your own computer or servers, while smol cloud is the paid hosted service. Ona is a commercial platform that runs in your own AWS or GCP account on an Enterprise contract. bochka is a hosted service only.
Try bochka
Install the CLI, then run bochka new.
Product preview