This post started as a tweet. We wanted to post a photo of one of the old HP workstations in our Tallinn office with a line like "cut our $1,200 a month CI down to near zero on this box".
Before posting it we checked, and three parts of that line were wrong. We never paid a $1,200 bill, so nothing was cut. It isn't one box. And "near zero" leaves out everything that doesn't arrive as an invoice.
So we measured it properly. In the 30 days to 16 November 2026, our GitHub Actions CI ran at least 135,000 jobs and 3,543 runner hours. On GitHub's hosted runners that is at least $1,252 a month, or $1,732 the way GitHub actually bills. On Blacksmith it is at least $834. On our own machines it is $0 in new bills.
That is cost avoided, not money saved. The rest of this post is how we got the numbers, what they leave out, and what running it ourselves has cost in other ways. If you only want your own number, the script and an agent prompt are in section 7.
1. Count every job a runner held
Much of our CI traffic comes from AI agents, not people. In those 30 days the repository created 49,028 workflow runs and merged 1,520 pull requests. Several of the busiest workflows exist for the agents: the CI fix loop ran 6,733 times, CI failure triage 6,150 times and the merge batcher 4,306 times. The main CI workflow ran 4,352 times.
List every run, sample the jobs. GitHub's API lists every run cheaply. Listing the jobs of all 25,339 runs that started would have taken about 5 hours of an API rate limit other tools share, so we fetched the jobs of 3,525 runs and scaled up per workflow.
Count only time a runner held. Some jobs sat in a queue until a 24-hour timeout and never ran. Counting them would have added over 100,000 minutes that used no machine.
Quote the low end. The sample gives a 90% interval. The point estimate is 3,801 hours; every money figure in this post uses the low end, 3,543.

Measured, from a sample of runs scaled to all of them. The whiskers are the 90% interval. Full method in the measurement notes below.
What this does not tell you: how long the same jobs would take on someone else's machine. We measured job time on our hardware. A hosted 2-core runner could be faster or slower, and we didn't test it.
2. Price it the way the vendor bills
We priced each kind of job at the smallest hosted machine that fits its 90th-percentile CPU and memory. That is a 2-core runner for almost everything and 4 cores for Android builds.1 This undercounts our heaviest jobs on purpose, so the hosted figure stays low.
Then the rounding. GitHub rounds every job up to a whole minute.1 Most of our jobs are short, so the rule alone moves the bill:
- GitHub, exact seconds → GitHub, as billed: $1,252 → $1,732 a month.
- GitHub, as billed → Blacksmith, exact seconds: $1,732 → $834 a month.2
What the first pair means: if your jobs are short, the rounding rule matters as much as the per-minute price. What it doesn't mean: Blacksmith doesn't publish a rounding rule, so we priced it on exact seconds. If it rounds too, its figure goes up.

Estimate: our measured minutes multiplied by list prices checked on 16 and 17 November 2026, after each provider's free allowance.
If we sized runners to the limits our own pods are allowed, not to what jobs actually use, GitHub would be $2,963 and Blacksmith $2,040. We don't lead with those because they assume machines our jobs mostly don't need.
3. Write down what it costs us on paper
Table 1. Estimate. Our side of the comparison, per month.
| Item | Per month | Why |
|---|---|---|
| GitHub's charge for self-hosted runners | $0 | Free under GitHub's billing rules today3 |
| Cloud machines for CI | $0 | None. Every runner is an office machine |
| Electricity | $0 | The office lease includes it |
| Electricity, if we paid it | at most $116 (€106) | All four machines at CI-peak draw, around the clock, €0.20/kWh4 |
| GitHub's self-hosted fee, if it arrives | about $456 | $0.002 a minute, announced for March 2026, then postponed5 |
| Hardware | $0 | The Z440s were a former employer's e-waste; the rest we already had |
The power line is an upper bound. The machines also run other work, so CI's real share is lower. The fee line is the one to watch: GitHub announced it, postponed it and set no new date.5 If it comes, self-hosting stops being free, though at our volume it would still be about a third of the cheapest hosted figure.
Most of the work runs on two HP Z440 workstations, a model from 2014. A dual-Xeon box and a spare laptop did the rest. We already owned all four. The Z440s cost us nothing: a former employer was about to throw them away.

