Ubicloud GitHub Actions runners, and where 4 to 7x lands

By Kaveh Alemi·Latchkey

Ubicloud GitHub Actions runners advertise a saving of 4 to 7x against GitHub-hosted, and the two ends of that range are claims about different things. Dividing its two published rate cards gives 4.8x at the small x64 sizes and 4.0x on arm64, which is the 4 end and checks out; the 7 end is a price-performance figure that folds in a separate claim that your jobs run twice as fast.

GitHub-hosted runners are the baseline. On a private repository a standard Linux x64 runner is 2 vCPU with 8 GB at $0.006 a minute, Linux arm64 is $0.005, Windows is $0.010 and macOS is $0.062, with included minutes by plan, 10 GB of cache per repository and artifact storage pooled with GitHub Packages. On a public repository standard runners are free and unlimited, which ends most comparisons before they start.

Ubicloud sells VMs from an open-source cloud it runs on bare metal, and GitHub Actions runners are one product on it. Runner VMs sit in data centres in Germany, x64 standard machines are AMD EPYC 9454P, premium machines are AMD Ryzen 9 7950X3D, and arm64 machines are Ampere Altra Q80-30 with a dedicated core per vCPU, built from the packer templates GitHub publishes in actions/runner-images.

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

Ubicloud, GitHub-hosted and Latchkey side by side (read 21 September 2026)

Where the 4 to 7x range comes from

Ubicloud publishes a range rather than a single number, and it is worth separating which of its claims is a price and which is not. Its GitHub Actions page says "Save 4-7x" under the heading and "Reduce your GitHub Actions bill by 4-7x" over its rate table, while its page title and the badge on each runner card say something narrower: "7x Price-Performance" and "7x better price-performance".

Only one of those is arithmetic, and it holds. Read it per ladder, because a single blended range hides which machine you are buying. Standard x64 divides out at 4.8x at 2 and 4 vCPU, 4.4x at 8, 4.2x at 16 and 4.1x at the largest size. Premium x64 is a flat 3.0x at the two smallest sizes, which is what Ubicloud's own documentation means by runners "priced at just 1/3th the cost of GitHub-hosted runners". arm64 is a separate and weaker ladder: 4.0x at 2 vCPU, falling to 2.5x at 30. A competitor checks the same two rows and gets the same answer, since RunsOn's runner benchmark prices the standard 2 vCPU runner at 4.8x cheaper than GitHub and the premium one at 3.0x.

So a measured 4.8x sits at the bottom of Ubicloud's own published range rather than contradicting anything, and two things account for the rest of it. The 7 is a price-performance figure, not a rate: the same page says "Go twice as fast" and "Double the performance", and price-performance multiplies the two halves together. And the badges carrying it sit beside runner cards still quoting $0.0010 and $0.0016 a minute, the rates before Ubicloud raised both tiers by 25% effective 1 September 2026; at the old standard rate the 2 vCPU multiple was 6.0x. Until your own jobs actually get faster, the multiple on your invoice is the current rate multiple alone.

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 fortnight, because runner selection is per job and the Actions run log hands you the timings for free.

This is the half of the headline that carries the 7. Ubicloud publishes sample run times for five named open-source repositories, including folly, xls, peerdb, supabase and astrobee, dated 7 January 2025, and attributes the difference to newer hardware than the Azure VMs GitHub uses. Naming the repositories and the date is more than most vendor claims manage, and it is still five projects that are not yours, measured some time ago.

The hardware description is easier to act on. Two x64 vCPU map to one physical core on the standard tier, as they do on GitHub, so a standard Ubicloud runner is not secretly smaller; each arm64 vCPU gets a dedicated physical core, which is why those machines pair 6 GB with 2 vCPU instead of 8.

Cost: the same month, and the part that does not move

The workload every comparison here uses: 10,000 Linux minutes at 2 vCPU plus 2,000 macOS minutes, private repository. Ubicloud sells no macOS runner, so that half of the bill stays where it was.

The Linux line moves by a factor of six and the bill by 27%, because macOS is two thirds of this month and the saving lands on the other third. On a pipeline with no macOS it inverts: $10 against $60, an 83% cut, and the rate card is then the whole story. 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.

Artifacts do not move with the runner: they go to GitHub wherever the job ran, at $0.25 per GB per month above a plan allowance shared with GitHub Packages. Cache does move, and moves well: 30 GB per repository per week against GitHub's 10 GB per repository, though GitHub Actions cache size limit is worth reading first, because a cache thrashing at 10 GB usually has a key problem rather than a size one.

None of this applies to a public repository, where standard GitHub-hosted runners cost nothing and have no minute limit. The only reasons to move an open-source project are speed, arm64 pricing or machine size, never the bill.

