Runpod vs Jarvislabs
Both are GPU clouds you pay for from a prepaid balance. Runpod gives you containers with a wide range of Nvidia and AMD cards in the US, Canada, Europe and Australia, while Jarvislabs gives you real KVM virtual machines with Nvidia cards, mostly in India.
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
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. “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 | Jarvislabs: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A Runpod pod cannot run Docker or Docker Compose inside, while a Jarvislabs VM can, but on both you install the coding agent and tooling yourself; bochka ships them ready. | 203rd of 367, with limits $2,362 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 | 211th of 366, with limits $2,290 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 Runpod comes to $135 a month and Jarvislabs to $169 for short code runs, both compromises, and Jarvislabs VMs take about 90 seconds to boot. | 227th of 345, with limits $135 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 Neither Runpod nor Jarvislabs publishes how many machines can run at once, so 300 sandboxes for your users is not confirmed on either. | 83rd of 361, with limits $733 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 | 53rd of 360, with limits $3,068 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 | 127th of 364, with limits $614 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 fit plain build and test jobs; only Jarvislabs VMs and bochka can run Docker inside, so jobs that start containers rule out Runpod. | 32nd cheapest of 377 $301 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 Jarvislabs VM keeps its whole disk when paused, so it is a full fit; on a Runpod pod anything installed outside /workspace is gone after a stop, and bochka keeps the whole disk for free. | 161st of 368, with limits $93 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: Runpod and Jarvislabs both offer a terminal, SSH, JupyterLab and VS Code, while bochka streams a 60fps desktop with computer use. | 189th of 369, with limits $614 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 | 224th of 367, with limits $307 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 | 225th of 346, with limits $202 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 | 138th of 338, with limits $4,035 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 | 180th of 360, with limits $161 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 Both fit GPU eval jobs and bochka has no GPUs: Jarvislabs ranks 9th of 98 at $876 a month, and Runpod comes 13th at $1,001 a month. | 13th cheapest of 98 $1,001 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 | Runpod | Jarvislabs | bochka |
|---|---|---|---|
| Isolation | Containers that share the host kernel | GPU and CPU VMs are KVM virtual machines; Templates are containers | Every sandbox is a full VM with its own kernel |
| Docker inside | Root in the container; no Docker or Docker Compose inside a pod | Root on VMs, so you can run your own Docker daemon; nested virtualization is not documented | Docker, Docker Compose, root, systemd and /dev/kvm on every machine |
| GPUs | Dozens of Nvidia and AMD types, from RTX A4000 to B300 and MI300X, plus multi-node clusters | Nvidia L4 up to H200, 1 to 8 per instance, spot on Templates, B200 as reserved clusters | None |
| Files after a stop | Only /workspace is kept, billed at double the running rate while stopped; the rest of the container disk is cleared | VMs keep the whole disk, Templates only /home; the disk keeps billing at $0.10/GB-month, with at least 100 GB on a VM | The whole disk is kept and a stopped sandbox costs nothing |
| Snapshots and fork | No pod snapshot or fork; templates save the image and settings only | No snapshot, clone or fork command | Snapshots every minute and on stop; fork a running sandbox |
| Desktop and computer use | Web terminal, SSH, JupyterLab and remote VS Code or Cursor; no desktop | JupyterLab, VS Code in the browser and SSH; no desktop | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Coding agents | An MCP server and skills let an agent on your own machine manage Runpod | A CLI and skill file let an agent on your own machine create GPUs, run jobs and read logs | Claude Code, Codex, OpenCode and more preinstalled, driven from outside with a prompt, steer and events API |
| Reaching the machine | Up to 10 HTTP ports on a public proxy URL with no built-in auth; TCP ports on a public IP; no UDP | VMs get a public IP with every port open by default; Templates expose chosen HTTP ports through proxy URLs | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Firewall rules | You choose which ports to expose; no provider-side egress allowlist | Security groups with inbound and outbound rules by port and IP range, VPCs and reserved IPs | Open internet on every plan; no provider-side allowlist |
| Keeping keys out of the machine | Secrets stored encrypted and passed into the pod as environment variables | Keys passed in as environment variables or uploaded files | AI credentials proxy for model providers and any HTTPS API you register |
| Scale to zero | Serverless workers run your own handler, scale to zero and start on a request | Serverless model workers (vLLM, SGLang, Ollama) stop after an idle timeout and start on the next request | No wake on request; you start a stopped sandbox through the API |
| Shared storage | Network volumes several pods can mount at once, plus an S3-compatible API | Shared filesystems up to 10 TB, not on CPU VMs | Each sandbox has its own disk; share files by fork or your own storage |
| Regions | 24 documented data centers in the US, Canada, Europe and Australia | India only for new instances (IN1, IN2); CPU VMs only in Noida | EU only: Germany, Finland, France |
| Billing | Per second from a prepaid balance; a new pod needs at least one hour of credit | Per minute from a prepaid wallet, $10 minimum top-up, no plan fee | Monthly plan from $20, all of it usage credit spent per second; stops are free |
Every feature Battleships tracks (43)
| Feature | Runpod | Jarvislabs | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | Not published | 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 | 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 | Yes | Yes | No |
| HTTPS preview URLs | Yes | Yes | 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 | No | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | 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 | Yes | Yes |
| Usage per sandbox (API) | No | 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 Runpod or Jarvislabs: neither is in the public StarSling sandbox benchmark 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. Jarvislabs publishes GPU benchmarks for its H200 VMs, but not for its CPU VMs.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Runpod 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 | Runpod, 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 | $26 · Pay-as-you-go (prepaid credits) · with limits | $21 · 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 | $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,156 · Pay-as-you-go (prepaid credits) · with limits | $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 | $307 · Pay-as-you-go (prepaid credits) · with limits | $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 | $614 · Pay-as-you-go (prepaid credits) · with limits | $514 · On-demand · with limits | $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 billing its /workspace volume at double the running rate. CPU pods are not on the pricing page; the rates here come from Runpod's public CPU catalogue, at $0.03 per vCPU-hour with 2 GB of RAM per vCPU.
Jarvislabs: Jarvislabs bills per minute from a prepaid wallet with no plan fee. CPU VMs cost $0.012 per vCPU-hour plus $0.0032 per GB of RAM, with 4 GB per vCPU, and the disk is $0.10/GB-month while running and paused, with at least 100 GB on a VM.
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 whole disk.
Limits in those scenarios
Neither Runpod nor Jarvislabs publishes how many machines an account can run at once, so 300 user sandboxes and 1,000 short jobs at once are not confirmed on either; Runpod limits spend instead, at $80 an hour by default. Runpod also misses the single-agent and fleet scenarios because packages installed outside /workspace are gone after a stop, and the 50-agent fleet also needs Docker inside, which pods cannot run. Jarvislabs fits the single agent and the fleet, but its smallest CPU VM is 2 vCPU / 8 GB and each VM takes about 90 seconds to boot. On bochka the 1,000-job burst is queued and needs more starts per day than the $2,000 plan allows.
| Scenario | Runpod | Jarvislabs | 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 |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Runpod when
you need a specific Nvidia or AMD card, serverless workers for your own code, or machines in the US, Canada, Europe or Australia.
- The widest choice of GPUs. For teams that need a specific card: Runpod rents dozens of Nvidia and AMD types, up to B300 and MI300X, plus multi-node clusters.
- Serverless for your own code. For spiky work: Runpod Serverless runs your own handler in workers that scale to zero and start when a request arrives.
- Regions on four continents and shared volumes. For data that must stay in the US, Canada, Europe or Australia, or many pods reading one network volume.
Use Jarvislabs when
you want Nvidia GPUs or CPU machines as real VMs with root, Docker and a disk that survives a pause, with firewall rules, in India.
- Real VMs that keep their disk. For work that needs root, Docker and installed packages: Jarvislabs VMs are KVM machines that keep the whole disk when paused.
- Firewall rules from the provider. For teams that want locked-down machines: Jarvislabs has security groups, private VPCs and reserved IPs on its VMs.
- Machines in India. For teams in India: Jarvislabs runs its machines there, and Indian customers can pay in rupees.
Where bochka fits
Runpod and Jarvislabs 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 ready VM with coding agents, a desktop and free stops, in the EU.
A full VM with Docker and /dev/kvm
On a Runpod pod, docker compose up fails because pods cannot run Docker inside. A Jarvislabs VM runs Docker but does not document nested virtualization. bochka has Docker, systemd and /dev/kvm on every machine, so emulators run too.
Free stops, snapshots and live fork
Runpod keeps only /workspace after a stop and bills it at double rate; Jarvislabs keeps the disk but bills at least 100 GB while paused. Neither snapshots or forks. bochka snapshots every minute, forks running sandboxes and stops for free.
Agents, a desktop and a keys proxy built in
Both give you a clean Linux box and a CLI for an agent on your laptop, with keys sitting inside as environment variables. bochka ships Claude Code and Codex inside, a 60fps desktop, and a proxy that keeps real keys out.
Use bochka when your agents write and run code for hours on CPU machines: a full VM with Docker and /dev/kvm, coding agents and a desktop built in, snapshots every minute and free stops, in the EU. Compare it one to one: bochka vs Runpod and bochka vs Jarvislabs.
Questions people ask
Is Runpod cheaper than Jarvislabs?
In our CPU scenarios Jarvislabs comes out lower: one coding agent on workdays is $26 a month on Runpod and $21 on Jarvislabs, one agent running all month $93 versus $71, and 50 agents $1,156 versus $892. For GPU eval jobs Runpod comes to $1,001 a month and Jarvislabs to $876. On bochka the same three CPU scenarios come to $20, $26 and $317.
Which is faster, Runpod or Jarvislabs?
Neither has a comparable CPU measurement in the public benchmark run we use, so we cannot say. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that run.
Can Runpod or Jarvislabs run Docker?
Runpod's docs say you cannot start your own Docker or use Docker Compose inside a pod, because pods are containers. Jarvislabs VMs give you root, so you can run your own Docker daemon there. On bochka every sandbox is a VM with Docker, Docker Compose and /dev/kvm ready.
Which has more GPU types?
Runpod: it lists dozens of Nvidia and AMD types, from RTX A4000 up to B300 and MI300X. Jarvislabs rents Nvidia L4, A30, A100, RTX Pro 6000, H100 and H200, with B200 as reserved clusters. bochka has no GPUs.
What happens to my files when I stop a machine?
On Runpod only /workspace is kept, and you pay double the running rate for it while stopped. A paused Jarvislabs VM keeps its whole disk and keeps billing it, at least 100 GB, while its GPU containers keep only /home. A stopped bochka sandbox keeps its whole disk and costs nothing.
Where do Runpod and Jarvislabs run?
Runpod documents 24 data centers in the US, Canada, Europe and Australia. Jarvislabs creates new instances only in India, and its old EU1 region no longer accepts new ones. bochka runs only in the EU: Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview