Crusoe vs Cerebrium
Crusoe rents you GPU and CPU virtual machines that run until you stop them, and you set up everything on them yourself. Cerebrium takes your code or Dockerfile and serves it as GPU containers that start on a request and scale back to zero.
The companies and products
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.
Cerebrium
Cerebrium is a serverless GPU cloud for real-time AI: voice agents, video models, LLMs and other ML apps.
You describe an app in a cerebrium.toml file, with your Python code or your own Dockerfile, and Cerebrium builds it and serves it as HTTP or WebSocket endpoints. It starts containers when requests arrive, scales them across GPUs and regions, and scales them back to zero when traffic stops. It is built for teams that serve models in production, not for agents that need a machine of their own, so this page compares the places where the two overlap.
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. “43rd cheapest of 364” means 42 of the other 363 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 | Crusoe: price rank | Cerebrium: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither has a desktop or coding agents, and Cerebrium also resets files outside /persistent-storage; bochka ranks 3rd with all of that ready. | 232nd of 367, with limits $2,996 a month | 182nd of 367, with limits $2,008 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 234th of 366, with limits $3,000 a month | 221st of 366, with limits $2,534 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 suit Cerebrium's scale-to-zero containers, at $131 a month here against $268 on Crusoe; bochka's start limits make big bursts a compromise. | 128th of 345, with limits $268 a month | 225th of 345, with limits $131 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 Crusoe gives each machine a public IP but no HTTPS URLs, and Cerebrium gives each app one endpoint; bochka ranks first with HTTPS URLs on up to 50 ports per sandbox. | 104th of 361, with limits $951 a month | 230th of 361, with limits $821 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 | 71st of 360, with limits $4,055 a month | 72nd of 360, with limits $4,068 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 fit agent evals, with Cerebrium ranked 32nd and Crusoe 43rd; bochka ranks 10th. | 43rd cheapest of 364 $811 a month | 32nd cheapest of 364 $639 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 CI, and Crusoe ranks 48th to Cerebrium's 81st; bochka ranks 4th with Docker and /dev/kvm on every sandbox. | 48th cheapest of 377 $395 a month | 81st cheapest of 377 $766 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs SSH and a disk that keeps your installs, which a Crusoe VM has and Cerebrium does not; bochka ranks 18th and keeps a stopped sandbox for free. | 87th cheapest of 368 $121 a month | 259th of 368, with limits $102 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 Crusoe nor Cerebrium has a desktop or computer-use tools; bochka ships a 60fps desktop with Chromium and ranks 6th. | 221st of 369, with limits $811 a month | 179th of 369, with limits $575 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 | 246th of 367, with limits $405 a month | 221st of 367, with limits $287 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 | 268th of 346, with limits $403 a month | 223rd of 346, with limits $195 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 | 201st of 338, with limits $8,055 a month | 135th of 338, with limits $3,991 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 | 201st of 360, with limits $207 a month | 197th of 360, with limits $191 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 Cerebrium ranks 28th and fits this job fully, while Crusoe ranks 86th as a compromise; bochka has no GPUs. | 86th of 98, with limits $7,803 a month | 28th cheapest of 98 $1,975 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 | Crusoe | Cerebrium | bochka |
|---|---|---|---|
| What you get | Plain Ubuntu VMs with GPUs or CPUs, plus managed Kubernetes and Slurm, that you set up yourself | Your app, built from code or a Dockerfile, served as autoscaling containers behind endpoints | A sandbox for agents: a full VM with tools, desktop and coding agents ready |
| Isolation | Full VM on cloud-hypervisor | Containers; the docs do not name the isolation layer | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Shell, root and Docker | SSH with a sudo user; Docker preinstalled on GPU images; nested virtualization not documented | No SSH; Docker inside and /dev/kvm are not documented | SSH, root, systemd, Docker and /dev/kvm on every machine |
| Files after a stop | OS disk and attached disks survive; local NVMe is erased; the OS disk is billed until the VM is deleted | Only the shared /persistent-storage volume survives; files elsewhere reset | Whole disk saved every minute and on stop; a stopped sandbox costs nothing and keeps it |
| Fork and templates | Custom image of the boot disk, only while the VM is shut off | No fork; an early-beta memory checkpoint speeds up new containers of the same build | Fork a running sandbox; named snapshots as templates |
| Scale to zero and wake | No; you start and stop VMs yourself | Yes; apps scale to zero and start again on the next request | No; a stopped sandbox is started by API |
| Run time | No maximum; a VM runs until you stop or delete it | No container cap, but a request times out at response_grace_period (15 minutes by default, 12 hours at most for async runs) | No session cap on paid plans; you set the time to live |
| GPUs | Nvidia GB200, B300, B200, H200, H100, A100, L40S and AMD MI355X, MI300X; on-demand, spot or reserved | T4 to B200 and RTX PRO 6000, up to 8 per container, plus Inferentia2 and Trainium | None, CPU only |
| Inbound access | Public IPv4, static or dynamic; TCP and UDP load balancers; no managed HTTPS URLs | One HTTPS endpoint per app on one port; custom domains on Standard | Token-protected HTTPS URLs for up to 50 ports; raw TCP; dedicated IPv4 or IPv6 |
| Network rules | VPC firewall with allow rules by IP, port and protocol, in and out | No egress allowlist in the docs | Open internet on every plan; no provider-side allowlist |
| Desktop and computer use | None; install and stream a desktop yourself | No desktop or browser product | 60fps desktop with Chromium, computer use and browser control |
| Coding agents | None; an MCP server lets an assistant inspect your Crusoe infrastructure | None to run inside; an Agent Skill and docs MCP server help your agent deploy to Cerebrium | Claude Code, Codex, OpenCode and more preinstalled, driven from outside with a prompt, steer and events API |
| Keeping keys out of the machine | No credentials proxy; secrets live on the VM | Secrets reach the app as environment variables | AI credentials proxy for model providers and any HTTPS API |
| Regions | US (Houston, Virginia, Ohio, Sparks) and EU (Iceland, Norway) | US East, US Central, Stockholm and Finland; 8 more, including Tokyo, Mumbai and Sao Paulo, on request | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Crusoe | Cerebrium | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | Yes | No | 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 | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | No | Yes | Yes |
| Raw TCP inbound | Yes | Not published | Yes |
| Public IPv4 | Yes | No | No |
| Egress allowlist | Yes | No | 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 | No | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | Yes | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | No | Not published | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | No | 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
Neither Crusoe nor Cerebrium was in the StarSling hpc-sandbox-benchmarks run we use, so we cannot say which is faster at CPU work. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that run, on dedicated AMD Ryzen 9 9950X hosts. Crusoe's CPU VMs run on AMD Genoa or Turin processors, and Cerebrium's speed claims are about GPU inference and cold starts, which this test does not cover.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Crusoe and Cerebrium 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 | Crusoe, a month | Cerebrium, 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 | $32 · On-demand | $53 · Hobby · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $121 · On-demand | $210 · Hobby · 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 | $1,488 · On-demand | $2,557 · Hobby · 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 | $405 · On-demand | $715 · Hobby | $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 | $811 · On-demand | $1,681 · Standard | $2,000 · $2000/mo · with limits |
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 also pays for a 128 GB OS disk each month, running or stopped. It has no plan fee and does not charge for data transfer today.
Cerebrium: Cerebrium bills per second for each vCPU, GB of memory and GPU while a container runs. Hobby is free plus compute, Standard is $100 a month plus compute with no usage credit, and the protected tier costs 2x on all compute.
Cerebrium: Plans start at $20 a month, and the whole fee becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Crusoe fits every scenario, but it sells 4 GB of memory per vCPU, so the 4 vCPU rows use a 16 GB machine, and 50 agents or 300 user sandboxes may need a support ticket to raise project quotas. Cerebrium misses the coding agent, always-on and 50-agent rows because only /persistent-storage survives a stop, and the fleet also needs Docker inside, which it does not document. Crusoe does not charge for data transfer today, while Cerebrium publishes no egress price, so its scenarios count none. bochka fits all but the 1,000-job burst, where its start limits queue the jobs.
| Scenario | Crusoe | Cerebrium | 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 Crusoe when
you want full GPU or CPU VMs you run yourself, the newest Nvidia or AMD chips for training, or clusters with Kubernetes and Slurm.
- Full machines you control. Crusoe gives you a full VM with SSH and sudo that runs until you stop it, so long jobs need no endpoint wrapper.
- The newest training chips. For training, Crusoe rents Nvidia GB200 and B300 and AMD MI300X and MI355X, which Cerebrium does not list.
- Cluster tools and network control. Teams running clusters get managed Kubernetes, Slurm, shared disks and VPC firewall rules for traffic in and out.
Use Cerebrium when
you want to serve a model or app as an endpoint that scales with traffic and down to zero, without managing machines.
- Endpoints that scale to zero. Apps that wait for traffic scale to zero, start on the next request and grow to many replicas, billed per second.
- No machines to manage. You hand over code or a Dockerfile and a cerebrium.toml, and Cerebrium builds it and serves it as HTTP or WebSocket endpoints.
- More regions. It runs in the US and the EU by default, with Tokyo, Mumbai, Sao Paulo and more on request.
Where bochka fits
Crusoe and Cerebrium are both GPU clouds, and neither is built as a machine for an agent to work inside. If what you are really running is agents that write code, use a browser or host previews, bochka gives each one a full VM with a desktop and coding agents ready. Keep model training or serving on Crusoe or Cerebrium, since bochka has no GPUs.
A whole disk that saves itself and forks
On Cerebrium an agent's installs outside /persistent-storage reset after a stop, and on Crusoe branching means shutting the VM off to image its boot disk. bochka saves the whole disk every minute and forks a running sandbox.
Docker, /dev/kvm and a real shell
Cerebrium has no SSH and no documented Docker inside, and Crusoe does not document nested virtualization. Every bochka sandbox has root, systemd, Docker and /dev/kvm, so builds, emulators and VMs run inside it.
Desktop, agents and keys built in
Neither has a desktop or coding agents, so you build both, and keys sit on the VM or in environment variables an agent can read. bochka ships a 60fps desktop, preinstalled agents and a credentials proxy.
Use bochka when what you are running is agents that need a machine of their own: a full VM with Docker and /dev/kvm, a disk saved every minute, live forks, and a desktop and coding agents built in. Compare it one to one: bochka vs Crusoe and bochka vs Cerebrium.
Questions people ask
Is Crusoe cheaper than Cerebrium?
In every scenario we priced, Crusoe comes out lower: $121 against $210 a month for one agent that never stops, and $811 against $1,681 for 1,000 short jobs at once. Cerebrium bills nothing while an app is scaled to zero, which can matter for spiky traffic. bochka comes to $26 a month for the always-on agent.
Which is faster, Crusoe or Cerebrium?
We cannot say: neither was in the StarSling CPU benchmark we use. bochka did 26.69 runs per second on that test at 4 vCPU / 8 GB. For GPU work, speed depends on the chip you pick on either one.
Can Crusoe run Docker? Can Cerebrium?
A Crusoe VM is a full Ubuntu machine with a sudo user, and its GPU images come with Docker preinstalled. Cerebrium builds your app from a Dockerfile, but running Docker inside the app is not documented. bochka runs Docker, systemd and /dev/kvm in every sandbox.
What happens to files when they stop?
On Crusoe the OS disk and attached disks survive a stop, but local NVMe is erased and the OS disk keeps billing. On Cerebrium only /persistent-storage is kept and the rest resets. bochka saves the whole disk every minute and keeps it for free while stopped.
Which runs in more regions?
Cerebrium: US East, US Central, Stockholm and Finland, with 8 more such as Tokyo, Mumbai and Sao Paulo on request. Crusoe runs in Texas, Virginia, Ohio and Nevada, plus Iceland and Norway. bochka runs only in the EU, in Germany, Finland and France.
Is Crusoe or Cerebrium a sandbox for AI agents?
Neither is built as one. Crusoe gives you a plain VM to set up, and Cerebrium serves your app as endpoints with no shell. A bochka sandbox is a full VM with a desktop, coding agents and a credentials proxy ready.
Try bochka
Install the CLI, then run bochka new.
Product preview