Skip to content

Home / Blog / Runners and limits

Is it safe to run CI on a third-party runner service? What to check

A third-party runner sees your code, secrets and network while a job runs. The 8 questions to put to any service in writing, and what GitHub says about isolation.

It can be, but it is a trust decision. While a job runs, your source code, the secrets GitHub hands its runner and your network access are on a machine someone else operates. GitHub says its standard hosted runners are ephemeral, clean, isolated virtual machines, so the test for any third-party service is whether it can say the same, in writing, on 8 points.

In short
  • A third-party runner service sees your code, your secrets and your network while a job runs, so the decision is about trust.
  • GitHub says its standard hosted runners are ephemeral, clean, isolated virtual machines; ask the service to match that in writing.
  • Ask 8 things: a fresh machine per job, what shares it, the audit report, App permissions, cache scope, retention, secrets and exit.
  • GitHub says a self-hosted runner can be persistently compromised by untrusted code, which is why a fresh machine for every job is the first question.
  • Our answers are only what our documentation says, and where it is silent, the answer says so.

This page is those 8 points, with the answer we can give to each and where it is written down. It names no other service on purpose: the questions are the useful part, and a service that cannot answer one in writing has told you something. Every GitHub statement below was read from GitHub’s documentation on the date this post was last checked, and every statement about runners.io is one our own documentation already makes.

What does a third-party runner service see?

Everything the runner sees. That is the code the job checks out, the secrets GitHub hands the runner for that job, the network the machine sits on and the job’s log. GitHub’s guidance makes the stakes plain: jobs in a workflow can interact with, and compromise, one another, and a compromise of a single action within a workflow can be very significant, because that action would have access to every secret configured on the repository. A runner service adds one more party that holds the same things a runner holds.

What does GitHub say about runner isolation?

GitHub’s pages do not mention third-party services. They describe GitHub-hosted and self-hosted runners, and a service’s machines are a runner you cannot see inside, which is why the questions below begin with the one GitHub's own hosted runners are built around: is each job on a clean machine that nothing else touches?

Kind of runnerWhat GitHub saysPage
GitHub-hosted, standardGitHub-hosted runners execute code within ephemeral and clean isolated virtual machines, "meaning there is no way to persistently compromise this environment".Secure use reference
GitHub-hosted, single-CPU (ubuntu-slim)Runs the job in a container rather than a full VM instance, in unprivileged mode.GitHub-hosted runners reference
Self-hostedNo guarantee of running in an ephemeral clean virtual machine; it "can be persistently compromised by untrusted code in a workflow".Secure use reference
Self-hosted, destroyed after every job by an automated systemGitHub says this might not be as effective as intended, because there is no way to guarantee a self-hosted runner only runs one job.Secure use reference
Self-hosted, just-in-timePerforms at most one job before it is removed, but re-using hardware to host it can risk exposing information from the environment.Secure use reference

What should I ask a third-party runner service?

Put these to every service, including us, and ask for the answers in writing. A good answer is a sentence you can link to. A weak one is “isolated” with nothing after it. The last column is what our documentation says on the date this post was last checked; where it is silent, we say so.

