Railway vs Ona
Railway is an app platform that added self-serve sandbox VMs, which are destroyed when they go idle. Ona, formerly Gitpod and now part of OpenAI, sells cloud dev environments for engineers and its Codex agent, and new customers buy it through sales.
The companies and products
Railway
Railway is a cloud platform for deploying web apps, servers and databases, which now also sells sandboxes and cloud agents.
Railway's main product is app hosting: you deploy services and databases as containers on its own hardware. In 2026 it added Sandboxes, isolated Linux VMs you create from the CLI or a TypeScript SDK, run commands in and destroy, and Cloud Agents, a personal VM for running a coding agent, in early access. It suits teams already hosting on Railway who want throwaway machines next to their apps.
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 366” means 15 of the other 365 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 | Railway: 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 Railway ranks 51st and Ona ranks 324th here: Railway sandboxes are destroyed when idle, and Ona needs an Enterprise contract to start machines from code, while bochka ranks 3rd with machines that keep their disk. | 51st of 367, with limits $342 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 Railway ranks 16th and fits fully if you set the idle timeout to 0, while Ona needs auto-stop set to Never because background work does not count as activity. | 16th cheapest of 366 $3,977 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 Railway ranks 36th and beats both Ona and bochka here, because a sandbox bills for CPU used and is gone when the short job ends. | 36th cheapest of 345 $413 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 Railway caps sandboxes per environment (100 on Pro) and Ona is built for your own engineers, not your users; bochka ranks 1st with up to 2,000 sandboxes by plan. | 42nd of 361, with limits $290 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 | 78th of 360, with limits $4,450 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 Railway can fork a running sandbox and boot many from one checkpoint, Ona cannot copy an environment, and bochka forks a running machine too. | 108th of 364, with limits $364 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 Ona ranks 365th, since each run starts from a prebuild and the plan is a sales contract; Railway ranks 113th and bochka ranks 4th with Docker on every machine. | 113th cheapest of 377 $1,210 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, but the only plan open to new customers is Enterprise, so it ranks 368th; Railway ranks 66th and bochka ranks 18th. | 66th cheapest of 368 $89 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 Railway nor Ona has a graphical desktop to drive, while bochka streams a 60fps desktop with Chromium for computer use. | 77th of 369, with limits $103 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 | 53rd of 367, with limits $93 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 | 60th cheapest of 346 $570 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 | 109th of 338, with limits $2,988 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 | 43rd of 360, with limits $574 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 | Railway | Ona | bochka |
|---|---|---|---|
| Kind of product | App platform for services and databases, with sandbox VMs added in 2026 | Cloud dev environments for engineers and the Codex Agent; each task gets an isolated VM | Sandbox API for agents; every sandbox is a full VM with its own kernel |
| Buying it | Self-serve: Free, Hobby ($5) and Pro ($20 per workspace), usage billed per second | New Core subscriptions are closed; new customers go through sales for Enterprise | Self-serve plans from $20, with a free trial |
| When the sandbox goes idle | Destroyed after the idle timeout (30 minutes by default); files survive only in checkpoints you take | Stops after 30 idle minutes by default and keeps its disk; storage bills on your cloud while stopped, and Core archives it after 3 days | Runs until you stop it; the disk is saved every minute and on stop, and a stopped sandbox costs nothing |
| Docker and nested virtualization | Root shell on Ubuntu; the sandbox docs do not mention Docker or /dev/kvm | Docker and root inside the Dev Container; nested virtualization is not documented | Docker, root, systemd and /dev/kvm on every machine |
| Fork and checkpoints | Fork a running sandbox's filesystem; named disk checkpoints to boot new ones | No way to copy an environment; you can create a project from its config | Fork a running sandbox; named snapshots to start new ones |
| Starting point | Templates built from ordered steps (apt packages, env, commands) and cached | Dev Container config per repo, with prebuilds that snapshot the filesystem on a schedule | Named snapshots (templates), shareable by code; no Dockerfile builds |
| Driving it from code | CLI and TypeScript SDK to create sandboxes and run commands | Python, TypeScript and Go SDK on the Enterprise plan only | API and SDK on every plan, including the trial |
| Coding agents | Claude Code, Codex, OpenCode and Pi preinstalled; you run them headless through exec | Codex Agent started from chat, a Linear issue or an automation; Claude Code you run yourself | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets are set as environment variables, or signed in and saved in a checkpoint | Secrets are injected into the environment as environment variables or files | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out |
| Desktop and computer use | Headless: terminal, exec and SSH only | Browser IDE plus VS Code and JetBrains; no graphical desktop inside the environment | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Reaching the sandbox | Up to 10 public HTTPS domains, set only at creation; SSH and port forwarding | HTTPS URL per port for you, your organization or everyone; SSH; no raw TCP documented | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Apps and databases next to it | Deploy Postgres, Redis and services in the same project; a sandbox can join their private network | No hosted databases; environments are for development work | No hosted databases or app services; host your own inside a sandbox |
| GPUs | None | GPU instance types on Enterprise runners in your own cloud, such as one NVIDIA A10G with 16 vCPU and 64 GB | None |
| Regions | US West, US East, Amsterdam and Singapore; new sandboxes start in US West | 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 |
Every feature Battleships tracks (43)
| Feature | Railway | Ona | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Not published | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | No | 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 | No | No | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | Yes | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | No | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | No | 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
There is no comparable measurement for Railway or Ona: neither was in the public benchmark runs we use, so we cannot say which of the two is faster. 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.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Railway 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 | Railway, 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 | $16 · Hobby · 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 | $70 · Hobby · 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 | $739 · Hobby · 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 | $223 · Pro · 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 | $781 · Pro · with limits | $5,955 · Enterprise (AWS Marketplace 12-month contract) · with limits | $2,000 · $2000/mo · with limits |
Railway: Railway bills sandboxes per second at $50 per vCPU-month on CPU actually used and $50 per GB-month on memory in use, plus $0.05 per GB out, and memory keeps billing while a sandbox waits. The Hobby ($5) and Pro ($20 per workspace) fees count toward usage, and sandbox disk has no published price, so our bills leave it out.
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.
Ona: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Neither Railway nor Ona fits any scenario cleanly. Railway is an app platform first with no published sandbox disk price, and it caps sandboxes per environment at 50 on Hobby and 100 on Pro, so 300 user sandboxes or 1,000 jobs at once need several environments. Ona can only be bought as Enterprise through sales and publishes no concurrency limit, so the table assumes 3 environments at once, and its per-user policy defaults to 10 running environments. On bochka, the 1,000-job burst is queued above 90 starts a minute and needs more starts per day than the $2,000 plan allows.
| Scenario | Railway | 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 Railway when
your app and databases already live on Railway and you want self-serve, short-lived sandboxes on the same private network, or regions in the US and Asia.
- Your apps and databases in one place. Useful if your app already runs on Railway: sandboxes can join the same private network as your Postgres and services.
- Sign up and start today. Useful if you want to try it now: Railway has self-serve plans, while new Ona customers must go through sales.
- Short jobs that bill for CPU used. Useful for many quick code runs: a Railway sandbox bills for CPU used and is gone when the job ends.
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, and you are ready to buy through sales.
- A full cloud IDE for your team. Useful if your engineers work beside their agents: Ona has 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.
- 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
If what you are really running is agents started by your own code, both picks have a catch: Railway sandboxes are destroyed when idle and are headless, and Ona's API needs an Enterprise contract. bochka gives each agent a full VM with Docker, /dev/kvm and a desktop, keeps its disk when stopped, and lets you drive the agents inside from outside on every plan.
Machines that keep their work
A Railway sandbox is destroyed after 30 idle minutes unless you set the timeout to 0, and then memory bills until you destroy it. Ona keeps the disk, but it bills on your cloud while stopped and Core archives it after 3 days.
Docker, KVM and a desktop
Neither Railway nor Ona documents /dev/kvm, Railway's sandbox docs do not mention Docker, and neither has a graphical desktop. An agent that boots an Android emulator or tests a web app in a real browser has nowhere to do it.
Agents you drive from outside
On Railway you shell each agent through exec and parse its output, with its API key in the VM. Ona's SDK is Enterprise only and its managed agent is Codex. bochka has a prompt, steer and events API and keeps real keys outside.
Use bochka when your code starts and drives the agents: full VMs with Docker, /dev/kvm, a desktop and open ports, an API on every plan, and machines that keep their work while stopped. Compare it one to one: bochka vs Railway and bochka vs Ona.
Questions people ask
Is Railway cheaper than Ona?
In every scenario we priced, yes: one agent running all month is $70 on Railway against $5,140 on Ona, and 50 agents in parallel are $739 against $6,521. Ona's numbers use its Enterprise listing on AWS Marketplace and Railway's leave out disk, so neither is exact. On bochka the same jobs come to $26 and $317 a month.
Which is faster, Railway or Ona?
We cannot say. Neither Railway nor Ona was in the public CPU benchmark we use. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that benchmark.
Can Railway or Ona run Docker?
Ona gives you Docker and root inside the Dev Container. Railway's sandbox docs give you a root shell on Ubuntu but do not mention Docker or /dev/kvm. bochka has Docker, systemd and /dev/kvm on every machine.
What happens when a sandbox goes idle?
Railway destroys it after the idle timeout, 30 minutes by default, and only checkpoints you took survive. Ona stops it after 30 idle minutes and keeps the disk, though background processes do not count as activity. A bochka sandbox runs until you stop it and keeps its disk for free while stopped.
Is Ona the same as Gitpod, and can I still sign up?
Yes, Gitpod renamed itself Ona in 2025, and Ona is now part of OpenAI. New Core subscriptions are no longer available, so new customers go through sales. Railway and bochka both have self-serve plans.
Do Railway and Ona come with coding agents?
Railway's default sandbox image includes Claude Code, Codex, OpenCode and Pi, which you run headless through exec. Ona's managed agent is Codex, and Claude Code you install yourself. bochka preinstalls coding agents and lets you prompt, steer and watch them through an API.
Try bochka
Install the CLI, then run bochka new.
Product preview