Paperspace vs Replicate
Paperspace rents whole Linux machines with GPUs by the hour, and you work inside them over SSH. Replicate runs AI models as containers behind an API, on GPUs that scale up with requests and down to zero.
The companies and products
Paperspace
Paperspace is a GPU cloud for machine learning, owned by DigitalOcean since 2023.
Paperspace Machines are full Linux VMs with a persistent disk, a public IP and optional Nvidia GPUs from M4000 up to H100, billed by the hour. Next to Machines it sells Gradient Notebooks, Deployments and Workflows for training and serving models. It is built for people who train, test and run models, not as a sandbox API: its API manages machines, and you work inside them over SSH.
- Operating systems
- Linux; Windows templates closed to new users since 1 July 2024
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. “58th cheapest of 364” means 57 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 | Paperspace: 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 Paperspace gives a coding agent a real VM with Docker but no API to run commands inside it, and Replicate has no shell or lasting disk at all; bochka is built for this. | 141st of 367, with limits $1,261 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 An assistant that lives on one machine all month keeps its disk on Paperspace and bochka, while a Replicate instance starts fresh from its image and each prediction stops at 30 minutes. | 179th of 366, with limits $1,560 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 Replicate, which bills per second and scales to zero, better than Paperspace, which bills each machine by the hour. | 179th of 345, with limits $1,451 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 Neither was made to hand sandboxes to your users: Paperspace needs your own SSH layer and Replicate gives only a model endpoint, while bochka gives each user a full VM. | 124th of 361, with limits $1,243 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 | 193rd of 360, with limits $30,570 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 | 58th cheapest of 364 $1,241 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 Paperspace VM can host a CI runner with Docker, while Replicate does not document Docker inside; bochka starts runners per job with Docker and /dev/kvm. | 101st cheapest of 377 $1,026 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 Paperspace fits a dev box that never stops, with SSH and a disk that is kept; Replicate has no SSH and no persistent disk. | 49th cheapest of 368 $63 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 Linux desktop for computer use: Paperspace streams a desktop only on Windows machines new users cannot create, and Replicate has none; bochka streams one at 60fps. | 284th of 369, with limits $1,655 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 | 319th of 367, with limits $1,241 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 | 192nd of 346, with limits $112 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 | 92nd of 338, with limits $2,242 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 | 207th of 360, with limits $214 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: Replicate ranks 22nd and Paperspace ranks 30th of 98, and bochka has no GPUs. | 30th cheapest of 98 $2,982 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 | Paperspace | Replicate | bochka |
|---|---|---|---|
| Kind of product | GPU and CPU VM cloud for machine learning; each machine is a full VM with its own kernel | Model inference API; each model runs as a Cog container, and the isolation layer is not named | Sandbox cloud for agents: full VMs with their own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Shell and network access | SSH and a public IPv4 on every Linux machine, any port; no managed HTTPS URLs | No SSH; one prediction API per model behind API token auth, no own IP or ports | SSH, root and systemd; HTTPS URLs for up to 50 ports, raw TCP, dedicated IPv4 or IPv6 |
| Docker and nested virtualization | Docker runs inside; 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 |
| Working inside from code | The API and CLI manage machines but cannot connect to them; you use SSH | You call the model through the HTTP API or client libraries; no commands or files | API, SDK and CLI to run commands, move files and fork |
| Files after a stop | Disk is kept and billed while off; auto-snapshots at most hourly, up to 10 kept | No persistent disk; instances start fresh, and API inputs and outputs are deleted after an hour by default | Whole disk saved every minute and on stop; a stopped sandbox costs nothing |
| Copying a machine | Custom templates; the machine must be turned off first, same region only | No snapshots or fork; you add replicas of the same image | Fork a running sandbox with its disk in one call |
| Run time | Auto-shutdown from one hour to one week, and you can remove it | 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 |
| Scale to zero and wake | Machines can shut down when idle; you start them again yourself | Deployments scale to zero and start again on the next prediction | No; a stopped sandbox is started by API |
| Billing step | Per hour while on; disk and public IP keep billing when off | Per second by hardware, from prepaid credit | Per second while running; a stopped sandbox costs nothing |
| GPUs | Nvidia M4000 up to H100, up to 8 per machine; H100 needs approval | T4, L40S, A100 80GB, H100 and H200, up to 8 per instance; H200 and most multi-GPU need a committed spend contract | None, CPU only |
| Ready-made models | ML templates such as ML-in-a-Box, plus Gradient Notebooks and Deployments | Thousands of public and official models for images, video, speech and text, plus fine-tuning | None; your agent calls the model APIs you choose |
| Desktop and computer use | Desktop streaming only on Windows machines, which new users cannot create | No desktop or browser product | 60fps Linux desktop with Chromium, computer use and browser control |
| Keeping keys out of the machine | No credentials proxy; Gradient secrets are injected as environment variables | 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 |
| Regions | New York, Amsterdam and Canada | No region choice documented; infrastructure subprocessors listed in the United States | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Paperspace | Replicate | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | Not published | No | Yes |
| Root | Not published | 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 | No | Yes | No |
| HTTPS preview URLs | No | Yes | Yes |
| Raw TCP inbound | Not published | Not published | Yes |
| Public IPv4 | Yes | No | No |
| Egress allowlist | No | 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) | No | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | Yes | Not published | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Paperspace or Replicate: neither was part of the public StarSling hpc-sandbox-benchmarks CPU run, so we cannot say which is faster at CPU work. 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 Paperspace and Replicate are chosen mostly 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. Paperspace 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 | Paperspace, 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 | $19 · Core usage | $57 · Usage · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $63 · Core usage | $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 | $804 · Core usage | $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 | $1,241 · Core usage | $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 | $8,274 · Core usage | $3,580 · Usage | $2,000 · $2000/mo · with limits |
Paperspace: Paperspace bills each machine per hour while it is on, at a fixed rate per size (C5, 4 vCPU / 8 GB, is $0.08 an hour). The boot disk (from $5 a month for 50 GB) and the public IP keep billing until you delete the machine, even when it is off.
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, and failed or canceled runs.
Replicate: Plans start at $20 a month, and the whole fee is 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 stops after 30 minutes unless support raises it, and Replicate publishes no disk or egress price. Paperspace fits all five scenarios, but it bills by the hour, so a five-minute job costs a full hour; that is why 1,000 short jobs at once cost $8,274 a month there and $3,580 a month on Replicate. bochka queues that burst because of its start limits.
| Scenario | Paperspace | 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 |
| 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 Paperspace when
you want GPU or large CPU machines that a person sets up and uses over SSH, with a disk that stays, in the US, Canada or Amsterdam.
- A whole machine you log into. For a person who wants a lasting GPU box: every Paperspace machine is a full Linux VM with SSH, a kept disk and a public IPv4.
- Big CPU machines. For heavy single jobs: Paperspace CPU machines go up to 32 vCPU and 244 GB of memory.
- Machines in Amsterdam and Canada. For teams that need a region: Paperspace runs in New York, Amsterdam and Canada, while Replicate documents no region choice.
Use Replicate when
you want to call or serve an AI model on GPUs as an API, from its catalog or packaged with Cog, that scales with traffic and down to zero.
- Thousands of models, one call away. For teams that want an image, video, speech or text model without hosting it: one API request runs it.
- Scale to zero, billed per second. For traffic that comes and goes: deployments scale down to zero and wake on the next prediction, billed per second.
- Newer GPUs, and Cog runs anywhere. For serving models: Replicate offers L40S, H100 and H200, and Cog images also run on your own servers.
Where bochka fits
Paperspace and Replicate are GPU clouds, and bochka has no GPUs, so model training and serving belong on them. If what you are really running is agents that need a machine of their own, bochka gives each one a full VM that code can create, fork and drive. Your agent in bochka can still call Replicate or use a Paperspace GPU when it needs one.
A machine code can drive
Paperspace's API cannot run commands inside a machine, so you build and keep an SSH layer. Replicate has no shell at all, and each prediction stops at 30 minutes. bochka runs commands, moves files and drives coding agents by API.
Work that is never lost
Paperspace auto-snapshots at most hourly, so a broken machine can lose an hour of work, and its disk bills while off. Replicate has no persistent disk, so files are gone when an instance scales down. bochka saves every minute and forks running sandboxes.
Docker, /dev/kvm and a desktop
Neither documents /dev/kvm, Replicate does not document Docker inside, and Paperspace streams a desktop only on Windows machines new users cannot create. Every bochka sandbox has Docker, /dev/kvm and a 60fps desktop with Chromium.
Use bochka when you run agents that each need a machine of their own: a shell, root, Docker, /dev/kvm and a desktop, driven from code, with a disk saved every minute. Compare it one to one: bochka vs Paperspace and bochka vs Replicate.
Questions people ask
Is Paperspace cheaper than Replicate?
In four of the five scenarios on this page, yes: one agent that never stops is $63 against $237 a month, though Replicate does not fit that job at all. For 1,000 short jobs at once, Replicate is cheaper at $3,580 against $8,274 a month, because Paperspace bills by the hour. For GPU eval jobs, Replicate comes to $1,338 against $2,982 a month.
Which is faster, Paperspace or Replicate?
There is no comparable CPU measurement for either one, so we cannot say. bochka did 26.69 runs per second on the StarSling CPU test at 4 vCPU / 8 GB.
Can I run Docker on Paperspace or Replicate?
Docker runs inside a Paperspace machine, though nested virtualization is not documented. On Replicate, Cog builds your model into a Docker image, but 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?
Paperspace rents Nvidia cards from the M4000 up to H100, and H100 needs approval. Replicate offers T4, L40S, A100 80GB, H100 and H200, and H200 and most multi-GPU setups need a committed spend contract. bochka has no GPUs.
Can I run an AI agent on Paperspace or Replicate?
On Paperspace you can run one on a VM you reach over SSH, but there is no API to work inside it, no fork and no Linux desktop. Replicate runs models, not agents: there is no shell, no lasting disk, and each prediction stops at 30 minutes. bochka is built for agents, and they can still call Replicate's API.
Where do Paperspace and Replicate run?
Paperspace runs machines in New York, Amsterdam and Canada. Replicate documents no region choice and lists its infrastructure subprocessors in the United States. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview