Jarvislabs vs Verda
Jarvislabs and Verda are both GPU clouds that also rent plain CPU virtual machines. Jarvislabs runs in India, bills by the minute and lets you pause a VM, while Verda runs in Finland, has more GPU models and much bigger CPU machines, but keeps billing a shut-down instance until you delete it.
The companies and products
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.
Verda
Verda, called DataCrunch until 2025, is a European AI cloud that rents Nvidia GPUs, CPU machines and GPU clusters.
You create a GPU or CPU instance, add a disk and an SSH key, and get a full Linux VM with root and its own public IP. Verda also sells GPU clusters with InfiniBand and serverless containers that scale to zero for inference. It is built for teams that train, fine-tune and serve AI models, not as a sandbox for agents.
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. “20th cheapest of 377” means 19 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 | Jarvislabs: price rank | Verda: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both give a coding agent a raw VM with root to set up yourself, and neither has snapshots or forks of a running machine, while bochka ships the agents ready. | 154th of 367, with limits $1,406 a month | 88th of 367, with limits $788 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 185th of 366, with limits $1,670 a month | 133rd of 366, with limits $901 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 have serverless GPU workers that scale to zero, and plain CPU VMs that bill with no plan fee, which suits short bursts better than bochka's start limits. | 103rd of 345, with limits $169 a month | 99th of 345, with limits $165 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 Jarvislabs nor Verda publishes how many instances an account can run at once, so 300 sandboxes for your users means asking each for more first. | 215th of 361, with limits $539 a month | 71st of 361, with limits $629 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 | 43rd of 360, with limits $2,568 a month | 20th of 360, with limits $1,097 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 | 113th of 364, with limits $411 a month | 91st of 364, with limits $123 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, Verda with dedicated EPYC cores and Jarvislabs with per-minute billing, and bochka adds per-second billing and free stops between jobs. | 20th cheapest of 377 $253 a month | 10th cheapest of 377 $142 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Jarvislabs VM can be paused so only its disk bills, while a shut-down Verda instance keeps billing, so a dev box that sleeps at night suits Jarvislabs better. | 52nd cheapest of 368 $68 a month | 36th cheapest of 368 $45 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 API: Jarvislabs offers JupyterLab, VS Code and SSH, Verda a guide to install VNC, while bochka streams a 60fps desktop. | 154th of 369, with limits $377 a month | 82nd of 369, with limits $123 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 | 204th of 367, with limits $205 a month | 169th of 367, with limits $110 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 | 244th of 346, with limits $247 a month | 184th of 346, with limits $103 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 | 158th of 338, with limits $4,942 a month | 84th of 338, with limits $2,057 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 | 156th of 360, with limits $127 a month | 122nd of 360, with limits $66 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: Jarvislabs rents Nvidia L4 up to H200 by the minute, Verda rents V100 up to GB300, and bochka has no GPUs. | 9th cheapest of 98 $876 a month | 14th cheapest of 98 $1,039 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 | Jarvislabs | Verda | bochka |
|---|---|---|---|
| Kind of product | GPU cloud: GPU VMs, GPU containers, CPU VMs, clusters and model serving | GPU and CPU cloud: raw VMs, GPU clusters and serverless containers | Sandboxes for AI agents: VMs with agents, desktop and hosting ready |
| Isolation | GPU VMs and CPU VMs are KVM virtual machines; Templates are containers | Every instance is a full VM on KVM/QEMU | Every sandbox is a full VM with its own kernel |
| Docker and nested virtualization | Root on VMs, so you can run your own Docker; nested virtualization is not documented | Root on your own VM, so you can install Docker; nested virtualization is not documented | Docker, root, systemd and /dev/kvm on every machine |
| GPUs | Nvidia L4 up to H200, 1 to 8 per instance, on-demand, spot (Templates) or reserved, plus clusters | Nvidia V100 up to GB300, on-demand or spot, plus clusters with InfiniBand | None |
| Biggest CPU machine | CPU VMs up to 32 vCPU / 128 GB | CPU instances up to 360 vCPU / 1,440 GB on dedicated AMD EPYC cores | 16 vCPU / 32 GB on the $100 plan and up |
| Smallest CPU machine | 2 vCPU / 8 GB | 4 vCPU / 16 GB | 2 vCPU / 4 GB (small) |
| Stopping a machine | Pause stops compute billing; the disk keeps billing at $0.10/GB-month, with at least 100 GB on a VM | A shut-down instance keeps billing; only Delete stops the charge, and kept volumes bill at $0.20/GiB-month | A stopped sandbox costs nothing and keeps its disk |
| Snapshots and fork | No snapshot, clone or fork command; pause and resume keeps the disk (VMs) or only /home (containers) | Clone a volume once its instance is shut down or it is detached; no snapshots of a running machine | Snapshots every minute and on stop; fork a running sandbox |
| Desktop and computer use | No desktop; JupyterLab, VS Code in the browser and SSH | No built-in desktop; a guide to install XFCE and TigerVNC yourself | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Coding agents | A CLI and skill file so an agent on your own machine can create GPUs, run jobs and read logs | An MCP server and CLI agent mode so an outside agent can manage Verda machines | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Reaching the machine | VMs get a public IP with every port open by default; Templates expose chosen HTTP ports through proxy URLs | A free public IPv4 per instance and SSH; you set up TLS and the firewall (ufw) yourself | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Network rules | Security groups with inbound and outbound rules by port and IP range, VPCs and reserved IPs | No provider-side rules documented; you run ufw on the instance | Open internet on every plan; no provider-side allowlist |
| Keeping keys out of the machine | Keys are passed in as environment variables or uploaded files | Secrets only for serverless containers; on instances you place keys yourself | AI credentials proxy for model providers and any HTTPS API you register |
| Billing | Per minute from a prepaid wallet, $10 minimum top-up, no free trial | Prepaid balance charged in 10-minute blocks, unused part refunded | Monthly plan from $20, all of it usage credit spent per second |
| Regions | India only for new instances (IN1, IN2); CPU VMs only in Noida | EU only: three data centers in Helsinki, Finland | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Jarvislabs | Verda | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Not published | 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 | No | 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 | Yes | No | No |
| Wake on request | Yes | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | Yes | Yes | 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 | No | Yes | 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 | Not published | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Not published | Yes | No |
| SSO | No | No | No |
| SOC 2 | No | Yes | No |
| HIPAA | No | No | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement: neither Jarvislabs nor Verda was part of the public StarSling benchmark run. 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 (Zen 5) hosts. Verda says its CPU instances use dedicated AMD EPYC cores clocked at 3.3 GHz, 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. Jarvislabs and Verda 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 | Jarvislabs, a month | Verda, 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 | $21 · On-demand | $18 · Pay as you go | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $71 · On-demand | $45 · Pay as you go | $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 | $892 · On-demand | $622 · Pay as you go | $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 | $231 · On-demand · with limits | $254 · Pay as you go · 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 | $514 · On-demand · with limits | $507 · Pay as you go · with limits | $2,000 · $2000/mo · with limits |
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, and the disk is extra at $0.10/GB-month, billed while running and while paused, with at least 100 GB on a VM.
Verda: Verda charges a prepaid balance in 10-minute blocks and refunds the unused part when you delete early. CPU machines cost $0.012 per vCPU-hour with 4 GB of RAM each, the disk is extra at $0.20/GiB-month, and a shut-down instance keeps billing until you delete it.
Verda: 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
Neither Jarvislabs nor Verda publishes how many instances an account can run at once, so 300 sandboxes for your users or 1,000 short jobs at once are not confirmed until you ask for more. Verda's smallest CPU machine is 4 vCPU / 16 GB and Jarvislabs' is 2 vCPU / 8 GB, so small sandboxes cost more than they need to on both. If the balance runs out, Jarvislabs pauses instances and deletes all data once it goes negative, while Verda stops instances and deletes volumes with 96 hours to restore them. On bochka the 1,000-job burst is queued and needs more starts per day than the $2,000 plan allows.
| Scenario | Jarvislabs | Verda | 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 Jarvislabs when
you want Nvidia GPUs or CPU VMs in India, billed by the minute, that you can pause without paying for compute, with security groups and VPCs.
- Pause without paying for compute. Useful for machines that sleep often: pausing a Jarvislabs VM stops compute billing and keeps its whole disk.
- Network rules set by the provider. Useful when you need firewalls outside the machine: Jarvislabs has security groups, private VPCs and reserved IPs.
- Machines in India. Useful for teams in India: Jarvislabs runs its new instances there, and Indian customers can pay in rupees.
Use Verda when
you need machines in the EU, the newest Nvidia GPUs or GPU clusters, or a single very large CPU machine.
- More GPUs and bigger clusters. Useful for large training runs: Verda rents Nvidia GPUs up to GB300 and sells clusters with InfiniBand between nodes.
- Very large CPU machines. Useful for one huge job: Verda CPU instances go up to 360 dedicated vCPU and 1,440 GB of RAM.
- Machines in the EU. Useful when your data must stay in Europe: all of Verda's data centers are in Helsinki, Finland.
Where bochka fits
Jarvislabs and Verda 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 on CPU machines, both hand you a raw VM to set up, keep billing something while it sleeps, and cannot copy a running machine. bochka is built for that work.
Free stops, snapshots every minute, live fork
A paused Jarvislabs VM still bills at least 100 GB of disk, and a shut-down Verda instance bills at its full rate until deleted. Neither can fork a running machine, so each copy is built by hand.
Coding agents and a desktop built in
On both, you install the agent, a browser and any desktop yourself. Their CLI and MCP tools let an agent manage machines from outside, not work inside one, so you maintain the setup scripts and desktop stream.
HTTPS ports and keys out of the sandbox
On Jarvislabs and Verda, API keys live on the machine, where an agent can leak them in a log or commit, and every preview server needs its own TLS and firewall. bochka serves 50 HTTPS ports and proxies keys.
Use bochka when you run agents rather than models: VMs that come with coding agents, a desktop, HTTPS ports and a credentials proxy, that snapshot every minute, fork while running and cost nothing while stopped. Compare it one to one: bochka vs Jarvislabs and bochka vs Verda.
Questions people ask
Is Jarvislabs cheaper than Verda?
Mostly not for CPU work. One coding agent on workdays comes to $21 a month on Jarvislabs and $18 on Verda, one agent running all month is $71 versus $45, and 50 agents in parallel are $892 versus $622. On bochka those come to $20, $26 and $317.
Which is faster, Jarvislabs or Verda?
There is no comparable CPU measurement for either: neither was in the public StarSling benchmark run. Verda says its CPU instances use dedicated AMD EPYC cores at 3.3 GHz. bochka did 26.69 runs per second in that run on dedicated AMD Ryzen 9 9950X hosts.
Can Jarvislabs and Verda run Docker?
Yes. Both give you root on a full VM, so you can install and run Docker yourself, though neither documents nested virtualization. bochka has Docker, systemd and /dev/kvm ready on every machine.
Does a stopped machine cost money on Jarvislabs or Verda?
On Jarvislabs, pausing stops compute billing but the disk keeps billing at $0.10/GB-month, with at least 100 GB on a VM. On Verda, a shut-down instance keeps billing at its full rate until you delete it. A stopped bochka sandbox costs nothing and keeps its disk.
Where does my data run?
Jarvislabs creates new instances only in India; its old EU1 region no longer accepts new instances. Verda runs three data centers in Helsinki, Finland. bochka runs only in the EU, in Germany, Finland and France, with EU data residency.
Does bochka have GPUs?
No. bochka runs Linux VMs on dedicated AMD Ryzen 9 9950X hosts and has no GPUs. If your agents need to train or serve models, rent the GPUs on Jarvislabs or Verda.
Try bochka
Install the CLI, then run bochka new.
Product preview