Runpod vs Crusoe
Runpod and Crusoe are both GPU clouds, but Runpod rents containers (pods) and serverless workers that share the host kernel, while Crusoe rents full VMs that you set up yourself over SSH. Runpod has more GPU types and regions; Crusoe gives you a whole VM, a firewall and the biggest Nvidia and AMD nodes.
The companies and products
Runpod
Runpod is a GPU cloud for AI work: you rent GPU or CPU pods by the second, run serverless endpoints, or book multi-node GPU clusters.
A Runpod Pod is a container started from a Docker image, with a GPU or CPU-only, SSH, a web terminal and Jupyter. Serverless endpoints run your handler in workers that scale to zero and start on a request, and Instant Clusters join 2 to 8 nodes of 8 GPUs each. It is built for teams that train, fine-tune and serve models, not as a sandbox API for agents, so this page compares the parts that overlap: CPU pods as machines for agent work.
- Founded
- 2022
Crusoe
Crusoe calls itself "the AI factory company": it builds energy-first data centers and rents GPU and CPU machines on Crusoe Cloud.
Crusoe Cloud is infrastructure for training and serving models: Nvidia and AMD GPU VMs, general-purpose and storage CPU VMs, disks, managed Kubernetes and Slurm, and managed inference. You create Ubuntu VMs through a console, CLI, Terraform or API, log in over SSH and install what you need. It is not a sandbox product, so this page compares the CPU VMs where it overlaps with bochka.
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. “32nd cheapest of 377” means 31 of the other 376 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 | Runpod: price rank | Crusoe: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither is built for coding agents: a Runpod pod cannot run Docker inside, and a Crusoe VM can but has no desktop, agents or forks; bochka has all of these on every sandbox. | 203rd of 367, with limits $2,362 a month | 232nd of 367, with limits $2,996 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 211th of 366, with limits $2,290 a month | 234th of 366, with limits $3,000 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 are a compromise for short code runs, but Runpod Serverless workers scale to zero and start on a request, which Crusoe has no answer for. | 227th of 345, with limits $135 a month | 128th of 345, with limits $268 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 Neither has a sandbox API for your users: Runpod does not publish how many pods can run at once, and Crusoe sets quotas per project that you raise through support. | 83rd of 361, with limits $733 a month | 104th of 361, with limits $951 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 | 53rd of 360, with limits $3,068 a month | 71st of 360, with limits $4,055 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 Crusoe fits agent evals as a plain VM with Docker, while Runpod's container pods make it a compromise; bochka adds snapshots and forks so each eval starts from the same disk. | 127th of 364, with limits $614 a month | 43rd cheapest of 364 $811 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 Both fit plain build and test jobs; jobs that start Docker containers work on a Crusoe VM and on bochka, not inside a Runpod pod. | 32nd cheapest of 377 $301 a month | 48th cheapest of 377 $395 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Crusoe keeps the whole disk of a stopped VM, so a 24/7 dev box fits there, while on Runpod anything installed outside /workspace is gone after a stop. | 161st of 368, with limits $93 a month | 87th cheapest of 368 $121 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 Runpod nor Crusoe ships a desktop or computer-use tools, so you would install and stream one yourself; bochka ships a 60fps desktop with Chromium. | 189th of 369, with limits $614 a month | 221st of 369, with limits $811 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 | 224th of 367, with limits $307 a month | 246th of 367, with limits $405 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 | 225th of 346, with limits $202 a month | 268th of 346, with limits $403 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 | 138th of 338, with limits $4,035 a month | 201st of 338, with limits $8,055 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 | 180th of 360, with limits $161 a month | 201st of 360, with limits $207 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 Runpod is the stronger fit for GPU eval jobs here, since it bills single GPUs by the second, while Crusoe's H100 and H200 SXM machines come only as 8-GPU VMs; bochka has no GPUs. | 13th cheapest of 98 $1,001 a month | 86th of 98, with limits $7,803 a month | 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 | Runpod | Crusoe | bochka |
|---|---|---|---|
| What you rent | GPU or CPU pods (containers), serverless workers and Instant Clusters | Plain Ubuntu GPU and CPU VMs, plus managed Kubernetes and Slurm | A sandbox for agents: a full VM with tools, desktop and agents ready |
| Isolation | Containers that share the host kernel | Full VM on cloud-hypervisor | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker inside | No Docker or Docker Compose inside a pod | A full VM with a sudo user, so Docker runs; preinstalled on GPU images | Docker, Docker Compose, root and systemd on every machine |
| Nested virtualization | None; pods are containers | Not documented | /dev/kvm on every machine, so emulators and VMs run inside |
| Files after a stop | Only /workspace is kept, billed at double the running rate; the rest of the container disk is cleared | The OS disk and attached disks are kept and the OS disk is billed; local NVMe is erased | The whole disk is kept, with snapshots every minute and on stop; a stopped sandbox costs nothing |
| Snapshots and forks | No pod snapshot or fork; templates save the image and settings only | Custom image of the boot disk, only while the VM is shut off | Fork a running sandbox into a new one with the same disk |
| Desktop and computer use | Web terminal, SSH, JupyterLab and remote VS Code; no desktop | None; install and stream a desktop yourself | 60fps desktop and Chromium, computer use and browser control |
| Coding agents | An MCP server and skills let your local agent manage Runpod | An MCP server lets an assistant inspect your Crusoe infrastructure | Claude Code, Codex, OpenCode and more preinstalled, driven from outside with a prompt, steer and events API |
| Keeping keys out of the machine | Secrets passed into the pod as environment variables | No credentials proxy; secrets live on the VM | AI credentials proxy for model providers and any HTTPS API you register |
| Reaching the machine | Up to 10 HTTP ports on a public proxy URL with no built-in auth; TCP on a public IP | Public IPv4, SSH, TCP and UDP load balancers; no managed HTTPS URLs | Token-protected HTTPS URLs for up to 50 ports; raw TCP; dedicated IPv6 or IPv4 |
| Network rules | No egress allowlist | VPC firewall with allow rules by IP, port and protocol, in and out | Open internet on every plan; no provider-side allowlist |
| GPUs | Dozens of Nvidia and AMD types, from RTX A4000 to B300 and MI300X, billed per GPU | Nvidia L40S up to GB200 and AMD MI300X and MI355X; H100 and H200 SXM as 8-GPU VMs | None |
| Scale to zero | Serverless workers scale to zero and start when a request arrives | None; VMs start and stop by API | Sandboxes stop and resume by API; no start on an incoming request |
| Regions | 24 documented data centers in the US, Canada, Europe and Australia | US (Texas, Virginia, Ohio, Nevada) and EU (Iceland, Norway) | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Runpod | Crusoe | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | 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 | No | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | No | No | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | Yes | Yes | Yes |
| Public IPv4 | Yes | Yes | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Yes | No | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Runpod or Crusoe: neither is in the StarSling hpc-sandbox-benchmarks run we use. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that 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. Runpod and Crusoe 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 | Runpod, a month | Crusoe, 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 | $26 · Pay-as-you-go (prepaid credits) · with limits | $32 · On-demand | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $93 · Pay-as-you-go (prepaid credits) · with limits | $121 · On-demand | $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 | $1,156 · Pay-as-you-go (prepaid credits) · with limits | $1,488 · On-demand | $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 | $307 · Pay-as-you-go (prepaid credits) · with limits | $405 · On-demand | $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 | $614 · Pay-as-you-go (prepaid credits) · with limits | $811 · On-demand | $2,000 · $2000/mo · with limits |
Runpod: Runpod bills a running pod per second from a prepaid balance, with disk on top, and a stopped pod keeps paying for its /workspace volume at double the running rate. CPU pods give 2 GB of memory per vCPU, and a new pod needs at least one hour of credit to start.
Crusoe: Crusoe bills each VM per second while it runs, at a flat rate per vCPU that includes 4 GB of memory per vCPU, and every VM pays for a 128 GB OS disk each month, running or stopped. It needs a credit card, not prepaid credit, and reservations bill for the whole term.
Crusoe: 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 whole disk.
Limits in those scenarios
Runpod does not publish how many pods can run at once and caps spend at $80 an hour by default, so 300 user sandboxes or 1,000 short jobs at once are not confirmed there, and every Runpod scenario hits the /workspace rule. Crusoe fits all five scenarios on paper, but its 4 vCPU machine has 16 GB, and its per-project quotas may need a support ticket before 50 agents or 300 sandboxes. On bochka the 1,000-job burst gets queued and needs more starts per day than the $2,000 plan allows.
| Scenario | Runpod | Crusoe | 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 Runpod when
you want single GPUs by the second, serverless workers that start on a request, or regions in Canada or Australia.
- More GPU types, one card at a time. If you want a single GPU for a short job, Runpod bills dozens of Nvidia and AMD types per GPU, by the second.
- Serverless that starts on a request. If your work comes in bursts, Runpod Serverless workers scale to zero and start when a request arrives.
- More regions and shared volumes. If you need Canada or Australia, or many pods reading one network volume, Runpod has both.
Use Crusoe when
you want full VMs with their own kernel, the largest GPU nodes with Kubernetes or Slurm, or firewall rules on every machine.
- A whole VM, not a container. If your jobs need their own kernel, Docker inside or a disk that fully survives a stop, Crusoe gives you a full VM.
- The biggest GPU nodes and cluster tools. If you train at scale, Crusoe rents GB200 and MI355X machines with managed Kubernetes and Slurm.
- Firewall rules and static IPs. If you must control traffic, Crusoe's VPC firewall allows only the IPs and ports you list, in and out.
Where bochka fits
Runpod and Crusoe are GPU clouds, and bochka has no GPUs, so model training and GPU evals belong on one of them. If what you are really running is agents that write and run code on CPU machines, bochka gives each one a full VM that saves itself, forks, and comes with a desktop and coding agents. Many teams keep the GPU work on Runpod or Crusoe and the agent workspaces on bochka.
Work that saves itself and forks
A Runpod stop wipes everything outside /workspace, and Crusoe can only copy a VM by shutting it off and imaging the boot disk. bochka snapshots the whole disk every minute and forks a sandbox while it runs.
A full VM with Docker and /dev/kvm
A Runpod pod cannot run Docker or Docker Compose, so an agent's docker compose up fails. Crusoe runs Docker but documents no nested virtualization; bochka has Docker, systemd and /dev/kvm for emulators on every sandbox.
Desktop, agents and keys proxy built in
Neither ships a desktop, coding agents or a credentials proxy, so you build the desktop stream, the agent control code and your own proxy, and keys sit inside the machine. bochka ships all three.
Use bochka when your agents write and run code on CPU machines: a full VM with Docker and /dev/kvm that saves itself every minute, forks while running, and comes with a desktop, coding agents, HTTPS hosting and a keys proxy. Compare it one to one: bochka vs Runpod and bochka vs Crusoe.
Questions people ask
Is Runpod cheaper than Crusoe?
For CPU machines in our scenarios, yes: one coding agent on workdays comes to $26 a month on Runpod and $32 on Crusoe, and one agent running all month to $93 versus $121. Crusoe's 4 vCPU machine has 16 GB of memory against Runpod's 8 GB. bochka comes to $20 and $26 for the same two.
Which is faster, Runpod or Crusoe?
We have no comparable CPU measurement for either one. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in the StarSling benchmark run we use.
Can I run Docker on Runpod or Crusoe?
Not inside a Runpod pod: its docs say you cannot start your own Docker or use Docker Compose there. A Crusoe VM is a full VM, so Docker runs, and it comes preinstalled on GPU images. bochka has Docker, Docker Compose and /dev/kvm on every sandbox.
What happens to my files when I stop a machine?
On Runpod only /workspace is kept and the rest of the container disk is cleared. On Crusoe the OS disk and attached disks are kept, but local NVMe is erased and the OS disk keeps billing. On bochka the whole disk is kept, snapshotted every minute, and a stopped sandbox costs nothing.
Which has more regions?
Runpod documents 24 data centers in the US, Canada, Europe and Australia. Crusoe runs in the US and in Iceland and Norway. bochka runs only in the EU (Germany, Finland and France).
Does bochka have GPUs?
No. bochka runs Linux VMs on dedicated AMD Ryzen 9 9950X hosts and has no GPUs. Run model training and GPU evals on Runpod or Crusoe, and keep your agents' workspaces on bochka.
Try bochka
Install the CLI, then run bochka new.
Product preview