Depot vs RunsOn
Depot and RunsOn both replace GitHub-hosted runners with a one-line runs-on change, and both give each job a fresh machine. Depot runs those machines for you, with macOS runners and fast Docker builds, while RunsOn installs in your own AWS account, where AWS bills the compute at cost and you pay RunsOn a yearly licence.
The companies and products
Depot
Depot is a build and CI platform: faster Docker builds, drop-in GitHub Actions runners, its own Depot CI, and newer sandboxes for coding agents.
Depot's main product is GitHub Actions runners: you change one runs-on label and each job runs on a fresh AWS EC2 instance that is thrown away when the job ends, with Linux, Arm, Windows and macOS sizes and a shared fast cache. It also sells remote agent sandboxes that run Claude Code in a container, and a Sandbox SDK in public beta whose sandboxes live at most 24 hours. It is built for engineering teams that want CI and builds to finish sooner, so it is a different kind of product than an agent sandbox, and this page compares where the two overlap.
RunsOn
RunsOn is self-hosted GitHub Actions runners on AWS: one CloudFormation or Terraform stack in your account, a yearly licence, and compute billed by AWS at cost.
You install RunsOn in your own AWS account, change the runs-on: label in your workflows, and every job then starts on a new EC2 instance that is terminated when the job ends. It covers Linux on x64 and arm64, Windows Server and GPU instances, with caches in S3 and sticky EBS disks. It is a CI runner, a different kind of product from bochka, so this page compares the part where they overlap: a machine where an agent or a job does its work.
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. “125th cheapest of 377” means 124 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 | Depot: price rank | RunsOn: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month An agent that builds an app over days loses its machine after each job on both; RunsOn keeps only the sticky disk, Depot keeps nothing, and bochka keeps the whole disk. | 331st of 367, with limits $8,688 a month | 122nd of 367, with limits $1,114 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that never stops has to be restarted on both: Depot's Sandbox SDK caps a sandbox at 24 hours and GitHub ends RunsOn jobs after 5 days. | 86th of 366, with limits $13,148 a month | 188th of 366, with limits $1,724 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 RunsOn costs less than Depot for short bursts because AWS bills spot minutes at cost, though each burst still has to arrive as a GitHub Actions job. | 311th of 345, with limits $1,188 a month | 229th of 345, with limits $147 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 Both start machines for your own GitHub workflows, not for your users, and neither documents HTTPS URLs into a machine; bochka serves up to 50 ports per sandbox. | 318th of 361, with limits $3,713 a month | 216th of 361, with limits $585 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 | 311th of 360, with limits $17,908 a month | 245th of 360, with limits $2,714 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 | 319th of 364, with limits $2,888 a month | 251st of 364, with limits $389 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 are built for this: Depot gives a managed fast cache and Docker builds, RunsOn gives EC2 machines in your own account with S3 caches and sticky disks, and bochka gives a full VM you register as your own runner. | 125th cheapest of 377 $1,736 a month | 58th cheapest of 377 $432 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Runners on both are made to start, run one job and disappear, so a dev box that keeps its state all month fits bochka better. | 199th of 368, with limits $534 a month | 158th of 368, with limits $86 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 product, so a computer-use agent needs your own desktop setup; bochka streams a 60fps Linux desktop with Chromium. | 321st of 369, with limits $2,600 a month | 142nd of 369, with limits $353 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 | 139th of 367, with limits $1,304 a month | 206th of 367, with limits $224 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 | 139th of 346, with limits $1,763 a month | 228th of 346, with limits $205 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 | 312th of 338, with limits $35,108 a month | 122nd of 338, with limits $3,539 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 | 81st of 360, with limits $863 a month | 178th of 360, with limits $157 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 | Can't run it | Can't run it | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month Only Depot fits: it rents macOS 26, 15 and 14 runners, while RunsOn does not support macOS and bochka runs Linux only. | 10th of 36, with limits $248 a month | Can't run it | Can't run it |
Key features
| Feature | Depot | RunsOn | bochka |
|---|---|---|---|
| What it is | Managed GitHub Actions runners, Depot CI and fast Docker builds, plus Claude Code sandboxes and a beta Sandbox SDK | Self-hosted GitHub Actions runners, deployed as one stack in your own AWS account | A sandbox API for agents: full VMs you create, stop, fork and delete from code |
| Who runs the machines | Depot runs them on AWS EC2 for you | You do: EC2 instances in your AWS account, billed by AWS | bochka runs them on dedicated AMD Ryzen 9 9950X hosts |
| How a machine starts | When a GitHub Actions job asks for it with a runs-on label | When a GitHub Actions job asks for it with a runs-on: label | Any time, by API, CLI or SDK |
| How long a machine lives | One job; Sandbox SDK default 120 minutes, at most 24 hours | One job; GitHub ends self-hosted jobs after 5 days | No session cap on paid plans; runs until you stop it |
| Files after a job | Runners are never reused; a shared cache carries build data | Root disk is thrown away; one sticky EBS disk per job is snapshotted and restored | Whole disk saved every minute and on stop; a stopped sandbox costs nothing |
| Fork | No fork or clone API | No; every job starts from an AMI | Fork a running sandbox with its disk |
| Docker and nested virtualization | Docker on Linux runners; /dev/kvm only on Depot CI sandboxes, not on GitHub Actions runners | Docker and root; KVM on compatible Intel x64 families, not arm64 | Docker, root, systemd and /dev/kvm on every machine |
| Operating systems | Linux x64 and Arm, Windows Server 2025 and 2022, macOS 26, 15 and 14 | Linux x64 and arm64, Windows Server 2022 and 2025; no macOS | Linux only; Wine for Windows apps |
| Sizes and GPUs | Linux 2 to 64 CPUs; macOS at 8 CPU / 24 GB; GPU runners on the Business plan | Any EC2 size up to 96 vCPU, with NVIDIA or AMD GPUs from T4 up to H200 | Linux x64 up to 16 vCPU / 32 GB on the $100 plan and above; CPU only |
| Caching and builds | Shared cache up to 1000 MiB/s, plus fast Docker image builds | S3 caches, sticky disks and warm pools | A VM you set up yourself; no managed CI cache |
| Reaching the machine | SSH into a running Depot CI job for debugging; no documented inbound ports or URLs | SSH from a CIDR range you allow, and SSM; no HTTPS URLs | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Outbound network rules | Egress filtering on Linux runners by IP, CIDR or hostname | Your own AWS Network Firewall or security groups; static egress IPs through NAT | Open internet on every plan; no provider-side allowlist |
| Coding agents and keys | Claude Code only, started with the depot claude command; secrets as environment variables | Bedrock through the instance role; Copilot's coding agent can use a runner | Claude Code, Codex, OpenCode and more preinstalled with a prompt, steer and events API; credentials proxy keeps real keys out |
| Where it runs | United States, or the European Union if a project chooses it | In your own AWS account, in the region you pick | EU only: Germany, Finland and France |
Every feature Battleships tracks (43)
| Feature | Depot | RunsOn | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | Yes | 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 | No | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | Yes | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | No | No | No |
| GPU | Yes | Yes | No |
| Windows | Yes | Yes | No |
| Arm64 | Yes | Yes | No |
| Self-hosting | No | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | No | No |
| HIPAA | Not published | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement. Neither Depot nor RunsOn was in the StarSling hpc-sandbox-benchmarks run where bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. RunsOn's speed depends on the EC2 family you pick, so we do not compare CPU speed here.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Depot and RunsOn 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 | Depot, a month | RunsOn, 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 | $122 · Developer · with limits | $61 · Starter · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $534 · Developer · with limits | $159 · Starter · 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 | $5,710 · Developer · with limits | $1,597 · Starter · 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,628 · Developer · with limits | $515 · Starter · 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 | $3,588 · Developer · with limits | $1,103 · Starter · with limits | $2,000 · $2000/mo · with limits |
Depot: Depot plans cost $20 or $200 a month and include GitHub Actions, Depot CI and Docker build minutes; after that a 2-CPU Linux runner costs $0.006 a minute and bigger sizes multiply it. We priced the scenarios on its 4-CPU / 16 GB Linux runner.
RunsOn: AWS bills the EC2 instances and EBS disks on your own AWS bill, to the second, with no markup; S3 cache traffic and data transfer are extra. RunsOn charges one licence a year per company, from EUR 300 or $350, and the prices here use spot rates in us-east-1.
RunsOn: 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
None of the five scenarios is a clean fit for Depot or RunsOn, because both start a machine for one GitHub Actions job and throw it away after. An agent that never stops needs restarts on both: after 24 hours on Depot's Sandbox SDK and after 5 days on RunsOn, where GitHub ends self-hosted jobs. Depot says it has no concurrency limits, while RunsOn's limits are your AWS account's quotas and its default pace of about 2 EC2 calls per second. On bochka, the 1,000 short jobs burst is the hard one: starts are capped per minute, per hour and per day, so the jobs queue.
| Scenario | Depot | RunsOn | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| 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 Depot when
you want faster GitHub Actions and Docker builds with nothing to run yourself, or need macOS runners.
- macOS and Windows runners. Useful if you build or test for Apple: Depot rents macOS 26, 15 and 14 runners, which RunsOn does not offer.
- Nothing to run yourself. Useful if you want no AWS account to manage: Depot runs the machines and says its runners have no concurrency limits.
- Fast Docker builds and cache. Useful if Docker image builds are your slow step: Depot speeds them up and shares a cache up to 1000 MiB/s.
Use RunsOn when
you want GitHub Actions runners in your own AWS account, with compute at AWS cost and any EC2 size, arm64 or GPU.
- Compute at AWS cost. Useful if CI spend matters: AWS bills spot or on-demand minutes with no markup, plus one flat RunsOn licence a year.
- Your own AWS account. Useful when code, secrets and logs must never leave your AWS account, or must run in a region you choose.
- Any EC2 size and GPUs. Useful for jobs that need up to 96 vCPU, native arm64 or NVIDIA GPUs from T4 up to H200.
Where bochka fits
Depot and RunsOn are CI runner services, and bochka is not one. If what you are really running is agents, not CI jobs, both make you wrap the agent in a GitHub Actions job that ends and takes its machine with it. bochka gives each agent a full VM you start from code, keep as long as the work needs, fork and reach over HTTPS.
A machine that stays
Depot runners are thrown away after each job and RunsOn keeps only one sticky disk, so an agent reinstalls its tools every run. A bochka sandbox has no session cap on paid plans and saves its whole disk every minute and on stop.
Apps your agents can serve
Neither Depot nor RunsOn documents HTTPS URLs into a runner, so showing an agent's web app means your own tunnel on a machine that disappears. bochka serves up to 50 ports per sandbox over HTTPS, plus raw TCP.
Agents you drive from outside
Depot starts only Claude Code and passes secrets in as environment variables; RunsOn leaves agents to your workflow steps. bochka preinstalls Claude Code, Codex and more with a prompt, steer and events API, and keeps real keys in a credentials proxy.
Use bochka when you need machines for agents rather than CI jobs: a full VM you start by API, keep with its whole disk, fork, reach over HTTPS and drive with built-in coding agents. Compare it one to one: bochka vs Depot and bochka vs RunsOn.
Questions people ask
Is Depot cheaper than RunsOn?
In our scenarios, RunsOn comes out lower because AWS bills spot minutes at cost: one coding agent on workdays is $61 a month on RunsOn against $122 on Depot. For our CI runners use case it is $432 a month on RunsOn and $1,736 on Depot, and $86 a month on bochka. RunsOn's total also needs the yearly licence and your own AWS account.
Which is faster, Depot or RunsOn?
We have no comparable measurement for either: neither was in the benchmark run where bochka did 26.69 runs per second at 4 vCPU / 8 GB. Depot adds a shared cache up to 1000 MiB/s and fast Docker builds, while RunsOn's speed depends on the EC2 family you choose.
Does RunsOn support macOS like Depot?
No. RunsOn covers Linux x64 and arm64, Windows Server and GPU instances, but not macOS. Depot rents macOS 26, 15 and 14 runners at 8 CPU / 24 GB, and bochka runs Linux only.
Can Depot or RunsOn run Docker and nested VMs?
Both run Docker on Linux runners. Depot offers /dev/kvm only on Depot CI sandboxes, not on its GitHub Actions runners, and RunsOn supports KVM on compatible Intel x64 families but not arm64. bochka has Docker, systemd and /dev/kvm on every machine.
Can I use Depot or RunsOn as a sandbox for AI agents?
Only partly. Depot sells Claude Code sandboxes and a beta Sandbox SDK whose sandboxes end after at most 24 hours, and RunsOn can host Copilot's coding agent inside a GitHub Actions job for up to 5 days. Neither lets you keep, fork or serve ports from a machine the way bochka does.
Where does my data run?
Depot runs in the United States, or the European Union if a project chooses it. RunsOn runs in your own AWS account and region, and your code, secrets and logs are never sent to RunsOn. bochka runs only in the EU (Germany, Finland and France), with EU data residency.
Try bochka
Install the CLI, then run bochka new.
Product preview