Measured over the last four days only, because that is all the machine history we keep. It supports "mostly two old Z440s", not a 30-day split.
4. Count the costs that never send an invoice
Our time. In the 30 days, 30 merged pull requests changed the runner setup: capacity, cache disks, which machine takes which jobs, version pins. Agents wrote most of them. A person still reviewed each one and owns the result. We didn't put a price on those hours, and anyone comparing should.
A consumer SSD that couldn't keep up. One of the Z440s got a consumer 250 GB SATA SSD as its CI cache. On a busy night the runners wrote the whole drive in about 20 to 25 minutes and deleted about as much. Without regular TRIM the drive had almost no clean blocks left, writes fell to about 55 MB/s, and the cache ran out of inodes before it ran out of space. We took that machine out of the busiest pools the same night.
Deploys stuck behind pull requests. GitHub hands jobs to runners by label and has no priority. On a heavy evening our deploy builds waited for a free runner like every PR check. On 16 November one image build waited 49 minutes, and 12 merges waited for production, the oldest for over two hours.
The night CI got slower. That same evening we landed changes meant to speed up deploys. Each stage we touched got faster: a deploy to our dev environment without an image build went from 33 minutes to 8 to 13, and the production step from 7 minutes to 4.6. End to end, the evening was worse. The median PR check run took 22 minutes, against 16 in the same hours on the seven evenings before, and nothing reached production for more than an hour and a half.
It would be easy to blame the changes. The same evening ran about twice the usual load, 323 CI jobs an hour against 154 on the evenings we compared it with. One evening of 15 PR runs can't separate the two. What we can say is that the queue, not the tests, ate the time.
On hosted runners none of this would have been ours to fix. That is part of what the hosted price pays for.
5. Fix the queue before the machines
What we changed, in the order it mattered:
- Deploy jobs got their own runners. We had already done it for migrations and smoke tests in October. Overnight into 17 November the image builds and end-to-end tests on the release path followed, so a busy PR evening can no longer hold a release.
- The cache SSD is trimmed every 15 minutes, and the cleanup job now reads how full its disk is and deletes sooner when it fills. A reformat with twice the inodes is the next step for that drive.
- Fewer end-to-end tests per deploy. A deploy now runs the critical tests plus the ones its change can reach, and the full suite runs after promotion.
What we don't know yet is the end-to-end effect. The next measurement needs a full working day after these changes, and we'll publish it when it is in.
6. Know when not to do this
- Your minutes fit in the free allowance. GitHub includes $12 a month on Free and $18 on Pro and Team.3 Most small teams are here, and there is nothing to save.
- You would have to buy hardware or pay for power. Our sums work because the machines and the electricity were already paid for. A new server bought for CI has to beat a hosted bill that, for many teams, is a few dollars a month.
- Nobody wants to run it. Runners fail in ways hosted CI hides: full disks, slow drives, stuck queues, a machine that dies during a release. Someone has to notice, at night if it blocks a deploy.
- Your repository is public. GitHub's own guidance is that self-hosted runners should almost never be used with public repositories, because anyone can open a pull request that runs code on your machine.6
7. Do the sum for your own repository
This counts job minutes for one repository over a window, both exact and rounded up per job the way GitHub bills. It makes one API call per run, so keep the window under 1,000 runs or split it. On our repository, half an hour of CI took about a minute to count.
# Job minutes for one repo over a time window. Needs gh (logged in) and jq.
# One API call per run: keep the window under 1,000 runs, or split it.
REPO=your-org/your-repo
FROM=2026-11-01T00:00:00Z
TO=2026-11-08T00:00:00Z
gh api --paginate "repos/$REPO/actions/runs?created=$FROM..$TO&status=completed&per_page=100" \
--jq '.workflow_runs[] | select(.conclusion != "skipped") | .id' |
while read -r run; do
gh api --paginate "repos/$REPO/actions/runs/$run/jobs?filter=all&per_page=100" \
--jq '.jobs[] | select((.runner_name // "") != "" and .started_at and .completed_at)
| (.completed_at | fromdate) - (.started_at | fromdate) | select(. > 0)'
done |
awk '{ s += $1; b += int(($1 + 59) / 60); n++ }
END { printf "%d jobs, %.0f job minutes, %d minutes if each job is rounded up\n", n, s / 60, b }'
Multiply the rounded-up minutes by the per-minute price of the smallest runner that fits, take off your plan's allowance, and you have a floor.
For a busier repository, or a whole month, give the job to your coding agent:
Estimate what our GitHub Actions CI would cost on hosted runners.
Read-only: change nothing.
1. For REPO and the last 30 days, list every workflow run through the
GitHub API. Split the window so no query passes 1,000 results.
Leave out runs that ended "skipped".
2. Fetch the jobs of a random sample of runs per workflow: 10%, at
least 40 each, all runs of small workflows. Job time = completed_at
minus started_at. Drop jobs with no runner_name. Keep a second total
with each job rounded up to a whole minute.
3. Scale each workflow's sample to all its runs and bootstrap a 90%
interval.
4. Price the low end at the smallest hosted size that fits the
90th-percentile job, from the provider's current pricing page, and
subtract the included allowance. Show exact-second and rounded-up
figures separately.
5. Give me one table with the source of every number, and a list of
what you could not measure.
Then write down the hours and the incidents next to the number, and decide with both in front of you.
Measurement notes
- Window. The 30 days from 17 October 23:00 to 16 November 23:00 UTC. It includes heavy agent traffic and one day with 3,426 runs. A quieter month would cost less on hosted runners.
- Runs. All 49,028 runs were listed in 3-hour windows so no query hit the API's 1,000-result cap. 23,678 ended skipped and started no job.
- Sample. Jobs of 3,525 runs: 10% of each workflow, at least 40 runs, every run for small workflows (122 of 148 workflows were fetched in full).
- Estimator. Per workflow, job seconds per run wall-second in the sample, scaled to the wall time of all its runs. 90% intervals from 1,000 bootstrap resamples.
-
Job time.
completed_atminusstarted_at, every attempt counted. Jobs no runner picked up are excluded. - Money. Always the low end of the interval, rounded down, after the larger of GitHub's plan allowances ($18) and Blacksmith's 3,000 free minutes ($12).
- Sizes. The smallest hosted size that holds the 90th-percentile job's peak CPU and memory, measured over four days.7
- Machines. Each job's runner matched to its machine through our metrics, which keep only four days of history. 93% of sampled job time in those days matched.
- Power. 735 W for the four machines, estimated from CI-peak draw (one CPU reading measured, the rest estimated), × 720 hours × an assumed €0.20/kWh.
- The slower night. Same clock hours, 20:35 to 23:31 UTC, on 16 November against 9 to 15 November. The after-window is under three hours and has 15 PR runs, too few to conclude anything on its own.
- Not counted. Runner wait time on either side, and how fast a hosted machine runs our jobs.
Notes and sources
-
GitHub Docs, Actions runner pricing: Linux x64 at $0.006 a minute for 2 cores and $0.012 for 4, and the rule that each job rounds up to a whole minute. Checked 16 November 2026. ↩
-
Blacksmith, pricing: x64 at $0.004 a minute for 2 vCPU and $0.008 for 4, with 3,000 free 2-vCPU minutes a month. Checked 16 and 17 November 2026. ↩
-
GitHub Docs, GitHub Actions billing: included usage of $12 (Free) and $18 (Pro, Team), and self-hosted runners listed as free. Checked 16 November 2026. ↩
-
European Central Bank reference rate, 16 November 2026: 1.1014 US dollars per euro. ↩
-
GitHub, 2026 pricing changes for GitHub Actions and the changelog of 16 December 2025: the $0.002 a minute self-hosted fee and its postponement. Checked 16 November 2026. ↩
-
GitHub Docs, Secure use reference, on self-hosted runners and public repositories. Checked 17 November 2026. ↩
-
GitHub Docs, GitHub-hosted runners and larger runners: 2 CPU and 8 GB standard, 4-core 16 GB larger. Checked 16 November 2026. ↩
Top comments (2)
Runner cost comparisons are most actionable when they include queue time, cache hit rate, maintenance labor, and failure recovery—not just billed minutes. Those are the variables that determine whether a self-hosted setup is actually cheaper for the team operating it.
Thanks Alex, great point, and it's the part I'd most like to hear other teams' numbers on.
We covered some of it in section 4. Queue time was the big one for us: on 16 Nov one image build waited 49 minutes for a runner and 12 merges waited for prod. Giving deploy jobs their own runners fixed that, no new machines needed. Failure recovery showed up as a consumer SATA SSD that struggled under the cache churn, and we learned a lot fixing it.
Labour and cache hit rate are the two we haven't put numbers on yet, and you're right that they matter. Both go into the follow-up measurement, and I'll share the results either way.