Railway vs Freestyle
Railway is an app platform for services and databases that added sandbox VMs, which are destroyed when they go idle. Freestyle sells full Linux VMs for agents, with Docker and KVM ready, that pause with their memory and wake on the next request.
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.
Freestyle
Freestyle sells full Linux virtual machines for AI agents, built for long running, complex tasks.
Each Freestyle VM is a KVM virtual machine with its own kernel, booted from an Ubuntu base snapshot with systemd, Docker and coding agent CLIs preinstalled. VMs can be paused with their memory, snapshotted while running, forked and woken by the next request, and every VM starts behind a default-deny firewall. It is built for teams that give each agent or each user its own machine, driven from a TypeScript SDK, a CLI or an API.
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 | Freestyle: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Railway sandboxes are destroyed when idle and its docs do not mention Docker; Freestyle runs Docker and systemd, and bochka does the same on CPUs that did 2.8 times Freestyle's work. | 51st of 367, with limits $342 a month | 241st of 367, with limits $3,311 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 with the idle timeout set to 0 or a Cloud Agent; on Freestyle's Free plan the monthly allowances are hard stops, so it pauses when they run out. | 16th cheapest of 366 $3,977 a month | 263rd of 366, with limits $4,195 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: Railway bills for CPU used and destroys the sandbox after, while Freestyle pauses a VM with its memory and wakes it on the next request. | 36th cheapest of 345 $413 a month | 40th cheapest of 345 $482 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 Freestyle fits sandboxes for your users fully, with 400 VMs at once on Pro and wake on request; Railway allows 100 per environment on Pro. | 42nd of 361, with limits $290 a month | 16th cheapest of 361 $1,358 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 | 107th of 360, with limits $6,600 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 Freestyle can snapshot a running VM with its memory and boot copies from it; Railway forks the filesystem only and caps how many sandboxes each environment runs. | 108th of 364, with limits $364 a month | 53rd cheapest of 364 $1,046 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 Freestyle's docs say CPU-heavy jobs like kernel builds are better served elsewhere; bochka did 2.8 times its CPU work and runs Docker on every machine. | 113th cheapest of 377 $1,210 a month | 168th of 377, with limits $625 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Railway's Cloud Agents keep a disk but are early access and fixed at 4 vCPU / 4 GB on Pro; a Freestyle VM keeps its disk and can pause with its memory. | 66th cheapest of 368 $89 a month | 98th cheapest of 368 $151 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 ships a desktop: Railway sandboxes are headless, and on Freestyle you install a desktop, VNC and Chromium yourself, while bochka streams one at 60fps. | 77th of 369, with limits $103 a month | 234th of 369, with limits $940 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 | 257th of 367, with limits $482 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 | 278th of 346, with limits $482 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 | 183rd of 338, with limits $6,560 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 | 272nd of 360, with limits $482 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 | Freestyle | bochka |
|---|---|---|---|
| Isolation | Sandboxes are Linux VMs; app services run as non-privileged containers | Full KVM VM with its own kernel on bare metal servers | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| CPU benchmark (4 vCPU / 8 GB) | No result in this benchmark | 9.64 runs/s | 26.69 runs/s |
| When the sandbox goes idle | Destroyed after the idle timeout (30 minutes by default); files survive only in checkpoints you take | No idle timeout unless you set one; a paused VM bills for its storage | You stop it; the disk is kept, snapshots every minute and on stop, and a stopped sandbox costs nothing |
| Pause and wake | No memory pause; a destroyed sandbox boots again from a disk checkpoint | Pause saves memory and disk; the same processes resume, and a paused VM wakes on the next request | Disk is saved; resume boots the machine again, started by API |
| Root, Docker and nested virtualization | Root shell on Ubuntu; the sandbox docs do not mention Docker or /dev/kvm | Yes; systemd is pid 1, Docker runs from boot, full KVM support | Yes: root, systemd, Docker and /dev/kvm on every machine |
| Fork | Fork a running sandbox's filesystem; named disk checkpoints (no memory) | Clone a running VM without pausing it; snapshots capture memory and disk | Fork a running sandbox with its disk; named snapshots to start new ones |
| Desktop, browser and computer use | Headless: terminal, exec and SSH only | Guides to install GNOME or Xvfb, VNC and Chromium yourself | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Coding agents | Claude Code, Codex, OpenCode and Pi preinstalled; run headless through exec | claude, codex, opencode and openclaw preinstalled; driven through exec or a terminal | Seven agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets go in as environment variables, or are signed in and saved in a checkpoint | Credentials injected at the edge for HTTPS headers, Postgres and S3; the VM must trust the Freestyle CA | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Outbound rules | No egress allowlist for sandboxes | Default-deny firewall with allow rules by IP, VM, VPC or exact domain | Open internet, no provider-side allowlist |
| Apps and databases next to the sandbox | Deploy Postgres, Redis and services in the same project; a sandbox can join their private network | Private VPCs and WireGuard tunnels between VMs | No hosted databases or app services; host your own inside a sandbox |
| Biggest machine | 8 vCPU / 8 GB on Hobby, 32 vCPU / 32 GB on Pro | 32 vCPU / 64 GiB on Pro, 64 / 128 with custom limits | 8 vCPU / 16 GB on the $20 plan, 16 vCPU / 32 GB from $100 |
| Sandboxes at once | 50 per environment on Hobby, 100 on Pro | 10 on Free, 40 on Hobby, 400 on Pro | 100 to 2,000 by plan |
| Regions | US West, US East, Amsterdam and Singapore | Not listed; the docs name a San Jose, US data center | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Railway | Freestyle | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Not published | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Yes | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | Yes | 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 | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | Yes | No | 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 | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Yes | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | Yes | Not published | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
On the same Node.js build-and-test benchmark at 4 vCPU / 8 GB, Freestyle did 9.64 runs per second and bochka did 26.69, so bochka finished about 2.8 times as much CPU work in the same time. Railway has no result in this benchmark, so we cannot say how fast it is next to either.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Railway 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 | Railway, a month | Freestyle, 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 | $27 · Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $70 · Hobby · with limits | $159 · Free | $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 | $2,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 | $581 · Pro | $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,305 · Pro · 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, which keeps billing while a sandbox waits. The Hobby ($5) and Pro ($20) fees count toward usage, and sandbox disk has no published price, so our bills leave disk out.
Freestyle: Freestyle bills per second for the vCPU, RAM and disk allocated to a VM, busy or idle, after monthly allowances of 200 vCPU-hours, 400 GiB-hours of RAM and 60,000 GiB-hours of storage. Hobby and Pro set a $50 or $500 monthly minimum that counts as usage, and a paused VM bills only for storage.
Freestyle: 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
Railway marks every scenario as not a clean fit because it is an app platform first and does not publish a sandbox disk price, and it caps sandboxes per environment at 50 on Hobby and 100 on Pro. Freestyle fits four of the five scenarios, but on Free its allowances are hard stops, and Pro allows 400 VMs at once, which is why it does not fit 1,000 short jobs at once. Neither does Railway, and bochka also misses that one: its $2,000 plan queues starts above 90 a minute.
| Scenario | Railway | Freestyle | 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 |
|
|
|
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 private network of your Postgres and services.
- Regions in the US, EU and Asia. Useful if users are spread out: Railway runs in California, Virginia, Amsterdam and Singapore, and Freestyle names only San Jose.
- Short jobs that bill for CPU used. Useful for many quick code runs: Railway bills sandbox CPU on what is used, while Freestyle bills allocated vCPUs, busy or idle.
Use Freestyle when
your VMs sleep between requests and must resume with their memory, when you need a default-deny firewall per VM, or when you need up to 64 GiB of memory in one machine on Pro.
- Memory pause, live fork and wake on request. Useful for VMs that sleep between requests: they resume the same processes and wake on the next incoming traffic.
- Docker and KVM ready from boot. Useful for agents that build containers or run emulators: systemd, Docker and nested virtualization work out of the box.
- Network controls. Useful when agents run untrusted code: every VM starts with no network access, and you allow exactly what it may reach.
Where bochka fits
If what you are really running is coding or browser agents that work for hours, look at bochka. It gives each agent a full VM with Docker and KVM like Freestyle, keeps its disk when it stops unlike a Railway sandbox, and adds a desktop and an API to drive the agents inside from outside.
Fast CPUs with Docker and KVM
Freestyle did 9.64 runs per second on the CPU benchmark and bochka did 26.69, so every install, build and test waits almost three times as long there. Railway has no result, and its sandbox docs do not mention Docker.
A desktop and a browser, ready
Railway sandboxes are headless, with no screen at all. On Freestyle you install GNOME or Xvfb, VNC and Chromium into your own snapshot and build the screenshot and click layer yourself. bochka streams a 60fps desktop with computer use built in.
Agents you drive from outside
On both, you start the agent CLI through exec and parse its output yourself, and on Railway its key sits inside the VM. bochka adds a prompt, steer and events API, and a credentials proxy that switches accounts when credits run out.
Use bochka when your agents do real work for hours: builds, tests, Docker, emulators, a desktop and a browser, on fast CPUs, with a disk that stays and an API to drive the agents inside from outside. Compare it one to one: bochka vs Railway and bochka vs Freestyle.
Questions people ask
Is Railway cheaper than Freestyle?
In our scenarios Railway comes out lower: one agent running all month is $70 on Railway against $159 on Freestyle, and 50 agents in parallel are $739 against $2,139. But Railway's bills leave out disk, which it does not price, and it is marked as not a clean fit in every scenario. On bochka those two come to $26 and $317.
Which is faster, Railway or Freestyle?
Freestyle did 9.64 runs per second on the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, and Railway has no result there, so we cannot compare them. bochka did 26.69 on the same test.
Can Railway sandboxes run Docker?
Railway's sandbox docs give you a root shell on Ubuntu but do not mention Docker or /dev/kvm. Freestyle VMs run systemd as pid 1 with Docker from boot and full KVM support, and bochka has root, systemd, Docker and /dev/kvm on every machine.
What happens when a sandbox goes idle?
Railway destroys it once the idle timeout runs out, 30 minutes by default, and only checkpoints you took survive. Freestyle has no idle timeout unless you set one, so a VM bills until you pause it, and a paused VM keeps its memory and wakes on the next request. A bochka sandbox stops, keeps its disk and costs nothing while stopped.
Where do Railway and Freestyle run?
Railway has regions in California, Virginia, Amsterdam and Singapore, and new sandboxes start in US West unless you pick one. Freestyle does not list regions; its docs name a San Jose, US data center. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview