Kay

Posted on Nov 15 Originally published at latchkey.dev

Latchkey vs GitHub hosted runners, and where each one wins

#githubactions #devops #cicd #cloud

Latchkey vs GitHub hosted runners comes down to a number you can compute from two published rate cards: $0.0025 a minute against $0.006 is 58% cheaper per 2 vCPU Linux minute, but Latchkey charges a monthly plan fee and GitHub gives you a monthly dollar allowance, so the break-even sits near 7,700 Linux minutes a month. Below that, staying put is cheaper, and on a public repository nothing paid can compete at all.

A GitHub Team plan with $18 of included usage (3,000 Linux minutes at $0.006) against the $19 Latchkey Launch plan with 4,000 included minutes, at published rates read 20 September 2026 and GitHub's allowance read 12 November 2026. The lines cross at 7,714 Linux minutes a month.

GitHub-hosted runners are the default and the safe answer: nothing to install, an included monthly allowance, every platform GitHub sells, and larger runners up to 96 vCPU. The standard Linux runner on a private repository is 2 vCPU with 8 GB of RAM and 14 GB of disk; on a public repository the same label gives 4 vCPU and 16 GB, free and unlimited.

Latchkey sells managed runners you adopt with a runs-on change, at $0.0025 a minute for 2 vCPU and 8 GB with 100 GB of disk, rising to $0.02 at 16 vCPU. Its argument is the rate plus what happens when a job fails for a mechanical reason: the runner diagnoses the failure and retries inside the run rather than handing it back to you. Its limits are equally plain, and they are listed below rather than buried.

Every cell below was read from the vendor's own public pricing or documentation page on 20 September 2026. Where a vendor does not publish a number, the cell says "not published" instead of carrying a guess.

Comparison

	GitHub-hosted	Latchkey
Price per minute, 2 vCPU Linux x64	$0.006 (2 vCPU, 8 GB RAM, 14 GB SSD on a private repo; free on public repos)	$0.0025 (2 vCPU, 8 GB RAM, 100 GB disk)
Price per minute, 4 vCPU Linux x64	$0.012 as a larger runner; the free public-repo standard runner is already 4 vCPU and 16 GB	$0.005 (4 vCPU, 16 GB RAM, 100 GB disk)
Free tier	$12 of compute a month on Free, $18 on Pro and Team, $300 on Enterprise Cloud (2,000, 3,000 and 50,000 standard Linux minutes), private repos only, deducted at each runner's own rate; larger runners can draw from it on Team and Enterprise Cloud and are billed on public repos	30-day trial, then 2,000 included minutes a month on Developer, 4,000 on Launch, 6,000 on Scale
Billing granularity	Every job is rounded up to the nearest whole minute	Per minute
Runner sizes and OS	Linux x64 and arm64, Windows x64 and arm64, macOS on Apple silicon and Intel; larger runners to 96 vCPU x64 and 64 vCPU arm64	2, 4, 8 and 16 vCPU, Ubuntu 24.04 on x86_64 only. arm64, Windows and macOS are not offered
Cache: type, limit, persistence	`actions/cache`, 10 GB per repository, entries removed after 7 days without access, restorable only from the same or the default branch	Size not published. `latchkey-dev/cache-action@v1` replaces `actions/cache` with a restore step and a save step, keeping `path` and `key` (no `restore-keys`); entries are isolated per organization, versioned by OS, kept 14 days; a failed restore warns rather than failing the job
Docker build acceleration	None built in. `cache-to: type=gha` writes into the same 10 GB store	`latchkey-dev/docker-cache-action@v1`, layers held in a Latchkey-managed private registry per organization
Concurrency limits	20 concurrent jobs on Free, 40 on Pro, 60 on Team, 500 on Enterprise Cloud. macOS is capped separately at 5, or 50 on Enterprise	Developer 20, Launch 40, Scale 80 busy runners per workspace; idle warm runners do not count
Where jobs run	GitHub's own hosted fleet	Latchkey's own AWS estate on m6a-class hosts, one job per runner, no inbound access, destroyed after the job
Self-healing or retries	None. A failed job waits for a person, or for retry logic you wrote yourself	Built in: transient failures are diagnosed and retried inside the run
Setup change required	None; this is the default	A `runs-on` label change. GitHub organization accounts only

