Crusoe vs Baseten
Crusoe is a GPU cloud that rents you whole machines: Nvidia and AMD GPU VMs and plain CPU VMs that you log into over SSH and set up yourself. Baseten is an inference cloud: you hand it a model or a Docker image and it runs it as containers that scale with traffic, down 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.
Baseten
Baseten is an inference cloud: it runs AI models on GPUs for production apps, and sells hosted open models and training.
You package a model with Truss, its open-source format, or bring a Docker image, and Baseten runs it as replicas on Kubernetes that scale up with traffic and down to zero. It also sells Model APIs (open models priced per token) and training jobs on the same GPUs. Sandboxes, isolated environments where an agent runs commands and works with files, are in private preview; this page compares bochka with both the CPU instances and the sandbox preview.
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 | Baseten: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 232nd of 367, with limits $2,996 a month | 216th of 367, with limits $2,619 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 | 242nd of 366, with limits $3,258 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 Crusoe is the cheaper of the two for short bursts at $268 a month, while Baseten bills cold starts and, by default, 15 idle minutes per burst. | 128th of 345, with limits $268 a month | 319th of 345, with limits $1,856 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 gives each machine an HTTPS URL for your users the way bochka does; Baseten's preview sandboxes also stop at 10 per organization by default. | 104th of 361, with limits $951 a month | 277th of 361, with limits $1,868 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 | 322nd of 360, with limits $31,140 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 at $811 a month on CPU VMs, Baseten is a compromise at $1,609, and bochka fits at $200 with forks of a running sandbox. | 43rd cheapest of 364 $811 a month | 297th of 364, with limits $1,609 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 Crusoe fits CI runners as plain VMs with root and Docker, while Baseten's model containers run as a non-root user with no persistent disk; bochka fits at $86 a month. | 48th cheapest of 377 $395 a month | 320th of 377, with limits $1,119 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Crusoe VM keeps its OS disk across stops, so it works as a 24/7 dev box; a Baseten replica starts fresh from its image, so files do not stay. | 87th cheapest of 368 $121 a month | 170th of 368, with limits $130 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 Baseten has a desktop or computer-use API; bochka streams a 60fps desktop with Chromium from every sandbox. | 221st of 369, with limits $811 a month | 294th of 369, with limits $1,799 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 | 318th of 367, with limits $1,194 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 Baseten is the cheaper of the two for small scraping jobs at $183 a month, but its default outbound traffic is limited to ports 443 and 80. | 268th of 346, with limits $403 a month | 220th of 346, with limits $183 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 | 126th of 338, with limits $3,654 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 | 254th of 360, with limits $381 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 Both rent GPUs and bochka has none; Baseten fits GPU eval jobs fully at $1,625 a month, while Crusoe sells its H100s only as 8-GPU machines and lands at $7,803. | 86th of 98, with limits $7,803 a month | 24th cheapest of 98 $1,625 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 | Baseten | bochka |
|---|---|---|---|
| Kind of product | GPU and CPU cloud: plain Ubuntu VMs, Kubernetes, Slurm and managed inference | Inference cloud: model deployments, Model APIs and training; agent sandboxes in private preview | Sandboxes for AI agents: full VMs with agents, desktop and hosting ready |
| Isolation | Full VMs on cloud-hypervisor | Kubernetes containers in a dedicated namespace per customer | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| GPUs | Nvidia GB200, B300, B200, H200, H100, A100, L40S and AMD MI355X, MI300X | Nvidia T4, L4, A10G, A100, H100, H200, B200 and RTX PRO 6000, up to 8 per instance | None |
| Root and Docker | sudo user; Docker preinstalled on GPU images | Containers run as the non-root app user; Docker inside not documented | Root, systemd, Docker and /dev/kvm on every machine |
| Files after a stop | OS disk and attached disks survive a stop; local NVMe is erased | Replicas start fresh from the image; preview sandboxes are deleted after 7 days by default | Snapshots every minute and on stop; the disk is kept |
| Fork and templates | Custom image of the boot disk, only while the VM is shut off | No fork or clone; new replicas cold-start from the image | Fork a running sandbox; named snapshots as templates |
| Idle and stopped | No compute charge when stopped, but the 128 GB OS disk is billed until deleted | Deployments scale to zero and start on the next request | A stopped sandbox costs nothing and keeps its disk; you start it through the API |
| Desktop and computer use | None; install and stream a desktop yourself | None; sandboxes run commands and file operations | 60fps desktop and Chromium, computer use and browser control |
| Coding agents | None; an MCP server lets an assistant inspect your Crusoe infrastructure | Baseten Switch points Claude Code or Codex on your laptop at its Model APIs | Claude Code, Codex, OpenCode and more preinstalled, driven from outside with a prompt, steer and events API |
| Reaching the machine | Public IPv4, SSH, TCP and UDP load balancers; no managed HTTPS URLs | HTTPS API endpoint per deployment; SSH once enabled for your organization | Token-protected HTTPS URLs on up to 50 ports, raw TCP, dedicated IPv6 or IPv4 |
| Outbound network rules | VPC firewall with allow rules by IP, port and protocol, in and out | Ports 443 and 80 by default; IP and domain allowlists once enabled | Open internet on every plan; no provider-side allowlist |
| Keeping keys out of the machine | No credentials proxy; secrets live on the VM | Secrets passed into the model as arguments or files under /secrets | AI credentials proxy for model providers and any HTTPS API |
| Regions | US (Houston, Virginia, Ohio, Sparks) and EU (Iceland, Norway) | US and EU for GPU deployments; self-hosted in your own cloud on Enterprise | EU only: Germany, Finland, France |
| Billing | Per second while running, plus the OS disk every month | Per minute, rounded up, including image builds and cold starts | Monthly plan from $20, all of it usage credit spent per second |
Every feature Battleships tracks (43)
| Feature | Crusoe | Baseten | 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 | Yes | Yes |
| Persistent disk | Yes | No | 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 | 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 | Yes | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | No | No | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Yes | Not published | 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 Crusoe or Baseten: neither was 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, on dedicated AMD Ryzen 9 9950X hosts. Crusoe's CPU VMs run on AMD Genoa or Turin processors, and Baseten publishes no CPU benchmark.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Crusoe and Baseten 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 | Baseten, 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 | $34 · Basic · 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 | $136 · Basic · 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 | $1,701 · Basic · 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 | $1,246 · Basic · 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 | $811 · On-demand | $6,228 · Basic · with limits | $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. There is no plan fee and no data transfer charge today.
Baseten: Baseten bills per minute, with partial minutes rounded up, from image build and cold start until the replica stops; a 4 vCPU / 16 GiB CPU instance is $0.00346 a minute. There is no plan fee on Basic, and sandbox pricing for the preview is not published.
Baseten: 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 disk.
Limits in those scenarios
Baseten's CPU instances are model containers with no persistent disk, so files are lost when a replica stops, and it does not fit any of our five scenarios; its preview sandboxes run at most 10 per organization by default. Crusoe fits all five, but publishes no default quotas, so 50 agents or 300 user sandboxes may need a support ticket first. Crusoe's 4 vCPU machine has 16 GB of memory, against bochka's 8 GB sandbox. On bochka, 1,000 short jobs at once get queued and need more starts per day than the $2,000 plan allows.
| Scenario | Crusoe | Baseten | 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 whole GPU or CPU machines you set up yourself, need the largest GPUs with Kubernetes or Slurm, or want firewall control over every connection.
- Whole machines you control. If you want a plain VM with SSH, a disk that survives stops and your own setup, Crusoe rents exactly that.
- The biggest GPUs and clusters. For large training runs, Crusoe offers GB200, B300 and AMD MI355X, with InfiniBand, Kubernetes and Slurm.
- Network control in and out. Crusoe's VPC firewall allows only the traffic you list, by IP, port and protocol, with static public IPs.
Use Baseten when
you want a model served behind an API without running the machines, with deployments that scale to zero and wake on the next request.
- Models served for you. If you just want a model behind an API, Baseten packages it with Truss and runs the replicas for you.
- Scale to zero. For spiky traffic, Baseten deployments scale down to zero when idle and start again on the next request.
- Your own cloud account. On Enterprise, Baseten can run its workload plane in your own AWS, GCP or OCI account.
Where bochka fits
Crusoe and Baseten are both built around GPUs and model work, and bochka has no GPUs. If what you are really running is agents that write code, browse and test software, bochka gives each one a ready VM, and you can keep the model side on Crusoe or Baseten.
Work that saves itself and forks live
A Crusoe VM can only be copied by shutting it off and imaging its boot disk, and a Baseten replica starts fresh every time. bochka snapshots every minute and forks a running sandbox, so an agent never stops to branch.
Root, Docker and a desktop inside
Baseten containers run as a non-root user, so Docker-based builds fail, and neither cloud has a desktop. On Crusoe you install and stream one yourself. bochka ships root, Docker, /dev/kvm and a 60fps desktop with Chromium.
Agents driven from outside, keys kept out
On both clouds you install each coding agent, write the loop that prompts and watches it, and store API keys on the machine where agent code can read them. bochka preinstalls the agents and its credentials proxy keeps real keys outside.
Use bochka when the work is agents rather than models: full VMs with root and Docker, snapshots every minute, forks of a running sandbox, a desktop and coding agents built in. Compare it one to one: bochka vs Crusoe and bochka vs Baseten.
Questions people ask
Is Crusoe cheaper than Baseten?
For CPU machines in our scenarios, yes: one agent running all month comes to $121 on Crusoe and $136 on Baseten, and 50 agents in parallel to $1,488 versus $1,701. For GPU eval jobs Baseten is cheaper, at $1,625 a month against $7,803, because Crusoe sells H100s only as 8-GPU machines.
Which is faster, Crusoe or Baseten?
We have no comparable measurement for either: neither was in the StarSling benchmark run we use. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that run.
Can Crusoe or Baseten run Docker?
Crusoe gives you a VM with a sudo user, and its GPU images come with Docker installed. Baseten can run your own Docker image as a model server, but its containers run as a non-root user and Docker inside is not documented. Every bochka sandbox has root and Docker.
Does Baseten keep my files like a Crusoe VM?
No. A Crusoe VM keeps its OS disk and attached disks across a stop, while a Baseten replica starts fresh from its image. Baseten's preview sandboxes keep files on standby but are deleted after 7 days by default.
Are Crusoe and Baseten sandboxes for AI agents?
Not mainly. Crusoe rents plain VMs you set up yourself, and Baseten serves models, with agent sandboxes in private preview. Neither has a desktop, built-in coding agents or forks of a running machine, which bochka has on every sandbox.
Does bochka have GPUs?
No. bochka runs Linux VMs on dedicated AMD Ryzen 9 9950X hosts and has no GPUs. Run model training or serving on Crusoe or Baseten and keep your agents' workspaces on bochka.
Try bochka
Install the CLI, then run bochka new.
Product preview