QuestionA good answerOurs, as our documentation says it
1. Is every job on a fresh machine that is never reused?One machine made for the job, with its disk, memory and firmware state erased, or the machine destroyed, when the job ends.Each job runs in its own virtual machine, started fresh from our image and shared with no other job. When the job ends the machine is destroyed, or rebuilt from the image, and a rebuild erases its disk, memory and firmware state.
2. What else shares the machine, the network and the address?Nothing shares the machine, and a plain statement of what the network does share.No other job shares a job's machine, and nothing on the internet or in another job can open a connection to a running job. Outbound traffic is not separated by organisation, so allowlisting one of our addresses is not a boundary between tenants.
3. Which audit report do you hold, for which period, from whom?The report itself rather than a badge: its type, its period, the auditor and its scope. Holding none is an acceptable answer if it is said plainly.Our documentation is silent on this.
4. What does the GitHub App ask for, and what is each permission used for?A list with a reason beside every permission.Connect your account lists all of them. Administration (read and write) registers a single-use runner on the repository for each job and removes it afterwards. Actions write is used only to cancel a workflow run.
5. How are caches scoped?A credential tied to your account and repository, and a rule for what an untrusted build may write.A job's cache credential names your GitHub account and repository by their ids and expires, so a job cannot reach another repository's or account's entries. Only a successful default-branch build from a trusted event can change a sticky disk.
6. What do you keep, and for how long?A list with a period beside each item: logs, caches, test results, timings.Each job's log is shown on its job page for 30 days, and its timings and minutes stay for billing. Cache entries, Docker layers and a sticky disk are stored between jobs, for the periods on their own pages.
7. How do secrets reach the job, and for how long are they there?On the job's machine only while it runs, with no copy kept.The code a job checks out and the secrets GitHub hands its runner are on a machine we operate while the job runs, as on any runner you do not host yourself. When the job ends, the machine is destroyed, or rebuilt as in question 1.
8. What does leaving cost, and what happens to my jobs if you stop?Leaving is a one-line change, and you know what a job does when its label has no runner.Moving a job is changing its runs-on label, and a workflow can mix our runners and GitHub's job by job. Installing the App moves no builds: nothing runs on our runners until a workflow names one of our labels. If we cannot take a job, it stays queued on GitHub, which cancels a queued job after 24 hours. Nothing is billed. That is on our limits page.

The pages behind the last column are the security documentation, the list of permissions the GitHub App asks for, the runner labels, the limits page and the security page. The longer account of one machine per job is Every job in its own virtual machine.

What happens to my jobs if the service stops?

Ask it, because GitHub does not answer it for you. GitHub’s limits page gives 24 hours as the longest a job can queue for a self-hosted runner before it is automatically cancelled, so ask the service what its runners are to GitHub, and what your jobs do when its label has no runner. The cheap protection is that moving a job back is the same runs-on change as moving it in. Keep your old runs-on value in a comment for the first month.

What can a runner service not fix?

A clean machine for every job does not protect you from what the job runs. A compromised action, a script that prints a secret, or a token with more permission than the job needs does the same harm on any runner. GitHub’s advice is to pin actions, lock your workflow dependencies with a lockfile, and give the GITHUB_TOKEN the minimum permissions. We cover the lockfile in Does GitHub Actions have a lockfile? and the rest in the security hardening checklist. A workflow that follows them is a safer one to hand to any service. The sample uses the tag v7 so it reads clearly; pin it to a full commit SHA, as the hardening post explains.

name: build
on: [push]
permissions: {}
jobs:
  build:
    runs-on: runnersio-2vcpu-ubuntu-2404
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@v7
        with:
          persist-credentials: false
      - run: make test

How do I try one safely?

Start with one repository that holds no deploy secrets, and one workflow. Read the job’s log and the App’s permissions before you widen it. The ten questions for choosing a provider cover the rest of the decision, cost and limits included, and what managed runners are sets out how they differ from the two kinds GitHub runs and you run. If you want to try ours, the migration page opens a pull request you read before you merge it. Every size we run, with its memory, disk and rate a minute, is on our managed GitHub Actions runners page.

Sources

Frequently asked questions

Is it safe to run CI on a third-party runner service?

It can be, but it is a trust decision: the service's machine sees your code, secrets and network while a job runs. GitHub describes its standard hosted runners as ephemeral, clean and isolated. Ask the service to match that in writing, and to name its audit report, its App permissions and its cache scoping.

What should I ask a third-party runner service before switching?

Whether every job gets a fresh machine, what else shares it, which audit report it holds and for which period, what its GitHub App asks for, how caches are scoped, what it keeps and for how long, how secrets reach the job, and what leaving costs.

Does a runner service make my workflows safe?

No. A clean machine does not stop a compromised action, a script that prints a secret or a token with too many permissions. GitHub advises pinning actions, locking workflow dependencies and giving the GITHUB_TOKEN the minimum permissions, on any runner.

Move your CI onto our runners with one line

Change one line, watch your own build, then decide.

Connect GitHub

Card required. You pay only for the minutes your jobs run.

.github/workflows/ci.yml
jobs: test:removed: runs-on: ubuntu-latestadded: runs-on: runnersio-4vcpu-ubuntu-2604 steps: - uses: actions/checkout@v4 - run: make testadded: build:added: runs-on: runnersio-32vcpu-ubuntu-2604