Where GitHub-hosted wins

This is the section that decides the page, so it goes first. Four of these are structural, not a matter of taste, and on any one of them the comparison is over before the rate card matters.

Public repositories. Standard GitHub-hosted runners are free and unlimited there, on a 4 vCPU and 16 GB machine, which is a better runner than the 2 vCPU tier anyone sells and costs nothing at all.
Anything that is not Linux x86_64. Latchkey has no arm64, no Windows and no macOS runner. If your matrix builds an iOS app or a Windows binary, those jobs stay on GitHub-hosted and your bill has two vendors on it.
Low volume. GitHub includes $12 of compute a month on Free, $18 on Team and $300 on Enterprise Cloud, which is 2,000, 3,000 and 50,000 standard Linux minutes at $0.006, and Latchkey charges $5 to $49 a month before the first minute. Under a few thousand Linux minutes, the plan fee is larger than the saving.
Personal accounts. Latchkey works with GitHub organization accounts only, so a repository under a personal account cannot use it whatever the price.
Sizes above 16 vCPU. GitHub sells larger runners to 96 vCPU x64 and 64 vCPU arm64; Latchkey publishes four sizes and stops at 16.
Published concurrency. GitHub states 20 to 500 concurrent jobs by plan and 5 concurrent macOS jobs, 50 on Enterprise. Latchkey documents 20 busy runners per workspace by default, raised on request, in its runner limits read 2026-09-20, so a wide matrix queues sooner than it would on a Team plan. The same page caps a job at four hours.

The break-even, in one line of arithmetic

Both sides have a fixed part and a variable part, so a per-minute comparison on its own is misleading. On a GitHub Team plan, GitHub prices every Linux minute at $0.006 and subtracts the $18 of included usage, so you pay nothing for the first 3,000 minutes and $0.006 a minute after that. On the Latchkey Launch plan you pay $19 a month, get 4,000 included minutes, then pay $0.0025. Set the two equal and the crossover is 7,714 Linux minutes a month.

That is the number to check your own usage against, and it moves with the plan you would actually buy: on the $49 Scale plan, with 6,000 included minutes, the crossover is 14,857 minutes a month. Everything below assumes 2 vCPU Linux jobs on a private repository, which is the comparison most teams are actually making.

Linux minutes a month, 2 vCPU	GitHub-hosted on Team	Latchkey on Launch ($19)	Cheaper
2,000	$0, $12 inside the $18 included	$19, inside the 4,000 included	GitHub-hosted
5,000	$12: $30 less the $18 included	$21.50 for 1,000 billed minutes	GitHub-hosted
7,714	$28.28	$28.29	Level
10,000	$42: $60 less the $18 included	$34 for 6,000 billed minutes	Latchkey
20,000	$102	$59	Latchkey
50,000	$282	$134	Latchkey

Speed

Not benchmarked yet; the runner benchmark report will replace this section. We have not run the same workload on these runners ourselves, and until we have, there is no number here worth quoting.

The cheap way to get a real answer is to point one slow job at each candidate for a week, because runner selection is per job and the Actions run log gives you the timings for free.

Cost: the same month, both ways

The table above nets each side's included allowance off, because that is how a Linux-only bill actually arrives. The one below does not: it is the workload every comparison here uses, stated gross on both sides so the pages are comparable, at 10,000 Linux minutes at 2 vCPU plus 2,000 macOS minutes a month on a private repository.

	10,000 Linux minutes at 2 vCPU	2,000 macOS minutes	Monthly total
GitHub-hosted	$60 at $0.006/min	$124 at $0.062/min	$184
Latchkey	$25 at $0.0025/min	Not offered: $124 on GitHub-hosted	$149 plus $5 to $49 a month for the plan

Read that table with the macOS column in mind, because it is doing most of the work. Latchkey has no macOS runner, so those 2,000 minutes stay on GitHub-hosted at $0.062 a minute in both rows, and the entire difference between $184 and $149 comes from the Linux line. Latchkey's own plan is $5 to $49 a month on top of that compute, and its 2,000 to 6,000 included minutes are not netted off, so the figure is gross on both counts.

