Crusoe vs Jarvislabs
Both are GPU clouds that also rent plain CPU VMs. Crusoe is the bigger one, with the newest Nvidia and AMD GPUs, Kubernetes and Slurm in the US and EU, while Jarvislabs rents Nvidia GPUs by the minute from a prepaid wallet in India, with ready GPU containers and model serving that scales 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.
Jarvislabs
Jarvislabs is an AI cloud from India that rents Nvidia GPUs by the minute for training and serving models.
You can rent a GPU VM with root and your own kernel, a Template (a GPU container with PyTorch, ComfyUI or similar ready, opened in JupyterLab, VS Code or SSH), a plain CPU VM, or a multi-node GPU cluster. It also serves open models through Managed Endpoints, Serverless workers and a token-priced Model API. It is built for people who train, fine-tune and serve AI models, not as a sandbox for agents, though its jl CLI is written so a coding agent on your laptop can drive the GPUs.
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 | Jarvislabs: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither ships a desktop, coding agents or forks of a running machine, so both are a compromise for a software factory; bochka has all three on every sandbox. | 232nd of 367, with limits $2,996 a month | 154th of 367, with limits $1,406 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 | 185th of 366, with limits $1,670 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 bill small CPU VMs with no plan fee, which suits short bursts, but a Crusoe VM can take up to a minute to be created and a Jarvislabs VM about 90 seconds to boot. | 128th of 345, with limits $268 a month | 103rd of 345, with limits $169 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 can run 300 user sandboxes once support raises your quota, but has no HTTPS URL per machine; Jarvislabs does not publish how many instances can run at once. | 104th of 361, with limits $951 a month | 215th of 361, with limits $539 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 | 43rd of 360, with limits $2,568 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 fully, while Jarvislabs is a compromise because it does not publish how many machines can run at once. | 43rd cheapest of 364 $811 a month | 113th of 364, with limits $411 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 make plain CI runners on CPU VMs; bochka adds per-second billing with stops that cost nothing between jobs. | 48th cheapest of 377 $395 a month | 20th cheapest of 377 $253 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box that runs all month fits on both, at $121 a month on Crusoe and $68 on Jarvislabs, against $26 on bochka. | 87th cheapest of 368 $121 a month | 52nd cheapest of 368 $68 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 has a desktop or computer-use tools, so you would install and stream a desktop yourself; bochka ships a 60fps desktop with Chromium. | 221st of 369, with limits $811 a month | 154th of 369, with limits $377 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 | 204th of 367, with limits $205 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 | 244th of 346, with limits $247 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 | 158th of 338, with limits $4,942 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 | 156th of 360, with limits $127 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 Jarvislabs is the full fit for GPU eval jobs with Nvidia GPUs from L4 to H200 by the minute, while Crusoe's big SXM GPUs come only as 8-GPU machines, which makes small jobs a compromise; bochka has no GPUs. | 86th of 98, with limits $7,803 a month | 9th cheapest of 98 $876 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 | Jarvislabs | bochka |
|---|---|---|---|
| Kind of product | GPU and CPU cloud with managed Kubernetes, Slurm and managed inference | GPU cloud: GPU VMs, GPU containers (Templates), CPU VMs, clusters and model serving | Sandboxes for AI agents: full VMs with agents, desktop and hosting ready |
| GPUs | Nvidia GB200, B300, B200, H200, H100, A100, L40S and AMD MI355X, MI300X | Nvidia H200, H100, RTX Pro 6000, A100, A30 and L4, 1 to 8 per instance; B200 as reserved clusters | None |
| Isolation | Full VMs on cloud-hypervisor | KVM VMs for GPU and CPU machines; Templates are containers | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root, Docker and nested virtualization | sudo user; Docker preinstalled on GPU images; nested virtualization not documented | Root on VMs, so you can run your own Docker daemon; nested virtualization not documented | Root, systemd, Docker and /dev/kvm on every machine |
| Smallest CPU VM | 2 vCPU / 8 GiB, with 4 GB of memory per vCPU | 2 vCPU / 8 GB, with 4 GB of RAM per vCPU | 2 vCPU / 4 GB, and 4 vCPU / 8 GB by default |
| Saving and copying a machine | Custom image of the boot disk, only while the VM is shut off; no snapshots of running VMs | No snapshot, clone or fork command; pause keeps the disk | Snapshots every minute and on stop; fork a running sandbox |
| Stopped machines | No compute charge, but the 128 GiB OS disk bills until the VM is deleted | No compute charge, but the disk keeps billing, with at least 100 GB on a VM | A stopped sandbox costs nothing and keeps its disk |
| Desktop and computer use | None; install and stream a desktop yourself | No desktop; JupyterLab, VS Code in the browser and SSH | 60fps desktop and Chromium, computer use and browser control |
| Coding agents | None inside; an MCP server lets an assistant inspect your Crusoe infrastructure | None inside; a CLI and skill file let an agent on your laptop create GPUs and run jobs | 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 | Public IP with every port open by default; Templates get HTTP proxy URLs | Token-protected HTTPS URLs for up to 50 ports, raw TCP, its own IP |
| Keeping keys out of the machine | No credentials proxy; secrets live on the VM | Keys are passed in as environment variables or uploaded files | AI credentials proxy for model providers and any HTTPS API |
| Network rules | VPC firewall with allow rules by IP, port and protocol, in and out | Security groups with inbound and outbound rules, VPCs and reserved IPs | Open internet on every plan; no provider-side allowlist |
| Model serving | Managed inference | Managed Endpoints and Serverless workers that scale to zero when idle | None; a sandbox does not wake on a request |
| Regions | US (Texas, Virginia, Ohio, Nevada) and EU (Iceland, Norway) | India only for new instances | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Crusoe | Jarvislabs | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Not published | Yes |
| Root | Yes | Yes | 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 | Yes | Yes |
| Pause/resume | Yes | Yes | 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 | Yes | Yes |
| Public IPv4 | Yes | Yes | 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 | 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 | Yes | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | No | 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 CPU measurement for Crusoe or Jarvislabs: 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 Jarvislabs publishes GPU benchmarks but 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 Jarvislabs 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 | Jarvislabs, 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 | $21 · On-demand | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $121 · On-demand | $71 · 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,488 · On-demand | $892 · 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 | $405 · On-demand | $231 · On-demand · 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 | $514 · On-demand · with limits | $2,000 · $2000/mo · with limits |
Crusoe: Crusoe bills each VM per second while it runs, with no plan fee and no data transfer charges today, and every VM also pays for a 128 GiB OS disk each month, running or stopped. VM billing needs a non-prepaid credit card, and reservations bill for their whole term.
Jarvislabs: Jarvislabs bills per minute from a prepaid wallet with a $10 minimum top-up and no free trial. Disk costs $0.10 per GB-month while running and while paused, with at least 100 GB on a VM, and data is deleted if the balance goes negative.
Jarvislabs: 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
Both sell CPU VMs with 4 GB of memory per vCPU, so the 4 vCPU rows use 16 GB machines on both. Crusoe sets CPU and GPU quotas per project that support can raise, so 300 user sandboxes or 1,000 jobs at once may need a ticket first. Jarvislabs publishes no limit on machines running at once, so those two scenarios are not confirmed until you ask. On bochka the limit is a sandbox count by plan plus starts per minute, so the 1,000-job burst is queued and needs more starts per day than the $2,000 plan allows.
| Scenario | Crusoe | Jarvislabs | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite | None that bite | None that bite |
| One agent that never stops | None that bite | 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 need the newest Nvidia or AMD GPUs, machines in the US or Europe, or cluster tools like Kubernetes and Slurm.
- The newest and biggest GPUs. For large training or serving jobs, Crusoe rents Nvidia GB200, B300 and B200 and AMD MI355X and MI300X GPUs.
- US and EU regions. For teams that need machines in the US or Europe, Crusoe runs in Texas, Virginia, Ohio, Nevada, Iceland and Norway.
- Cluster tools built in. For cluster jobs, Crusoe offers managed Kubernetes, Slurm, shared disks and much larger CPU and storage VMs.
Use Jarvislabs when
you want one Nvidia GPU at a time by the minute, model serving that scales to zero, or machines in India.
- Small GPUs by the minute. For short GPU jobs, Jarvislabs rents one Nvidia GPU at a time, from L4 to H200, billed per minute.
- Model serving that scales to zero. For inference, Jarvislabs Serverless workers stop after an idle timeout and start again on the next request.
- Ready GPU containers in India. For teams in India, Jarvislabs Templates open PyTorch or ComfyUI in JupyterLab or VS Code, and you can pay in rupees.
Where bochka fits
Crusoe and Jarvislabs are GPU clouds, and bochka has no GPUs, so model training and serving belong on one of them. If what you are really running is agents on CPU machines, both give you a bare Linux VM to build on, while bochka gives each agent a ready full VM with its own kernel. Many teams keep the GPU work on a GPU cloud and the agents on bochka.
Work that saves itself and forks live
Neither can snapshot or fork a running machine. On Crusoe you shut the VM off to image it, on Jarvislabs you rebuild by hand, and both keep billing the disk of a stopped machine. bochka snapshots every minute and stops for free.
Agents and a desktop inside
Both start as a plain Linux server, and their agent tools only manage machines from your laptop. You would install each agent, a browser and a desktop stream yourself. bochka ships coding agents you drive from outside and a 60fps desktop.
HTTPS ports and keys kept out
On Crusoe and Jarvislabs an agent's API keys sit on its own machine, and every preview needs your own TLS and firewall rules. bochka serves HTTPS on up to 50 ports behind a token and keeps real keys in a credentials proxy.
Use bochka when you run agents: full VMs that come with coding agents, a desktop, HTTPS ports and a credentials proxy, snapshot every minute, fork while running and cost nothing while stopped. Compare it one to one: bochka vs Crusoe and bochka vs Jarvislabs.
Questions people ask
Is Crusoe cheaper than Jarvislabs?
For CPU VMs in our scenarios, no. One agent running all month comes to $121 on Crusoe and $71 on Jarvislabs, and 50 agents in parallel to $1,488 versus $892. bochka comes to $26 and $317 for the same two jobs.
Which is faster, Crusoe or Jarvislabs?
We have no comparable CPU measurement for either, since neither was in the StarSling benchmark run. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that run.
Can Crusoe and Jarvislabs run Docker?
Yes. Crusoe preinstalls Docker on its GPU images, and Jarvislabs VMs give you root to run your own Docker daemon. Neither documents nested virtualization, while every bochka sandbox has Docker, systemd and /dev/kvm.
Can I snapshot or fork a machine on Crusoe or Jarvislabs?
On Crusoe you can only make a custom image of the boot disk while the VM is shut off. Jarvislabs has no snapshot, clone or fork command. bochka snapshots every sandbox every minute and can fork one while it runs.
Where do Crusoe and Jarvislabs run?
Crusoe runs in the US (Texas, Virginia, Ohio, Nevada) and in Iceland and Norway. Jarvislabs creates new instances only in India. bochka runs only in the EU, in Germany, Finland and France.
Which has more GPUs?
Crusoe has the wider range, up to Nvidia GB200 and AMD MI355X. Jarvislabs rents Nvidia L4 to H200, 1 to 8 per instance, and B200 as reserved clusters. bochka has no GPUs.
Try bochka
Install the CLI, then run bochka new.
Product preview