Skip to content
Latchkey home
Documentation menu

Managed runners overview

What Latchkey runners are, the four sizes and their prices, what makes them different from GitHub-hosted runners, and what you need before your first job.

per minute
$0.0025
starting price (small)
warm pickup
~2s
when a warm runner is already online
job per runner
1
destroyed afterward
cheaper
58%
on small, per runner minute vs GitHub-hosted
free minutes
2,000+
small-equivalent, monthly on every plan

In short

  1. Four sizes: latchkey-small (2 vCPU, $0.0025/min) through latchkey-xlarge (16 vCPU, $0.0200/min), Ubuntu 24.04 x64.
  2. One job per runner, destroyed afterward; a warm runner that is already online picks up in about two seconds.
  3. Every plan includes 2,000-6,000 free small-equivalent runner minutes per month.
app.latchkey.dev / acme / runners

The Runners page, Fleet now. Runners at once reads 2 of 40 in use, with Warm 1, noted as counting every warm runner including one still running a job, Parked 1, Starting 0 and Held 0. Under it, Last hour, by minute draws a lane for each runner size from 13:55 to 14:54, your time, each minute a column of running, starting and held jobs, with the size's warm and parked runners beside it: small reads warm 1 · parked 1, and large and xlarge read No jobs in the last hour. A job finishes, and 1 of 40 is in use. Two test shards wait together: the warm runner takes the first, and the parked runner resumes for the second, so Parked drops to 0 and small reads warm 1 · parked 0. Then one more job waits with no warm or parked runner free, and a fresh machine cold-starts for it. At the end, 4 of 40 are in use, with Warm 1, Parked 0, Starting 1 and Held 0, and small's newest minute shows three jobs running and one starting.

FIG. 3.1-AEach new job takes the quickest runner free: the warm runner at once, then a parked one that resumes, then a fresh machine that cold-starts once neither is left. Only busy runners count toward Runners at once, and every runner serves exactly one job.

Latchkey managed runners are ephemeral virtual machines that run your GitHub Actions jobs. Each runner executes exactly one job and is destroyed afterward, so every job starts from a clean, isolated machine. Every runner also ships with self-healing built in.

Sizes and pricing#

LabelvCPUMemoryDiskPrice
latchkey-small28 GB100 GB$0.0025/min
latchkey-medium416 GB100 GB$0.0050/min
latchkey-large832 GB100 GB$0.0100/min
latchkey-xlarge1664 GB200 GB$0.0200/min

All runners are Ubuntu 24.04 LTS on x86_64 (AWS m6a-class hardware) with a comprehensive preinstalled toolchain. Billing is per minute, rounded up per job, and every plan includes free small-equivalent minutes each month (2,000 on Developer, 4,000 on Launch, 6,000 on Scale; that is 4,000 a month on the mid tier, vs 3,000 on GitHub); see Runner usage and free minutes.

Price per minute of a 2 vCPU Linux runner
latchkey-small$0.0025
GitHub-hosted$0.006

Which size should you pick?#

Treat what follows as guidance, not rules: your own job runtimes are the real benchmark. The pattern that serves most teams is to default everything to latchkey-small, then promote the specific jobs that prove they need more.

SizeA good first fit forWhy
latchkey-smallLint, unit tests, scripts, small buildsMost CI jobs are I/O-bound or single-core-bound; 2 vCPU / 8 GB covers them at the lowest rate
latchkey-mediumTypical app test suites, Docker image buildsTwice the CPU and memory of small, for parallel test runners and multi-stage image builds
latchkey-largeCompile-heavy builds, parallel integration suites8 vCPU / 32 GB suits work that scales with cores: large TypeScript, Rust, Java, or C++ builds
latchkey-xlargeMonorepo builds, memory-hungry end-to-end suites16 vCPU / 64 GB plus the 200 GB disk, for the heaviest jobs that would otherwise need splitting

Two properties of the lineup make right-sizing easy to reason about. Each step up doubles vCPU, memory, and the per-minute rate, so moving a job up a size pays off when it at least halves that job's duration: same cost or less, and faster feedback. And runs-on is chosen per job, not per workflow, so one heavy build job on latchkey-large never forces your lint job off latchkey-small.

Why teams switch#

  • Price: 52 to 58% less per runner minute than GitHub-hosted, with more free minutes than GitHub includes (4,000 vs 3,000 on the mid tier).
  • Speed: a warm runner that is already online picks up a job in about two seconds.
  • Self-healing: transient failures (registry timeouts, OOM kills, full disks, missing tools) are detected and fixed during the run.
  • Isolation: one job per runner, with no inbound access, destroyed after the job.
  • Zero infrastructure to manage: no runner images to build, no autoscaling to tune, no runner agents to patch.

