Documentation menu
Dashboard & analytics
Managed runners
Team & notifications
Billing & plans
Workflow files
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.
In short
- Four sizes:
latchkey-small(2 vCPU, $0.0025/min) throughlatchkey-xlarge(16 vCPU, $0.0200/min), Ubuntu 24.04 x64. - One job per runner, destroyed afterward; a warm runner that is already online picks up in about two seconds.
- Every plan includes 2,000-6,000 free small-equivalent runner minutes per month.
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.
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#
| Label | vCPU | Memory | Disk | Price |
|---|---|---|---|---|
latchkey-small | 2 | 8 GB | 100 GB | $0.0025/min |
latchkey-medium | 4 | 16 GB | 100 GB | $0.0050/min |
latchkey-large | 8 | 32 GB | 100 GB | $0.0100/min |
latchkey-xlarge | 16 | 64 GB | 200 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.
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.
| Size | A good first fit for | Why |
|---|---|---|
latchkey-small | Lint, unit tests, scripts, small builds | Most CI jobs are I/O-bound or single-core-bound; 2 vCPU / 8 GB covers them at the lowest rate |
latchkey-medium | Typical app test suites, Docker image builds | Twice the CPU and memory of small, for parallel test runners and multi-stage image builds |
latchkey-large | Compile-heavy builds, parallel integration suites | 8 vCPU / 32 GB suits work that scales with cores: large TypeScript, Rust, Java, or C++ builds |
latchkey-xlarge | Monorepo builds, memory-hungry end-to-end suites | 16 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:
- Pickup in about two seconds when the runner is already online
- Every plan gets the same warm baseline today, and it covers
latchkey-smallonly
- 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.
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.