Jarvislabs vs Baseten
Jarvislabs rents you whole machines: GPU VMs, GPU containers and CPU VMs with root, billed by the minute, mostly in India. Baseten runs your models for you as containers that scale with traffic and down to zero, in the US and the EU, with agent sandboxes in private preview.
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.
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. “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 | Baseten: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent needs root, Docker and a kept disk: Jarvislabs VMs have the first and last, Baseten containers have neither, and bochka adds the agents themselves preinstalled. | 154th of 367, with limits $1,406 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 | 185th of 366, with limits $1,670 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 Both bill per minute with no plan fee, but a Jarvislabs VM takes about 90 seconds to boot and a Baseten replica pays for its cold start and, by default, 15 idle minutes. | 103rd of 345, with limits $169 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 Jarvislabs does not publish how many machines can run at once and Baseten's sandbox preview allows 10 per organization by default, so 300 sandboxes for your users means asking either one first. | 215th of 361, with limits $539 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 Jarvislabs CPU VMs bill by the minute with root, which suits RL rollouts better than Baseten's model containers that lose their files when they stop. | 43rd of 360, with limits $2,568 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 | 113th of 364, with limits $411 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 Jarvislabs gives root on a CPU VM, so a CI runner with Docker works there; Baseten's model containers run as a non-root user, and bochka gives root and Docker on every VM. | 20th cheapest of 377 $253 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 Jarvislabs CPU VM keeps its disk as a 24/7 dev box, while a Baseten replica starts fresh from its image; bochka keeps the disk and a stop costs nothing. | 52nd cheapest of 368 $68 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 has a desktop or computer-use API; bochka streams a 60fps desktop with Chromium and computer use from every sandbox. | 154th of 369, with limits $377 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 | 204th of 367, with limits $205 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 | 244th of 346, with limits $247 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 | 158th of 338, with limits $4,942 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 | 156th of 360, with limits $127 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 fit GPU eval jobs: Jarvislabs rents GPU VMs from L4 to H200 by the minute, Baseten runs jobs on GPUs from T4 to B200, and bochka has no GPUs. | 9th cheapest of 98 $876 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 | Jarvislabs | Baseten | bochka |
|---|---|---|---|
| Kind of product | GPU cloud: GPU VMs, GPU containers, CPU VMs, clusters and model serving | Inference cloud for serving and training models; agent sandboxes in private preview | Sandboxes for AI agents: VMs with agents, desktop and hosting ready |
| Isolation | GPU VMs and CPU VMs are KVM virtual machines; Templates are containers | Kubernetes containers in a dedicated namespace per customer; sandbox isolation is not documented | Every sandbox is a full VM with its own kernel |
| Root and Docker | Root on VMs, so you can run your own Docker daemon; nested virtualization is not documented | Containers run as the non-root app user; Docker inside 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 or reserved, plus clusters | Nvidia T4 up to B200, 1 to 8 per instance, multi-node over InfiniBand | None |
| CPU machines | CPU VMs from 2 to 32 vCPU with 4 GB of RAM per vCPU, in Noida only | CPU instances from 1 vCPU / 2 GiB to 16 vCPU / 64 GiB, shared, no region choice | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB on the $100 plan and up |
| Files after a stop | A paused VM keeps its whole disk, which keeps billing at $0.10/GB-month with at least 100 GB | Model replicas start fresh from the image; preview sandboxes are deleted with their files after 7 days by default | A stopped sandbox costs nothing and keeps its disk, snapshotted every minute and on stop |
| Snapshots and fork | No snapshot, clone or fork command | No fork or clone; new replicas cold-start from the image | Snapshots every minute and on stop; fork a running sandbox |
| Scale to zero and wake on request | Serverless model workers stop after an idle timeout and start on the next request | Deployments scale to zero and start on the next request; standby sandboxes resume on the next request | No wake on request; you start a stopped sandbox through the API |
| Desktop and computer use | No desktop; JupyterLab, VS Code in the browser and SSH | No desktop or computer-use API; sandboxes run commands and file operations | 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 | Baseten Switch routes Claude Code or Codex on your laptop to its Model APIs; an agent drives a sandbox through the CLI or MCP | 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 | HTTPS API endpoint per deployment; sandbox ports through a /port/ route on its API server | 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 | TCP ports 443 and 80 out by default; per-deployment IP and domain allowlists once enabled | 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 are passed into the model as arguments or files under /secrets | AI credentials proxy for model providers and any HTTPS API you register |
| Regions | India only for new instances (IN1, IN2) | US and EU for GPU deployments; self-hosted in your own cloud account on Enterprise | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Jarvislabs | Baseten | 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 | Yes | 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 | 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 | No | Yes | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | 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 | Yes | No | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | No | Yes | No |
| SOC 2 | No | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for either: Jarvislabs and Baseten were not part of the public StarSling benchmark run, and neither publishes a CPU benchmark for its CPU machines. 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.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Jarvislabs 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 | Jarvislabs, 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 | $21 · 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 | $71 · 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 | $892 · 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 | $231 · On-demand · with limits | $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 | $514 · On-demand · with limits | $6,228 · Basic · with limits | $2,000 · $2000/mo · with limits |
Jarvislabs: Jarvislabs bills per minute from a prepaid wallet with no plan fee and no free trial. CPU VMs cost $0.012 per vCPU-hour plus $0.0032 per GB of RAM, and disk is $0.10/GB-month while running and while paused, with at least 100 GB on a VM.
Baseten: Baseten bills per minute, 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 preview pricing 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 have no persistent disk, so in every scenario files are lost when a replica stops, and the table marks them as not fitting; its preview sandboxes run at most 10 per organization by default. Jarvislabs fits the single-agent and 50-agent scenarios, but does not publish how many machines can run at once, so 300 sandboxes for your users or 1,000 short jobs at once 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 | Jarvislabs | 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 |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Jarvislabs when
you want to rent whole GPU or CPU machines with root by the minute, keep their disk between sessions, or run in India.
- A whole machine with root. Useful if you want to log in and work: Jarvislabs rents KVM VMs with root, SSH and a disk that survives a pause.
- Big CPU VMs by the minute. Useful for heavy CPU work: Jarvislabs CPU VMs go up to 32 vCPU / 128 GB, billed per minute with no plan fee.
- Firewall rules and India regions. Useful for teams in India, or who want security groups, VPCs and reserved IPs set by the provider.
Use Baseten when
you serve or train models in production and want deployments that scale to zero, GPUs up to B200, or the US or your own cloud account.
- Model serving that scales to zero. Useful for spiky inference traffic: Baseten deployments scale to zero when idle and start again on the next request.
- GPUs up to B200, across nodes. Useful for large models: Baseten runs Nvidia GPUs from T4 to B200, up to 8 per instance and across nodes.
- US region or your own cloud. Useful if you must run in the US, or in your own AWS, GCP or OCI account on Enterprise.
Where bochka fits
Jarvislabs and Baseten are GPU clouds, and bochka has no GPUs, so keep model training and serving on one of them. If what you are really running is agents that write code, use a browser or host previews, bochka gives each one a full VM built for that. Many teams split it: models on a GPU cloud, agents on bochka.
A disk that stays, with free stops and fork
A paused Jarvislabs VM keeps billing for at least 100 GB of disk, and a Baseten replica loses its files when it stops. Neither can copy a running machine, so every new agent is set up again by hand.
Agents and a desktop already inside
Jarvislabs and Baseten give an agent on your laptop tools to manage machines or call models, not a machine with the agent in it. On both you install the agent, a browser and any desktop stream yourself.
HTTPS ports and keys kept off the machine
A Jarvislabs VM opens every port until you add a security group, and Baseten reaches sandbox ports through its API server. On both, real API keys sit on the machine, where an agent can leak them in a log.
Use bochka when you run agents: full VMs with root and Docker, coding agents and a 60fps desktop inside, HTTPS on 50 ports, a credentials proxy, snapshots every minute, live fork and free stops, in the EU. Compare it one to one: bochka vs Jarvislabs and bochka vs Baseten.
Questions people ask
Is Jarvislabs cheaper than Baseten?
In every CPU scenario we priced, yes. One coding agent on workdays is $21 a month on Jarvislabs and $34 on Baseten, one agent running all month is $71 versus $136, and 50 agents in parallel are $892 versus $1,701. On bochka those are $20, $26 and $317.
Which is faster, Jarvislabs or Baseten?
Neither has a comparable CPU measurement: both were left out of the public StarSling benchmark run, and neither publishes a CPU benchmark. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that run.
Can Jarvislabs or Baseten run Docker?
On Jarvislabs VMs you have root, so you can run your own Docker daemon. Baseten does not document Docker inside its containers, which run as the non-root app user, though it can run your own Docker image as a model server. Every bochka sandbox has root and Docker.
Do Jarvislabs and Baseten keep files when a machine stops?
A paused Jarvislabs VM keeps its whole disk and keeps paying for it, while its GPU containers keep only /home. Baseten replicas start fresh from the image, and its preview sandboxes are deleted after 7 days by default. A stopped bochka sandbox keeps its disk and costs nothing.
Where do Jarvislabs and Baseten run?
Jarvislabs creates new instances only in India, and its old EU1 region no longer accepts new ones. Baseten runs GPU deployments in the US or the EU, and Enterprise customers can self-host in their own cloud. bochka runs only in the EU: Germany, Finland and France.
Does bochka have GPUs?
No. bochka runs Linux VMs on dedicated AMD Ryzen 9 9950X hosts and has no GPUs. Train or serve models on Jarvislabs or Baseten, and let your agents work on bochka.
Try bochka
Install the CLI, then run bochka new.
Product preview