skip to content

Hosted Runners and Fleet

The runner side of GitLab seen from the platform: hosted runners that give every job a fresh VM and draw on a compute-minute quota, against runners you operate yourself, and the fleet view that shows which of them have gone stale. Interviewers ask it to see whether you can predict a CI bill and keep a runner fleet tidy.

on this pageshow

explore

questions

4

On GitLab.com, where does an untagged CI job run by default, and what is left of its machine when the next job starts?

level: juniorimportance: must knowfreq 44%

answer

  1. on by default, no setup
  2. smallest Linux machine type
  3. one VM per job
  4. deleted right after the job
  5. three-hour ceiling

basics

~20 s

On GitLab.com an untagged job runs on the GitLab-hosted small Linux x86-64 runner, in a newly provisioned VM dedicated to that job and deleted when it ends, so nothing on that machine reaches the next job.

solid answer

~40 s

GitLab-hosted runners are enabled by default for every GitLab.com project, so a job with no tags lands on the `small` Linux x86-64 machine (`saas-linux-small-amd64`, 2 vCPUs and 8 GB). Each job gets a newly provisioned VM that serves only that job and is deleted straight afterwards: packages you installed with `sudo`, files on disk and pulled image layers are gone, and anything the next job needs has to travel as an artifact or a cache. A job asks for a bigger Linux machine, an Arm64, GPU, Windows or macOS machine by naming that runner's tag, and each machine type draws compute minutes at its own cost factor. Hosted-runner jobs also time out after 3 hours whatever the project's timeout says.

go deeper

for a junior

Recall the three facts: hosted runners are on by default on GitLab.com, untagged jobs use the small Linux x86-64 machine, and every job gets a fresh VM that is deleted afterwards.

for a middle

Explain what that lifecycle means for a pipeline: nothing on disk carries between jobs, artifacts and cache are the only bridges, and a different machine type is chosen per job by its runner tag at a higher cost factor.

for a senior

Show you can predict hosted-runner behaviour in production: the 3-hour cap that ignores the project timeout, beta Windows and macOS runners whose beta images sit outside the SLA, tier-gated large and GPU machines, and when a job belongs on your own runner instead.

for a principal

Frame hosted runners as a policy default: which workloads a platform team leaves on ephemeral metered VMs, which it moves to its own fleet, and how that split shows up in compute minutes and isolation guarantees.

## What a GitLab-hosted runner is A **runner** is the agent that picks up a CI/CD job from GitLab and executes its script. On **GitLab.com**, GitLab operates a fleet of **GitLab-hosted runners** for you. They are **instance runners** (available to every project on the instance), they are **enabled by default** for all projects, and they need no registration or configuration from the team. The alternative is a runner you install and operate yourself; the material on runner configuration covers how those are registered and routed. Jobs on hosted runners draw on the namespace's **compute minutes**, so knowing which machine a job lands on is the first step to predicting the CI bill. ## The default: untagged jobs on the small Linux runner A job with no `tags` runs on the **`small` Linux x86-64** hosted runner, tagged `saas-linux-small-amd64`. It has 2 vCPUs, 8 GB of memory and 30 GB of storage, and its cost factor is `1`, the cheapest rate. Two consequences matter: - A team that never thought about runners is already on this machine, so "our build is slow" often means "our build is running on the smallest VM". - Moving a job to a larger machine is a deliberate choice made by naming another runner tag on the job, and it raises the cost factor. ## One job, one VM The lifecycle of each job on a GitLab.com hosted runner is: 1. GitLab provisions a **new virtual machine** dedicated to that job. 2. The job runs; on Linux it runs in the container image the job asks for, and the VM grants passwordless `sudo`. 3. As soon as the job completes, GitLab sends the command to **delete the VM** and its data. So nothing written to that machine's disk survives: not an `apt` install, not a build directory, not a pulled image layer. The next job of the same pipeline, even in the same stage, starts on a different, clean VM. What crosses between jobs is only what the pipeline explicitly hands over as **artifacts** or through the **cache** that the hosted runners share (cache entries not updated for 14 days are removed). The network is fenced as well: the VM may only make outbound connections, inbound connections from the internet are refused, and VMs cannot talk to each other. One documented exception exists: the separate fleet that runs **community contributions to GitLab's own projects** reuses its machines up to 40 times. Ordinary GitLab.com projects do not run there. ## Machine types | Runner tag | Platform | Tiers | Status | |---|---|---|---| | `saas-linux-small-amd64` | Linux x86-64, default | Free, Premium, Ultimate | GA | | `saas-linux-medium-amd64` | Linux x86-64 | Free, Premium, Ultimate | GA | | `saas-linux-large-amd64` and larger | Linux x86-64 | Premium, Ultimate | GA | | `saas-linux-small-arm64` | Linux Arm64 | Free, Premium, Ultimate | GA | | `saas-linux-medium-amd64-gpu-standard` | Linux x86-64 with a GPU | Premium, Ultimate | GA | | `saas-windows-medium-amd64` | Windows | Free, Premium, Ultimate | Beta | | `saas-macos-medium-m1`, `saas-macos-large-m2pro` | macOS | Premium, Ultimate | Beta | On Linux you may use any container image. On **Windows and macOS** you can only use the images GitLab supports; you cannot bring your own. Jobs on beta images are not covered by the service-level agreement. ## Limits that surprise people - **Three-hour timeout.** Jobs on GitLab.com hosted runners time out after 3 hours, regardless of the timeout configured in the project. Raising the project timeout does not help; split the job or run it on a runner you operate. - **Shared disk.** The VM's storage holds the operating system, the image with its preinstalled software and your clone, so the free space a job sees is less than the machine's nominal storage. - **Start-up time.** GitLab's stated objective is for 90% of jobs to start within 120 seconds, so a short wait for a hosted runner is normal rather than a fault. ## Where your own runners fit A team that needs persistent state, a machine type the hosted fleet lacks, jobs longer than three hours or no compute-minute charge can register its own group or project runners and route jobs to them. That trade-off in general is a vendor-neutral CI design question; on GitLab.com the practical point is that hosted runners are the default, ephemeral and metered, and anything else is something you run.

  • On GitLab.com, why does a hosted-runner job report less free disk than its machine type's listed storage?
    The VM's storage is shared by the operating system, the container image with its preinstalled software and the cloned repository, so the space left for the job is smaller than the nominal figure. A bigger machine type raises the storage, at a higher cost factor, or the job can use a slimmer image.
  • On GitLab.com, why does a team's macOS job fail to start on a Free namespace?
    The macOS hosted runners are a Premium and Ultimate feature (and available to open source programs), and they are still beta. A Free namespace has the Linux machines up to medium x86-64, the small Arm64 machine and the beta Windows machine, but no macOS machine type.

  • Hosted runners must be registered before a GitLab.com project can run jobs.
  • Untagged jobs land on the medium Linux machine by default.
  • Jobs in one pipeline share a hosted VM, so installed packages carry over.
  • Raising the project timeout lets hosted-runner jobs run past three hours.
  • Any container image can be used on the Windows and macOS hosted runners.
open as a page

On GitLab.com, how are compute minutes calculated for jobs on hosted runners, and why can a pipeline use more minutes than it took?

level: middleimportance: must knowfreq 33%

basics

~20 s

Each job's usage is its run time in minutes multiplied by the runner type's cost factor, charged to the top-level namespace. Pipelines add up all their jobs, so parallel jobs make usage exceed the pipeline's wall-clock time.

open as a page

On GitLab.com, a group's jobs on hosted runners stop mid-month while its own group runners keep working; what happened, and what becomes of pending and running jobs?

level: seniorimportance: should knowfreq 22%

basics

~20 s

The top-level namespace used up its compute quota. Instance runners stop taking its new jobs, pending and retried ones are dropped, running jobs continue until usage is 1,000 minutes over quota, and the group's own runners carry on.

open as a page

In GitLab, what makes a runner stale rather than offline, and how do you find and clean up stale runners across a fleet?

level: seniorimportance: should knowfreq 16%

basics

~20 s

A GitLab runner is offline after more than 2 hours without contacting GitLab and stale after more than 7 days (since GitLab 17.1). Spot them in the instance or group runner list, then delete them or, on Ultimate, enable group stale runner cleanup.

open as a page