Railway vs Docker Cloud Sandboxes
Railway is an app platform whose sandboxes are VMs that sit next to your services and are destroyed when they go idle. Docker Cloud Sandboxes runs the same sbx microVM you use on your laptop, with Docker inside, for up to 24 hours a session.
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.
Docker Cloud Sandboxes
Docker Cloud Sandboxes runs Docker's sbx coding-agent microVMs on Docker-managed compute instead of your laptop.
Each sandbox is a microVM with its own Linux kernel and its own Docker Engine, started from the same sbx CLI you use locally, with Claude Code, Codex and other agents ready to run. You can move a sandbox from your laptop to the cloud and back, publish HTTPS ports and SSH in. It launched on September 24, 2026, is billed pay-as-you-go on a personal Docker account, and is built for developers who want their local agent sandboxes to keep going off their machine.
- Launched
- September 24, 2026
- Session length
- 1 hour by default, extendable to 24 hours from creation
- Default quota
- 10 concurrent and 50 stored sandboxes per account
- Regions
- Not published
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 | Docker Cloud Sandboxes: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs machines that keep their work; Railway destroys idle sandboxes, Docker ends each one 24 hours after creation and runs 10 at once, while boat keeps the disk with no session cap. | 51st of 367, with limits $342 a month | 280th of 367, with limits $4,928 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant fits Railway if you set the idle timeout to 0, but not Docker, whose sessions end at 24 hours; boat runs it all month for $657 in this use case. | 16th cheapest of 366 $3,977 a month | 276th of 366, with limits $5,110 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 Short code runs are the one place both shine: Railway bills CPU used and destroys the sandbox after, and Docker bills small sandboxes by the second. | 36th cheapest of 345 $413 a month | 119th of 345, with limits $233 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 Sandboxes for your users hit Railway's 100 per environment on Pro and Docker's default of 10 at once; boat's plans run up to 2,000 at once. | 42nd of 361, with limits $290 a month | 136th of 361, with limits $1,628 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 | 114th of 360, with limits $7,000 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 | 108th of 364, with limits $364 a month | 167th of 364, with limits $1,400 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 CI that builds containers needs Docker inside, which Docker Cloud Sandboxes ships and Railway's sandbox docs do not mention; boat has Docker and /dev/kvm on every machine. | 113th cheapest of 377 $1,210 a month | 172nd of 377, with limits $672 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box on all month works on Railway with the timeout off or a Cloud Agent, but not on Docker, where each session stops at 24 hours. | 66th cheapest of 368 $89 a month | 127th of 368, with limits $204 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 Docker has a desktop, so computer-use agents fit only as a compromise there; boat has a 60fps desktop with Chromium. | 77th of 369, with limits $103 a month | 268th of 369, with limits $1,400 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 Browser agents need a real browser on the machine; boat ships one with a desktop, while Railway and Docker sandboxes are headless. | 53rd of 367, with limits $93 a month | 277th of 367, with limits $700 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 | 262nd of 346, with limits $350 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 | 190th of 338, with limits $7,000 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 | 248th of 360, with limits $350 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 | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| Isolation | Sandboxes are isolated Linux VMs; app services are containers | MicroVM with its own Linux kernel and its own Docker Engine | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| How long a sandbox lives | Until you destroy it, or until the idle timeout (30 minutes by default, 0 for never) | 1 hour by default, at most 24 hours from creation | No session cap on paid plans; you set the time to live |
| Stop and resume | No stop: an idle sandbox is destroyed, and files survive only in checkpoints you take | Stop keeps memory and files, and resume picks up where it left off | Stop keeps the disk, saved every minute and on stop; a stopped sandbox costs nothing |
| Fork | Fork a running sandbox's filesystem, or boot new ones from a checkpoint | Snapshot a running sandbox with disk or disk and memory, then restore it as a new one | Fork a running sandbox with its disk; named snapshots to start new ones |
| Docker inside | Root on Ubuntu; the sandbox docs do not mention Docker | Yes, its own Docker Engine; the agent runs as a non-root user with sudo | Yes, with root and systemd |
| Nested virtualization | Not documented | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Desktop and browser | Headless: terminal, exec and SSH | Terminal sessions only | 60fps Linux desktop with Chromium, computer use and browser control |
| Sandboxes at once | 50 per environment on Hobby, 100 on Pro; Enterprise can ask for more | 10 by default, with no published way to raise it | 100 on the $20 plan, up to 2,000 on higher plans |
| Biggest sandbox | 8 vCPU / 8 GB on Hobby, 32 vCPU / 32 GB on Pro | 16 vCPU / 32 GiB, amd64 or arm64 by account | 8 vCPU / 16 GB on the $20 plan, 16 vCPU / 32 GB from $100 |
| Inbound access | Up to 10 public HTTPS domains, set at creation; SSH and port forwarding | Public HTTPS URL per published port; SSH with Docker-issued certificates; not a TCP tunnel | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Coding agents | Claude Code, Codex, OpenCode and Pi preinstalled, run headless through exec | Claude Code, Codex, Copilot, OpenCode and more, attached to from the sbx CLI | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Keeping API keys out of the sandbox | Secrets go in as environment variables or a saved sign-in | Cloud proxy sets the auth header for AI services and custom hosts | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| Outbound rules | Open internet | Allow and deny rules by host, enforced at a proxy outside the VM | Open internet |
| Apps and databases nearby | Postgres, Redis and services in the same project, on a private network the sandbox can join | None; the same sandbox can also run on your laptop | None; host your own inside a sandbox |
Every feature Battleships tracks (43)
| Feature | Railway | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| 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 | 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 | No | No |
| Wake on request | No | Not published | 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 | Yes | Yes |
| Secret proxy for any API | No | Yes | 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 | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No | No | 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 Railway or Docker Cloud Sandboxes: neither is in StarSling's hpc-sandbox-benchmarks runs, and Docker does not say what hardware it uses. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB, so we cannot say which of the three is fastest.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Railway and Docker Cloud Sandboxes 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 | Docker Cloud Sandboxes, a month | boat, 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 | $49 · Docker Agentic Platform (pay-as-you-go) | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $70 · Hobby · with limits | $204 · Docker Agentic Platform (pay-as-you-go) · 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 | $2,464 · Docker Agentic Platform (pay-as-you-go) · 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 | $700 · Docker Agentic Platform (pay-as-you-go) · 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 | $1,400 · Docker Agentic Platform (pay-as-you-go) · with limits | $2,000 · $2000/mo · with limits |
Railway: Railway bills sandboxes per second at $50 per vCPU-month on CPU 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 disk and checkpoints have no published price, so our bills leave them out.
Docker Cloud Sandboxes: Docker bills per second for the size you pick, from $0.07 an hour for 1 vCPU / 2 GiB to $1.12 an hour for 16 vCPU / 32 GiB, with no monthly fee. A stopped sandbox costs nothing, and volumes and egress are free.
Docker Cloud Sandboxes: Plans start at $20 a month, and the whole fee is usage credit spent per second while sandboxes run. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Railway is marked as a different kind of product in every scenario because it is an app platform first and does not price sandbox disk, and it caps sandboxes at 100 per environment on Pro. Docker ends each sandbox 24 hours after creation, so an agent that never stops does not fit, and its default of 10 at once rules it out for 50 agents, sandboxes for your users and 1,000 short jobs. boat fits all but the 1,000-job burst, where its start limits queue the jobs even on the $2,000 plan.
| Scenario | Railway | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | 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 short sandboxes on the same private network, or you need US or Asia regions.
- Next to your apps and databases. If your app already runs on Railway, a sandbox can join the same private network as your Postgres and services.
- Regions in the US, EU and Asia. Railway runs in California, Virginia, Amsterdam and Singapore, and you pick a region per sandbox.
- Pay for CPU you use. For many quick runs, a Railway sandbox bills CPU on what it uses and is gone when the job ends.
Use Docker Cloud Sandboxes when
you already run agents in sbx on your laptop and want a few to keep going in the cloud for up to a day, with memory kept on stop and strict outbound rules.
- Stop with memory. For agents that pause between steps, a stopped sandbox comes back with its memory and running processes.
- Laptop and cloud, one CLI. If you already run sbx locally, the cloud is the same microVM, and you can move a sandbox either way.
- Outbound rules at the proxy. Teams that must limit where an agent connects can set allow and deny rules by host, enforced outside the VM.
Where boat fits
Railway is built around short sandboxes next to hosted apps, and Docker around moving your laptop sandbox to the cloud for a day. If your agents work for days, run by the dozen, or need a screen, look at boat: a full VM that keeps its disk, with a desktop and agents you drive from outside.
Work that outlives a session
A Railway sandbox is destroyed after 30 idle minutes by default, and a Docker one ends 24 hours after creation. Turning Railway's timeout off keeps it, but memory bills the whole time. boat stops, keeps its disk and costs nothing stopped.
A desktop, Docker and KVM
Both are headless, neither documents /dev/kvm, and Railway's docs do not mention Docker. An agent that clicks through a web app or boots an Android emulator needs a separate browser service there; boat has a 60fps desktop and /dev/kvm.
Agents driven from outside
On Railway you shell agents through exec, and on Docker you attach to their terminal, so your app parses text to know when they finish. boat gives a prompt, steer and events API, plus a credentials proxy for any HTTPS API.
Use boat when your agents run for days or by the dozen, need Docker, a desktop or an Android emulator, or have to be driven from your own app through an API. Compare it one to one: boat vs Railway and boat vs Docker Cloud Sandboxes.
Questions people ask
Is Railway cheaper than Docker Cloud Sandboxes?
In our scenarios, yes: one agent on workdays is $16 on Railway against $49 on Docker, and one agent all month is $70 on Railway against $204 on Docker. Railway's numbers leave out disk, which it does not price. boat comes to $20 and $26 for the same two jobs.
Which is faster, Railway or Docker Cloud Sandboxes?
We cannot say: neither has a result in the benchmark we use, and Docker does not name its hardware. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB.
Can Railway sandboxes run Docker?
Railway's sandbox docs give you root on Ubuntu but do not mention Docker. Docker Cloud Sandboxes gives each sandbox its own Docker Engine, and boat has Docker, root and systemd on every machine.
How long can a sandbox run on each?
A Railway sandbox runs until you destroy it or its idle timeout fires, 30 minutes by default or never if set to 0. A Docker cloud sandbox lasts 1 hour by default and at most 24 hours from creation. boat has no session cap on paid plans.
How many sandboxes can I run at once?
Railway allows 50 per environment on Hobby and 100 on Pro. Docker's default is 10 at once and 50 stored per account. boat runs 100 at once on the $20 plan and up to 2,000 on higher plans.
Do they keep memory when a sandbox stops?
Docker does: a stopped sandbox resumes with its memory and processes. Railway destroys idle sandboxes and keeps only disk checkpoints. boat keeps the disk, saved every minute and on stop, and boots the machine again on resume.
Try boat
Install the CLI, then run boat new.
7-day free trial