Jarvislabs vs Replicate
Jarvislabs rents you a machine: a GPU or CPU virtual machine with root and SSH, billed by the minute, mostly in India. Replicate rents you a model: you call it through an API, and its GPUs scale up with requests and down to zero.
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.
Replicate
Replicate runs AI models with an API: thousands of community and official models, plus your own models packaged with Cog.
You call a public model with one API request, fine-tune one on your data, or package your own model with Cog, Replicate's open-source tool that builds a Docker image with an HTTP prediction server. Replicate runs it on CPU or NVIDIA GPU hardware as deployments that scale up with traffic and down to zero. It is built for teams that serve models, 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. “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 | Replicate: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs root, Docker and a lasting disk: Jarvislabs CPU VMs have them but no snapshots or forks, and a Replicate model is a stateless container behind an API. | 154th of 367, with limits $1,406 a month | 268th of 367, with limits $4,340 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 | 335th of 366, with limits $11,300 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 runs suit both: Jarvislabs bills small CPU VMs by the minute, though each takes about 90 seconds to boot, and Replicate bills per second and scales back to zero. | 103rd of 345, with limits $169 a month | 258th of 345, with limits $295 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 Replicate's deployments scale out to the 300 at once this needs, while Jarvislabs does not publish how many instances an account can run at once; bochka gives each user a full VM with a lasting disk. | 215th of 361, with limits $539 a month | 317th of 361, with limits $3,705 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 | 174th of 360, with limits $17,900 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 Replicate is a full match for agent evals at rank 67 and Jarvislabs a compromise at 113, while bochka ranks 10th with a full VM per run. | 113th of 364, with limits $411 a month | 67th cheapest of 364 $1,440 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 A Jarvislabs CPU VM makes a plain CI runner and ranks 20th, while Replicate has no shell or documented Docker inside to build in; bochka ranks 4th. | 20th cheapest of 377 $253 a month | 311th of 377, with limits $864 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: a Jarvislabs VM has both, and Replicate has neither. | 52nd cheapest of 368 $68 a month | 306th of 368, with limits $226 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 a computer-use API, while bochka streams a 60fps desktop with Chromium and computer use. | 154th of 369, with limits $377 a month | 263rd of 369, with limits $1,296 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 | 322nd of 367, with limits $1,296 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 | 272nd of 346, with limits $439 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 | 221st of 338, with limits $8,775 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 | 306th of 360, with limits $855 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 ranks 9th of 98 and Replicate ranks 22nd, while bochka has no GPUs. | 9th cheapest of 98 $876 a month | 22nd cheapest of 98 $1,338 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 | Replicate | bochka |
|---|---|---|---|
| What you get | A GPU or CPU VM with root and SSH, a GPU container (Template), a GPU cluster, or model serving | A model packaged as a Cog container and called through a prediction API; no SSH | A full VM with its own kernel, root, SSH and systemd, made for agents to work inside |
| Docker and nested virtualization | Root on VMs, so you can run your own Docker daemon; nested virtualization is not documented | The model is the container; Docker inside and /dev/kvm are not documented | Docker, root, systemd and /dev/kvm on every machine |
| GPUs | Nvidia L4 up to H200, 1 to 8 per instance, billed per minute; on-demand, spot (Templates), reserved and clusters | T4, L40S, A100 80GB, H100 and H200, up to 8 per instance, billed per second; H200 and most multi-GPU need a committed spend contract | None, CPU only |
| Ready-made models | Open models served through Managed Endpoints, Serverless workers and a token-priced Model API | Thousands of public and official models for images, video, speech and text, plus fine-tuning | None; your agent calls the model API you choose |
| Scale to zero | Serverless model workers stop after an idle timeout and start on the next request | Deployments scale to zero and start on the next prediction, with min and max instances you set | No wake on request; you start a stopped sandbox through the API |
| Files after a stop | A paused VM keeps its disk, which bills at $0.10/GB-month with at least 100 GB; containers keep only /home | No persistent disk; instances start fresh from the image, and API inputs and outputs are deleted after an hour by default | The whole disk is saved every minute and on stop, and a stopped sandbox keeps it for free |
| Snapshots and fork | No snapshot, clone or fork command | No snapshots or fork; you add replicas of the same image | Snapshots every minute and on stop; fork a running sandbox |
| Run time | No documented cap; instances run until you pause them or the balance hits zero | Instances can stay on, but each prediction times out after 30 minutes unless support raises it | No session cap on paid plans; you set the time to live |
| Desktop and computer use | No desktop; JupyterLab, VS Code in the browser and SSH | No desktop or browser product | 60fps desktop with Chromium, computer use and browser control |
| Coding agents | A CLI and skill file so an agent on your own machine can create GPUs, run jobs and read logs | None to run inside; it hosts models your agent can call | Claude Code, Codex, OpenCode and more preinstalled, driven from outside 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 | One prediction API per model behind API token auth; no own IP or ports | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Keeping keys out of the machine | Keys are passed in as environment variables or uploaded files | Secrets are sent to the model as inputs and redacted from logs afterwards | AI credentials proxy for model providers and any HTTPS API you register |
| Network rules | Security groups with inbound and outbound rules by port and IP range, VPCs and reserved IPs | No network rules documented | Open internet on every plan; no provider-side allowlist |
| Regions and self-hosting | India only for new instances (IN1, IN2); not self-hostable | Subprocessors listed in the United States, no region choice; Cog images run anywhere Docker runs | EU only: Germany, Finland, France; not self-hostable |
Every feature Battleships tracks (43)
| Feature | Jarvislabs | Replicate | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | Not published | 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 | No | Yes |
| Pause/resume | Yes | No | 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 | Yes | Yes | No |
| Wake on request | Yes | Yes | No |
| HTTPS preview URLs | Yes | 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 | No | Yes | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | No | No |
| Open source | No | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | No | No | No |
| SOC 2 | No | Not published | No |
| HIPAA | No | Not published | No |
| EU data residency | No | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for either: neither Jarvislabs nor Replicate was part of the StarSling hpc-sandbox-benchmarks CPU test. 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. Both GPU clouds pick their hardware for GPU work, 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. Jarvislabs and Replicate 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 | Replicate, 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 | $57 · Usage · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $71 · On-demand | $237 · Usage · 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 | $892 · On-demand | $2,851 · Usage · 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 | $231 · On-demand · with limits | $1,620 · Usage | $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 | $3,580 · Usage | $2,000 · $2000/mo · with limits |
Jarvislabs: Jarvislabs bills per minute from a prepaid wallet with no plan fee and a $10 minimum top-up. CPU VMs cost $0.012 per vCPU-hour plus $0.0032 per GB of RAM, and disk is extra at $0.10/GB-month, billed while running and while paused.
Replicate: Replicate bills per second by hardware tier from prepaid credit that expires after a year. Public models bill only while they run; private models and deployments also bill setup and idle time.
Replicate: bochka 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
Replicate does not fit the workday agent, the always-on agent or the 50-agent fleet, because it has no persistent disk, and the fleet also needs Docker inside, which is not documented. Each Replicate prediction also stops at 30 minutes unless support raises it. Jarvislabs fits those three, but does not publish how many instances an account can run at once, so 300 sandboxes for your users and 1,000 short jobs at once are not confirmed, while Replicate fits both. bochka fits every scenario except the 1,000-job burst, where its starts are queued.
| Scenario | Jarvislabs | Replicate | 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 your own GPU or CPU machine with root and SSH, billed by the minute, or machines in India.
- Your own GPU machine, by the minute. Useful when you want root and SSH on a GPU VM, from L4 to H200, billed per minute.
- Plain VMs that keep their disk. Useful for a dev box or CI runner: Jarvislabs CPU VMs give root, Docker and a disk that survives a pause.
- Network rules and India regions. Useful for teams in India, or who need security groups, VPCs and reserved IPs set by the provider.
Use Replicate when
you want to call or serve an AI model through an API, from its catalog or packaged with Cog, on GPUs that scale to zero.
- Thousands of models, one API call away. Useful when you want to call an image, video, speech or text model without hosting it yourself.
- Per-second GPUs that scale to zero. Useful for spiky inference: deployments scale with traffic, down to zero, and bill per second.
- Cog runs anywhere. Useful if you may leave: Cog is open source and builds standard Docker images you can run on your own servers.
Where bochka fits
Jarvislabs and Replicate are both built to train and serve AI models on GPUs. If what you are really running is agents that need a machine of their own, bochka is built for that, and an agent in bochka can still call a model hosted on either. bochka has no GPUs, so model training stays on a GPU cloud.
Work that survives a stop
Replicate has no persistent disk, so an agent's files are gone when the instance scales down. A paused Jarvislabs VM keeps its disk but still bills at least 100 GB, with no snapshot or fork. bochka saves the disk every minute, stops for free and forks while running.
Agents and a desktop already inside
Neither has a desktop or computer use. A Jarvislabs CPU VM is a clean Linux machine you set up yourself, and Replicate has no agent harness at all. bochka ships coding agents you drive from outside and a 60fps desktop with Chromium.
Keys and ports handled for you
On Jarvislabs your keys sit on the machine and every port is open until you add a security group; on Replicate secrets go into the model as inputs. bochka keeps keys in a credentials proxy and serves HTTPS on 50 token-protected ports.
Use bochka when you run agents: full VMs with coding agents, a desktop, HTTPS ports and a credentials proxy, whose disk is saved every minute and which cost nothing while stopped. Compare it one to one: bochka vs Jarvislabs and bochka vs Replicate.
Questions people ask
Is Jarvislabs cheaper than Replicate?
In every scenario on this page, yes. One agent running all month is $71 on Jarvislabs against $237 a month on Replicate, and 50 agents in parallel are $892 against $2,851, though Replicate does not fit those because it has no persistent disk. GPU eval jobs come to $876 a month on Jarvislabs and $1,338 a month on Replicate.
Which is faster, Jarvislabs or Replicate?
There is no comparable CPU measurement for either, so we cannot say. bochka did 26.69 runs per second on the StarSling CPU test at 4 vCPU / 8 GB. For GPU speed, compare the GPU models each one rents.
Can Jarvislabs or Replicate run Docker?
On a Jarvislabs VM you have root, so you can run your own Docker daemon. On Replicate your model is the Docker container, and running Docker inside it is not documented. A bochka sandbox runs Docker, systemd and /dev/kvm like a normal Ubuntu server.
Which has better GPUs?
Both go up to the Nvidia H200 with up to 8 GPUs per instance. Jarvislabs rents H200 on demand by the minute, while Replicate bills per second but needs a committed spend contract for H200 and most multi-GPU setups. bochka has no GPUs.
How long can a job run?
A Replicate prediction times out after 30 minutes unless support raises it. Jarvislabs documents no cap: instances run until you pause them or the balance hits zero. A bochka sandbox has no session cap on paid plans.
Where do they run?
Jarvislabs creates new instances only in India. Replicate lists its infrastructure subprocessors in the United States and documents no region choice. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview