Skip to content

Home / Blog / Runners and limits

"The runner has received a shutdown signal" and "lost communication": causes

Both messages mean the runner stopped talking to GitHub mid-job. The five causes in the order to check them, how to tell them apart and a log step that explains the next one.

Both messages describe the runner stopping, or going silent, in the middle of a job, and the job fails with it. “The runner has received a shutdown signal” says the runner was told to stop, and “lost communication with the server” says GitHub stopped hearing from it. GitHub’s annotation names three possible causes, and reports add more. One is a job starving the runner of memory, which is 8 GB on a private-repository runner.

In short
  • Both messages describe the runner stopping, or going silent, during a job, and the job fails with it.
  • GitHub's annotation names three possible causes; reports add memory starvation, a stopped host, a network drop and a hung runner.
  • A standard private-repository Linux runner has 8 GB of memory; one contributor reports that above RAM plus swap the runner is lost with this message.
  • An if: always() step can be skipped when the runner shuts down, so print memory into the log while the job runs.
  • Exit code 143 is SIGTERM and 137 is SIGKILL, which the out-of-memory killer sends.

This post sets out the causes in the order to check them, how to tell them apart from the logs and the timestamps, and one change that makes the next failure explain itself. The GitHub facts were read from GitHub’s pages on the date this post was last checked. GitHub’s annotation names three possible causes and its documentation gives no more, so each other cause below says who reported it.

What do “The runner has received a shutdown signal” and “lost communication with the server” mean?

The first is a line the runner logs about itself: it has been told to stop, and the step it was running is marked “The operation was canceled”, as in a report from October 2026. The second is the server’s view, an annotation on the job that GitHub adds when a runner stops answering: “The hosted runner: … lost communication with the server. Anything in your workflow that terminates the runner process, starves it for CPU/Memory, or blocks its network access can cause this error.” For a self-hosted runner it begins “The self-hosted runner”, as in an issue open since August 2022. The post on “The operation was canceled” covers the cancellation side: what GitHub does when it cancels a job on purpose.

GitHub’s own page on monitoring and troubleshooting self-hosted runners says a runner shows as Offline when the machine is down, the runner application is not running or it cannot communicate with GitHub. It does not mention either message, and the page covers self-hosted runners only. For a hosted runner, GitHub’s documentation that we read gives no cause either, and the reports below are all there is.

What causes them?

Five causes account for the reports we read. The table lists them in the order to check, with how to confirm each and what the evidence is.

CauseHow to confirmThe changeWho says so
The machine ran out of memory or CPUMemory printed into the log falls toward zero before the log stops; no out-of-memory line appearsFewer parallel workers, a heap cap, a bigger runnerA contributor on GitHub's runner images repository: above RAM plus swap, the runner was lost with the same message
The machine was stopped, drained or reclaimedThe time of the failure matches a reboot, an eviction or a spot or preemptible reclaimOn-demand capacity for long jobs; a window for maintenanceReports on the runner repository; a reporter says on-demand capacity cut failures from 30 to 40 per cent to 0.01 per cent
The network between the runner and GitHub droppedThe runner's diagnostic log shows a dropped connection; the self-hosted check failsFix the route, or run the runner's own checkGitHub's documentation lists it among the reasons a self-hosted runner is offline
The runner process hung or was killedThe runner's own log ends; a job fails after about ten minutes with no step loggedRestart the service; follow the report's fix pull requestAn open bug report on the runner repository, not confirmed by a maintainer
A hosted runner stopped from outside with no cause visibleNothing in the logs: no out-of-memory line, no timeout, no cancellationRe-run the job; report it to GitHub Support with the run linkAn unanswered community thread, where a reply says only GitHub Support can tell which side stopped it

Memory or CPU. A contributor on GitHub’s runner images repository, answering a report in November 2026, capped a runner at about 7.75 GiB of RAM plus 3 GiB of swap and held memory with Node. Jobs that used 7 and 9.25 GiB passed, and above RAM plus swap “the runner was lost with the same shutdown message”. The reporter’s log has no exit code and no out-of-memory line, and the contributor’s reading is that the machine stops responding before an out-of-memory message can reach the log. The contributor closed the report on 12 November 2026 as matching the runner running out of memory. A standard Linux runner in a private repository has 2 vCPU, 8 GB of memory and 14 GB of SSD. The post on memory and out-of-memory kills shows how to measure a job’s peak. Start there if the last lines of the log are the job’s heaviest step.

A stopped or reclaimed machine. On a self-hosted fleet, the runner goes when its host does: a service restart or upgrade, a drained node, an evicted pod or a reclaimed spot or preemptible instance. In the long thread on the runner repository one reporter, who suspected spot instances, says switching to on-demand capacity cut failures from 30 to 40 per cent to 0.01 per cent. That is one reporter’s figure and no maintainer has confirmed a cause in the thread, so treat it as a reason to compare timestamps and not as a result. Match the failure time against your autoscaler’s and cloud provider’s events.

The network. The runner has to reach GitHub for the whole job. GitHub’s page lists a runner that cannot communicate with GitHub among the reasons it shows as Offline, and its --check option on the runner’s config script (with the runner’s --url and --pat) tests each required service and prints PASS or FAIL for each.

A hung runner process. One open report on the runner repository, from September 2026, describes a listener that stalls after its connection to GitHub’s broker is interrupted and takes no more jobs: GitHub fails each job at ten minutes with the “lost communication” message and no step logged, and the runner drops out of the organisation’s list. The report is open and a maintainer has not confirmed it, but a job that fails at ten minutes with no steps is worth checking against it.

A hosted runner stopped from outside. Sometimes there is nothing to find. In a community thread from October 2026, a job on a GitHub-hosted ubuntu-24.04 runner stopped about ten seconds after an install began, with exit code 143, no timeout or competing cancellation found and no out-of-memory kill in the last container heartbeat. 143 is 128 plus 15, the number of SIGTERM, where an out-of-memory kill gives 137. The thread has no answer from GitHub, and a reply there says only GitHub Support can tell which side stopped the runner. If you see this and a re-run passes, send Support the run link.

How do I tell which one it was?

Start with the clock. Note when in the job it stopped and compare that with what the job was doing: a build at its most memory-hungry points to memory, a job that fails at ten minutes with no step logged matches the open report of a hung runner, and a failure that lines up with a reboot or a scale-in points to the machine. On a self-hosted runner, the _diag folder where you installed the runner holds a Runner_ log for the application and a Worker_ log for each job, and journalctl -u on the runner’s service shows the service side. For a hosted runner, re-run the job with debug logging, from the run page or with gh run rerun RUN_ID --failed --debug, which turns on runner diagnostic logging for the attempt.

If it was memory, you will not see it at the time, because the machine stops before it can say so. So print memory into the log as the job runs. A step in the same job with if: always() will not help here: the report quoted above saw such a step skipped when the runner shut down. This step prints used and available memory every fifteen seconds while the tests run. The lines are written to the step’s own log as it runs, not at the end, so they are already there if the runner is lost. The loop was run locally with a stub of free and the workflow linted with actionlint 1.7.12; it has not run on GitHub.

- name: Test, with memory printed into the log as it runs
  run: |
    ( while true; do
        echo "memory MB, used/available: $(free -m | awk '/^Mem:/ {print $3 "/" $7}')"
        sleep 15
      done ) &
    sampler=$!
    status=0
    npm test || status=$?
    kill "$sampler"
    exit "$status"

If the available figure falls toward zero and the log stops in the middle of a step, you have your answer, and the fixes are in the out-of-memory post. If memory stays flat, the cause is outside the machine, and the timestamps are what you take to the provider or to GitHub Support.

On our runners the job page has a Resources tab covering memory, disk, CPU and network over the run, described on the jobs page, so a run can be read without adding a step. If memory is the cause and a bigger runner is the fix, the runner size guide sets out how to choose the size. Every size we run, with its memory, disk and rate a minute, is on our managed GitHub Actions runners page.

Does GitHub retry the job, and can the job survive one?

We found nothing in GitHub’s documentation saying that a job lost this way is retried for you, so assume it is not: re-run the failed jobs yourself, from the run page or with gh run rerun RUN_ID --failed. A job cannot rely on its own cleanup, because a step with a condition may be skipped when the runner shuts down. Two habits help. Upload an artifact as soon as the step that makes it ends, not in a final step, and split a long job into jobs joined with needs, so that a loss costs one stage and not the whole run. The limits post lists the job time and re-run limits that apply to the retry.

Sources

Frequently asked questions

What does "The runner has received a shutdown signal" mean?

The runner process was told to stop while your job was running, and the job failed with it. The step it was running is marked cancelled. The log does not say who sent the signal; reported causes are memory starvation, a stopped host and an outside stop.

What causes "lost communication with the server"?

GitHub's annotation says anything that terminates the runner process, starves it for CPU or memory, or blocks its network access can cause it. Reports add a stopped or reclaimed host and, on self-hosted runners, a hung listener.

Is a shutdown signal always an out-of-memory kill?

No. A contributor on GitHub's runner images repository reports it appears when a job exceeds RAM plus swap, but a hosted job in a community thread stopped with exit code 143, SIGTERM, and no out-of-memory line. A community reply says only GitHub Support can tell which side stopped that runner.

How do I find the cause?

Compare the failure time with what the job was doing and with reboots or scale-ins. Re-run with debug logging, check the runner's _diag logs if self-hosted, and print memory into the log every few seconds while the job runs.

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