GitHub Actions concurrency limits: why pull requests queue at busy hours, and how to run more jobs at once without Enterprise

GitHub-hosted runners run a fixed number of jobs at once per account: 20 on GitHub Free, 40 on Pro, 60 on Team, 500 on Enterprise. The count is across every repository and workflow, so when pull requests pile up at busy hours, the jobs past the limit queue until running ones finish. Short of Enterprise you can ask GitHub Support to raise the limit, cancel superseded runs, or run jobs where the limit doesn't count them: on self-hosted runners.

Skipbox is a self-hosted runner you don't host. Its jobs don't count against GitHub's hosted limit, and they run on your account's own machine for a flat $39 a month with unlimited minutes. Move your longest jobs with one line, runs-on: skipbox, and the hosted slots they held go back to everything else.

GitHub's limits on jobs at once

From GitHub's Actions limits page, read November 14, 2026:

• The limit is the account's, not a repository's. Every workflow in every repository draws on the same number.
• A matrix counts each of its jobs, and one workflow run can generate 256 of them.
• A job past the limit isn't refused. It stays queued and starts when a running job ends.
• The limit is for GitHub-hosted runners. Jobs on self-hosted runners aren't in it.

Why it bites at busy hours

A team on GitHub Team has 60 slots. A pull request that runs lint, unit tests, a build and an E2E suite split 8 ways holds 11 of them. Six pull requests pushed in the same ten minutes want 66, and the last ones wait.

Coding agents make the busy hour longer. An agent pushes each fix as it goes, each push starts the whole workflow again, and the runs of the push before are still holding slots.

What you can do short of Enterprise

The concurrency block belongs in every pull-request workflow whatever you choose:

concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true

It cancels runs of the same workflow on the same pull request and leaves pushes to other branches alone.

Skipbox: your heaviest jobs leave the queue

The jobs that hold a slot longest do the most to fill the limit: the Docker build, the E2E suite, the monorepo's full test run. Move those to Skipbox and three things change.

They stop counting. To GitHub a Skipbox job is a self-hosted job. It takes none of your 20, 40 or 60 hosted slots, so the short jobs you leave on GitHub start at once.

They end sooner. Each plan comes with your account's own machine, kept between jobs. Docker images, layers and build cache, package caches and installed tools are on its disk when the next job starts, so the job skips the downloads a new VM repeats every run.

They cost the same every month. Minutes are unlimited. A busy week adds nothing to the bill.

On Skipbox, your plans' vCPU set how many jobs run at once, and you choose it:

Jobs run at once while they fit in the vCPU of all your plans added together, and you can hold any number of plans in any mix. A job past that waits its turn and starts when a running one ends. Waiting adds nothing to the bill, and your account's page shows how many jobs wait and for how long. Concurrency and queueing has the rules.

What the same minutes cost

Larger runners lift the limit by billing more per minute. A flat plan lifts it without a meter:

GitHub's figures are after GitHub Team's included usage. Your own minutes go in the calculator on the home page.

Moving is one line

jobs:
  e2e:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm run test:e2e

1. Sign in to Skipbox with GitHub.
2. Install the Skipbox GitHub App and pick the repositories.
3. Change runs-on on the jobs that run longest and push.

The other jobs stay on ubuntu-latest and keep GitHub's hosted slots to themselves.

Security

• The machine is your account's alone. No other company's jobs run on it.
• After every job, the runner's credentials, processes and containers are wiped. Clean every job gives each job a fresh machine instead.
• Code from people without write access (such as pull requests from forks) runs on a fresh, throwaway machine.

The details are in how jobs are isolated.

Try it at your next busy hour

The trial is free for 7 days or 3,000 job-minutes, whichever comes first, and takes no card. Move the job that holds a slot longest to runs-on: skipbox and watch the queue on the next busy afternoon.

Updated November 14, 2026