Ephemeral by design#

Every runner is created for one job and destroyed the moment that job finishes. Nothing on the machine carries into the next job: no leftover processes, no stale caches, no files a previous job wrote to disk. A job starts from earlier work only when its workflow restores a cache entry or downloads an artifact. That clean-machine guarantee is what makes runs reproducible; if a job passes today and fails tomorrow, the difference is in your change or a dependency, not in state that accumulated on a long-lived machine.

The same property carries the security story. A runner registers just-in-time with single-use credentials, accepts no inbound connection, takes exactly one job, and is destroyed: there is no window for one job to observe another, and no long-lived machine to patch and harden. See Security and permissions for the full picture.

Plan around it, too: anything written to the runner's local disk is gone when the job ends. Persist build outputs as artifacts and speed up installs with caches, exactly as you would on GitHub-hosted runners.

Prerequisites#

  • The Latchkey GitHub App is installed on your organization.
  • The repository is monitored in Latchkey.
  • Managed runners are enabled for your workspace (they are set up automatically when the app is installed; the Runners page in the dashboard shows your readiness and configurations).
  • Your subscription or trial is active. Runner launches are blocked for expired trials and lapsed subscriptions; see Runner usage and free minutes.

How provisioning works#

When GitHub queues a job with a latchkey-* label, Latchkey either hands it to an already-warm runner or launches a fresh one:

Warm runner already online
  • Pickup in about two seconds when the runner is already online
  • Every plan gets the same warm baseline today, and it covers latchkey-small only
Fresh runner (cold start)
  • A new machine boots just for your job
  • Registers just-in-time with single-use credentials
  • Running once the fresh machine has registered
  • Any job past the warm baseline, or asking for a larger size, takes this path

Either way the runner is destroyed after your job. The full lifecycle, warm pools, concurrency, and why a job might wait, is in How provisioning works. Beyond the four presets you can create custom runner configurations with their own labels, and the Runners page in the dashboard is where you manage all of it.

A migration strategy that works#

You do not need a big-bang migration, and we suggest avoiding one. GitHub-hosted labels keep working side by side with latchkey-* labels, so you can move one job at a time and compare the two directly on your own workloads.

01
Pick one workflow
Start with a flaky or slow one, where the wins are most visible
02
Watch it for a week
Compare duration, cost, and heals on the Runs page
03
Then move in bulk
Use the Migrate Runners tool to switch the rest of the fleet

A flaky or slow workflow makes the best pilot because cheaper minutes, faster pickup, and self-healing all show up where the pain already is. After a week, the Cost page gives you the runner spend, the Runs page marks each healed run, and the Self-heal outcome report on AI Insight counts what self-heal fixed, all to judge with; when you are convinced, the Migrate Runners tool on the Runners page (owners and admins) opens ready-to-merge pull requests that switch up to 20 repositories at once; the full walkthrough is Migrate from GitHub-hosted runners. Jobs that need GPU, Windows, macOS, or arm64 hosts stay on GitHub-hosted or other runners, and mixing within a single workflow is fine.

Deciding between providers? The Learn library has an independent runner comparison hub covering GitHub-hosted, Blacksmith, BuildJet, and more, plus a GitHub Actions cost calculator to estimate spend on your own numbers before you switch anything.

Q.01What sizes do Latchkey runners come in?

Four, all Ubuntu 24.04 x64: latchkey-small at 2 vCPU and $0.0025 per minute, through latchkey-xlarge at 16 vCPU and $0.0200 per minute. Every plan includes 2,000 to 6,000 free runner minutes a month depending on the plan. Free runner minutes are counted in small-equivalent units: a minute on latchkey-small counts as one, medium as two, large as four, and xlarge or a custom runner as eight, and the included allowance on every plan is unchanged.

Q.02How fast does a Latchkey runner start?

A warm runner that is already online picks a job up in about two seconds. A cold start takes longer, because a fresh machine has to boot and register first. Either way the runner is a fresh machine: one job per runner, destroyed afterward.

Q.03How do Latchkey runners differ from GitHub-hosted runners?

Two ways that matter. The published rate is $0.0025 per minute for 2 vCPU against $0.006 for the GitHub-hosted equivalent, and a self-healing agent on the machine repairs transient failures such as registry timeouts and OOM kills during the run rather than failing the job.