Reliability

Neither publishes an Actions SLA on the pages read here, so the comparison is what each tells you about its image and its capacity. GitHub publishes the runner images, a status page and concurrency caps by plan. Ubicloud publishes no concurrency number at all, the largest gap in its documentation for anyone planning a wide matrix.

What it does publish is its image policy, a deliberate trade. It builds x64 images from GitHub's own packer templates in actions/runner-images and updates monthly, but deploys a few days after GitHub, because GitHub has shipped images it then had to roll back. So for a few days each month the image is behind ubuntu-latest, and a workflow expecting a just-added preinstalled tool fails on Ubicloud and passes on GitHub. What is installed on ubuntu-latest explains why it moves.

And the failure neither side handles is the ordinary mechanical one: a registry timeout, a browser binary that did not install, an out-of-memory kill. The run bills, the re-run bills, the merge waits for a person, and that cost does not shrink when the minute gets cheaper.

When to choose Ubicloud

• Your repositories are private, your pipeline is Linux, and minutes are a line you can see on an invoice. This is the cheapest published rate in the category by a clear margin at every size.
• You build arm64 at a small size. A dedicated physical core per vCPU at $0.00125 against the GitHub-hosted arm64 rate of $0.005 is 4.0x at 2 vCPU, though the arm64 saving narrows as the machine grows and is 2.5x at 30 vCPU, well under the x64 ladder.
• Your services are in Europe, so German data centres shorten your dependency pulls instead of lengthening them.
• You want the option to leave. The platform is AGPL v3, so running it yourself is a documented path rather than a theoretical one.
• Your cache is between 10 and 30 GB, where GitHub starts evicting and Ubicloud does not.

When to stay on GitHub-hosted

• Your repositories are public. Standard runners are free and unlimited, and no paid rate card competes with zero.
• Your pipeline needs Windows or macOS. Ubicloud publishes no labels for either, so those jobs stay on GitHub and the comparison only covers part of your bill.
• You are inside your included minutes. Two thousand a month on Free and three thousand on Pro and Team is an allowance you are not being charged for, and Ubicloud requires a card before the first runner exists.
• You need a published concurrency number to plan a wide matrix. GitHub documents its caps by plan; Ubicloud publishes none.
• Your workflow depends on the newest preinstalled tooling the day it lands, which is exactly the window Ubicloud deliberately waits out.

Switching: the exact diff

One label, after a GitHub App install and a card. Nothing else in the workflow changes, because the transparent cache backs actions/cache without an action swap and the images are built from the same templates. Keep a GitHub-hosted job beside the new one for a fortnight so you are comparing the same commits rather than the same week.

 jobs:
   test:
-    runs-on: ubuntu-latest
+    runs-on: ubicloud-standard-4
     steps:
       - uses: actions/checkout@v7
       - uses: actions/setup-node@v6
         with:
           node-version: 22
           cache: npm
       - run: npm ci && npm test

   test-control:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v7
       - uses: actions/setup-node@v6
         with:
           node-version: 22
           cache: npm
       - run: npm ci && npm test

The verdict

On a private repository with a Linux pipeline, Ubicloud is the cheapest published runner in this corpus, and its price claims hold up when you check them, which is not something every rate card in this category manages. Dividing its own two columns gives 4.8x at 2 and 4 vCPU on the standard tier, 4.2x at 16, and a flat 3.0x on the premium tier a new account is placed on, matching the wording in its own documentation. That is the 4 in its published 4 to 7x range. The 7 is a price-performance figure carrying a separate claim that your jobs run twice as fast, so it is the half to test rather than the half to quote, and on arm64 the rate saving alone falls to 2.5x at the largest size. Where it stops is clear enough to check in a minute: no Windows, no macOS, no published concurrency number, German data centres, and a runner image that deliberately lands a few days after GitHub's. For a public repository GitHub-hosted is free and none of this applies. Neither side repairs a job that failed for a reason unrelated to your code, and the cheaper the minute gets, the larger a share of your bill that re-run becomes.

Frequently asked questions

Related guides

References

• Ubicloud pricing: standard, premium and arm64 runner rates beside the GitHub rate (verified 2026-09-21)
• Ubicloud GitHub Actions use cases: the 4 to 7x range, the runner cards and the rounded x64 table (verified 2026-09-21)
• Ubicloud premium runners: the AMD Ryzen fleet and its "1/3th the cost" wording (verified 2026-09-21)
• Ubicloud runner types, labels, hardware and image build policy (verified 2026-09-21)
• GitHub Actions billing: per-minute rates, storage rates and plan allowances (verified 2026-09-21)
• GitHub Actions documentation