One more line that catches teams out, and it is GitHub's, not ours: the included allowance is a dollar amount, and each runner spends it at its own rate. A macOS minute is $0.062, so a Team plan's $18 is gone after about 290 macOS minutes, which is why so many Actions bills turn out to be mostly macOS. If that is your shape, macOS runner cost is a more useful page than this one, and no Linux rate will fix it.

Reliability

GitHub publishes a status history rather than an Actions SLA, and Latchkey publishes no uptime figure either, so treat both as unmeasured on that axis and do not let either of us claim otherwise. What is different is documented behavior on a bad job. On GitHub-hosted, a step that dies because a registry timed out, a browser binary did not install, or the kernel killed the process fails the job, bills the minutes it burned, and waits for a person; the re-run bills again.

Latchkey runners diagnose that class of failure and retry inside the run. It is worth being precise about what that does not cover: a compile error, a failing assertion or a genuine out-of-memory in your own code are not transient, and retrying them would be a bug rather than a feature. The way to size the difference is to count the runs in your own history that passed on the second attempt with no code change between them, which is the same measurement exit code 137 in GitHub Actions walks through for one specific failure.

Switching: the exact diff

One label per job, and nothing else in the workflow moves: steps, actions, secrets, matrix and artifacts are untouched, and reverting is the same edit backwards. Runner selection is per job, so the sensible trial is one job for a fortnight rather than a repository-wide decision, and a mixed file with macOS jobs still on GitHub-hosted is the normal end state rather than a compromise.

jobs:
   test:
-    runs-on: ubuntu-latest
+    runs-on: latchkey-small

   build:
-    runs-on: ubuntu-latest
+    runs-on: latchkey-medium

   ios:
     # stays on GitHub-hosted: Latchkey has no macOS runner
     runs-on: macos-latest

The verdict

If your CI is public, low volume, or built on anything other than Linux x86_64, GitHub-hosted is the right answer and this comparison is not close. The case for Latchkey starts at roughly 7,700 private-repo Linux minutes a month on a Team plan, where the 58% lower rate finally clears the plan fee, and it gets stronger from there: at 20,000 minutes it is $59 against $102, and at 50,000 it is $134 against $282. The second half of the case is the one the rate cards cannot show, which is what happens to the jobs that fail for reasons that have nothing to do with your code, and the honest way to price that is to count your own re-runs rather than to take our word for it. Whatever you decide, the decision is one line per job and reversible in a minute, which is the strongest argument for testing it on one job instead of arguing about it.

FAQ

Is Latchkey cheaper than GitHub-hosted runners?

Per minute, yes: $0.0025 against $0.006 at 2 vCPU is 58% lower, and $0.01 against $0.022 at 8 vCPU is 55% lower. Per month it depends on volume, because Latchkey charges $5 to $49 for a plan and GitHub includes $12 to $300 of compute a month (2,000 to 50,000 standard Linux minutes). Comparing a GitHub Team plan with the $19 Latchkey Launch plan, the two are level at about 7,714 Linux minutes a month and Latchkey is cheaper above that. On public repositories GitHub-hosted is free, so nothing paid wins there.

Do Latchkey minutes count against my GitHub included minutes?

No. A third-party managed runner registers with GitHub as a self-hosted runner, and GitHub's billing documentation states that Actions usage is free for self-hosted runners, so those jobs are not metered by GitHub at all. Your included allowance stays available for the jobs you leave on GitHub-hosted runners, which in practice is usually macOS and Windows.

Is there a limit on usage by public repos?

Standard GitHub-hosted runners are free and unlimited on public repositories, subject to GitHub's usage limits on job and workflow duration, and the free public-repo Linux runner is 4 vCPU with 16 GB rather than the 2 vCPU and 8 GB a private repository gets. Larger runners are billed even on public repositories. There is no cost case for a paid runner on a public repo, and we are not going to invent one.

What does Latchkey not offer?

No arm64, no Windows and no macOS runners: Ubuntu 24.04 on x86_64 only, in four sizes from 2 to 16 vCPU. No support for repositories under personal accounts, since it works with GitHub organizations only. A default ceiling of 20 busy runners per workspace, and no published uptime SLA. And a plan fee of $5 to $49 a month whose included minutes are separate from, not netted off, the per-minute compute.

DEV Community