Railway vs smol machines
Railway is an app platform that added sandbox VMs, which are destroyed when they go idle and can sit next to your Railway apps and databases. smol machines makes microVMs that keep their files when stopped, branch with their memory, and run the same on your laptop, in its cloud or on your own servers.
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.
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. “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 | smol machines: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month smol machines keeps a stopped machine's files and runs Docker inside, while Railway sandboxes are destroyed when idle; bochka adds /dev/kvm, SSH and coding agents you drive from outside. | 51st of 367, with limits $342 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 Railway fits an always-on assistant if you set the idle timeout to 0, smol machines only as a compromise, and bochka adds a desktop, a browser and a credentials proxy. | 16th cheapest of 366 $3,977 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 Both fit short code runs well: Railway bills for CPU used and destroys the sandbox after, and smol machines has a one-minute minimum and a /code endpoint. | 36th cheapest of 345 $413 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 smol machines fits sandboxes for your users with 1,000 machines on Startup, while Railway caps each environment at 100 sandboxes on Pro. | 42nd of 361, with limits $290 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, so many rollouts start from one prepared state; Railway forks the filesystem only. | 78th of 360, with limits $4,450 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 Both can fork a running machine, but Railway's cap is per environment, while smol machines branches with memory and holds up to 1,000 machines on Startup. | 108th of 364, with limits $364 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 smol machines runs Docker inside a machine, which Railway's sandbox docs do not mention; bochka has Docker and /dev/kvm on every machine. | 113th cheapest of 377 $1,210 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 | 66th cheapest of 368 $89 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 has a hosted desktop, so computer-use agents fit only as a compromise on both; bochka streams a 60fps desktop with computer use built in. | 77th of 369, with limits $103 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 | 53rd of 367, with limits $93 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 | 60th cheapest of 346 $570 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 | 109th of 338, with limits $2,988 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 | 43rd of 360, with limits $574 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 | Railway | smol machines | bochka |
|---|---|---|---|
| Kind of product | App platform for apps and databases, with sandbox VMs added in 2026 | Open-source microVM engine (smolvm) plus a paid hosted cloud | Sandbox VMs for agents, hosted in the EU |
| Isolation | Sandboxes are isolated Linux VMs; app services are containers | libkrun microVM with its own guest kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| When the machine goes idle | Destroyed after the idle timeout (30 minutes by default); files survive only in checkpoints you take | Filesystem survives a stop, memory paths like /tmp are emptied; stopped disk keeps billing | Stops and keeps its disk, saved every minute and on stop; a stopped sandbox costs nothing |
| Fork | Fork a running sandbox's filesystem; disk checkpoints to boot new ones (no memory) | Branch a running machine with its memory and processes; checkpoints capture RAM to a file | Fork a running sandbox with its disk; named snapshots to start new ones |
| Docker and nested virtualization | Root shell on Ubuntu; the sandbox docs do not mention Docker or /dev/kvm | Docker inside the machine; nested virtualization not exposed in the cloud API | Docker, root, systemd and /dev/kvm on every machine |
| Shell access | SSH and port forwarding, plus exec | Command API, sessions and a WebSocket terminal capped at one hour per connection; no SSH | SSH, plus a command API and terminal |
| Inbound access | Up to 10 public HTTPS domains, set only at creation | Up to 16 published ports through a returned URL or an authenticated connect route | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | Open internet; static outbound IPs for services on Pro | Blocked, open, or an allowlist of hosts and CIDR ranges | Open internet, no provider-side allowlist |
| Desktop and computer use | Headless: terminal, exec and SSH only | No hosted desktop; a guide shows running your own Chromium inside a machine | 60fps Linux desktop with Chromium, computer use and an embeddable stream |
| Coding agents | Claude Code, Codex, OpenCode and Pi preinstalled; you run them headless through exec | Registry images with the Codex CLI and the Harbor eval harness, run through the command API | Seven agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets go into the sandbox as environment variables | 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 |
| Apps and databases next to the sandbox | Deploy Postgres, Redis and services in the same project; a sandbox can join their private network | Idle apps scale to zero and wake on the next request; no hosted databases | No hosted databases or app services; host your own inside a sandbox |
| Machines at once | 50 per environment on Hobby, 100 on Pro | 20 on Standard, 100 on Pro, 1,000 on Startup; stopped machines count too | 100 to 2,000 by plan |
| Regions and self-hosting | US West, US East, Amsterdam and Singapore; BYOC listed for Enterprise | No region choice in the cloud API; smolvm runs on your laptop or your own servers | EU only: Germany, Finland, France, with EU data residency; hosted only |
Every feature Battleships tracks (43)
| Feature | Railway | smol machines | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Not published | 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 | Yes | Yes | Yes |
| Live fork (no pause) | Yes | 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 | Yes | Yes | No |
| GPU | No | 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 | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for either. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's public benchmark, but neither Railway nor smol cloud has a result there, so we cannot say which of the three is faster. 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. Railway 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 | Railway, 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 | $16 · Hobby · with limits | $25 · Standard | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $70 · Hobby · 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 | $739 · Hobby · 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 | $223 · Pro · 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 | $781 · Pro · with limits | $1,389 · Startup | $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, and memory keeps billing while a sandbox waits until it is destroyed. The Hobby ($5) and Pro ($20) fees count toward usage, and Railway does not publish a sandbox disk price, so our bills leave disk out.
smol machines: smol cloud charges a base fee for every hour a machine runs plus the CPU and memory the guest actually uses, with a one-minute minimum and disk billed even while stopped. Pro ($20) and Startup ($150) are fees added on top of usage, not credit.
Limits in those scenarios
Railway is marked as not a clean fit in every scenario because it is an app platform first and does not price sandbox disk, and its Pro cap of 100 sandboxes per environment is too low for 300 sandboxes for your users or 1,000 jobs at once. smol machines fits every scenario, but stopped machines hold a slot, so 50 agents in parallel needs Pro and 1,000 jobs at once needs Startup, whose fee is added on top. bochka fits every scenario except the 1,000-job burst, where its $2,000 plan queues starts above 90 a minute.
| Scenario | Railway | 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 Railway when
your app and databases already live on Railway and you want short-lived sandboxes on the same private network, or you need US or Asia regions.
- 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.
- Regions in the US, EU and Asia. Useful if your users are spread out: you can pick California, Virginia, Amsterdam or Singapore for each sandbox.
- Throwaway jobs with SSH. Useful for quick jobs: a sandbox bills for CPU used, is gone when idle, and takes SSH, which smol cloud does not.
Use smol machines when
you want one open-source VM engine from your laptop to your own servers, machines that keep their files when stopped, or many branches of a running machine with its memory.
- Live branches with memory. Useful for RL and test fan-out: branch a running machine with its memory and processes, paying the one-minute minimum once.
- One engine from laptop to your servers. Teams that want the same VM locally, in a hosted cloud and on their own servers get it from open-source smolvm.
- Files that stay, and outbound allowlists. A stopped machine keeps its files and wakes on the next command, and you can limit which hosts it reaches.
Where bochka fits
Railway and smol machines both run each sandbox in a VM, but both leave out pieces an agent often needs: a desktop, nested virtualization and a way to keep keys out of the guest. If your agents work for hours on real projects, test in a browser or run emulators, bochka gives each one a fuller machine that keeps its disk and costs nothing while stopped.
A whole machine: Docker, KVM and SSH
Railway's sandbox docs do not mention Docker or /dev/kvm, and smol cloud exposes neither nested virtualization nor SSH. An agent that boots an Android emulator or a VM cannot do it on either; bochka has Docker, systemd, /dev/kvm and SSH on every machine.
A desktop and agents you drive from outside
Both are headless, so a computer-use agent means building your own desktop and stream, and both run coding agents only through exec calls you parse yourself. bochka streams a 60fps desktop and has a prompt, steer and events API.
Keys that stay outside, and a disk that stays
On both, secrets are environment variables the guest can read, so one prompt injection can leak them. bochka's credentials proxy keeps real keys outside for any HTTPS API, and its disk is saved every minute, where Railway destroys idle sandboxes.
Use bochka when your agents need a whole machine for real work: Docker, emulators, SSH, a desktop and a browser, a disk that stays, and coding agents you drive from outside while their keys stay outside. Compare it one to one: bochka vs Railway and bochka vs smol machines.
Questions people ask
Is Railway cheaper than smol machines?
In our five scenarios Railway's bills are lower, for example $70 against $93 for one agent running all month, but they leave out disk, which Railway does not price, and Railway is not a clean fit in any of them. On bochka the same always-on agent comes to $26.
Which is faster, Railway or smol machines?
We cannot say: neither has a result in the StarSling CPU benchmark we use. bochka did 26.69 runs per second there at 4 vCPU / 8 GB. smol machines publishes a boot time under 200ms, which measures start time, not CPU speed.
Can Railway or smol machines run Docker?
smol machines runs Docker inside a machine, and its guide says Docker data must live on the machine's ext4 disk. Railway's sandbox docs do not mention Docker. 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. smol machines keeps the filesystem of a stopped machine but empties /tmp, and the disk keeps billing. bochka keeps the disk and charges nothing while stopped.
Can I fork a running machine on Railway or smol machines?
Both can. Railway forks a running sandbox's filesystem, while smol machines branches a running machine with its memory and running processes. bochka forks a running sandbox with its disk.
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