40% of GitHub Pull Requests Now Start With an Agent: Reading the 2026 Octoverse Numbers

GitHub published Octoverse 2026 on October 28, and the number that matters most is not the developer count. It is this: by September 2026, more than 40% of pull requests on GitHub started with an agent's first draft, up from 17% in March. In September alone that was 110 million pull requests, roughly six times March's volume. Twelve months of pushes reached 17.9 billion, more than 2024 and 2025 combined, and commits across public and private repositories hit 34.3 billion, more than three times where they stood two years ago. Merged pull requests more than tripled to 1.3 billion, an average of 3.5 million a day. What follows is the subset of the report that changes how you instrument your own pipeline, plus the scripts to check whether your repository behaves anything like the aggregate.

17.9 billion pushes in twelve months, more than 2024 and 2025 combined.

1. Read the definition before you read the number

GitHub counts three things that look alike and are not. A push is one send and may carry many commits. A commit is a snapshot. A contribution counts each push once regardless of how many commits it holds, which is why public contributions came in at 2.5 billion against 34.3 billion commits. If you benchmark your team against the headline, make sure you are comparing the same unit. Two more rows deserve attention because they describe automation rather than generation: GitHub Actions ran a job 1,440 times per second, which is 124 million runs a day and more than three times last year's total, and developers merged more than 30 million Dependabot pull requests, about double 2025's pace. The machinery around the code scaled at least as fast as the code.

# Recompute the pushes-vs-commits gap for one repository, using the same
# distinction Octoverse makes: a contribution counts a push once.
git rev-list --count HEAD                    # commits on the current branch
git rev-list --count --all                   # commits across all refs
git log --format='%H' --first-parent | wc -l # linear history size

# Pushes are not recoverable from a clone. They live on the server.
# Use the API and page carefully: 17.9 billion is the platform total, your
# repo is a rounding error, but the RATIO is what you want to compare.
gh api "repos/{owner}/{repo}/commits?per_page=100" --paginate \
  | jq '[.[] | .sha] | length'

# Sanity check before you trust any of this: how much of your history is
# merge commits versus real work?
git log --merges --oneline | wc -l
git log --no-merges --oneline | wc -l

2. Agent-started pull requests are larger, and by September they were faster

The report splits agent-started pull requests in a way you can replicate on your own data. About 87% of agent-started pull requests change multiple files, against 79% for pull requests without detected agent involvement. In February, 83% of agent-involved pull requests merged within two weeks, a touch behind the roughly 86% for the comparison group. By September the agent cohort was at 90% while the comparison group held near 86%. That crossover is the interesting part. For most of the past two years the standing objection was that agents produce code that sits in review forever, and the aggregate data says the opposite happened over seven months. The other lever developers reached for is review structure: stacked pull requests, previewed on July 30, had more than 264,000 developers using them by September, and AI-assisted code review plus GitHub Advanced Security both grew more than 90% year over year.

# Share of pull requests whose first draft came from an agent.
# Detection differs from GitHub's, so measure the delta over time, not the level.
import json, re
import urllib.request

OWNER, REPO = "your-org", "your-repo"
# Trailers and markers that agents commonly leave behind.
AGENT_MARKERS = re.compile(
    r"(co-authored-by:\s*.*(copilot|claude|codex|cursor|devin|agent))"
    r"|(generated-with:\s*\S+)"
    r"|(\bAI-Generated\b)",
    re.I,
)

def prs(page):
    url = (f"https://api.github.com/repos/{OWNER}/{REPO}/pulls"
           f"?state=all&per_page=100&page={page}")
    req = urllib.request.Request(url, headers={"Accept": "application/vnd.github+json",
                                               "User-Agent": "octoverse-check"})
    with urllib.request.urlopen(req, timeout=30) as r:
        return json.load(r)

total, agent = 0, 0
for page in range(1, 11):          # first 1,000 PRs; adjust to your volume
    batch = prs(page)
    if not batch:
        break
    for pr in batch:
        total += 1
        blob = (pr.get("title") or "") + "\n" + (pr.get("body") or "")
        if AGENT_MARKERS.search(blob):
            agent += 1

print(f"agent-started share: {agent}/{total} = {agent / max(total, 1):.1%}")

3. The eight-times-commits claim is correlation, and it is loud

Among repositories created in 2026, the average repo carrying an agent configuration file logged eight times as many commits as the average new repo without one. Read that as a signal, not a causal claim. A repository that commits an AGENTS.md on day one is a repository whose owner already intended to run agents, so intent is doing a large share of the work in that ratio. The honest use of the number is comparing your own repo across two periods, not comparing your repo to a stranger's. Adjacent context: 55% of GitHub Copilot's monthly active users now use agentic features, up from 35% a year ago, and the most hands-off mode grew fastest — Copilot cloud agent, where you assign a task and walk away, was up 230% year over year against 85% for agent chat. Developers still ask questions, and increasingly they hand over whole tasks.

# Do agent-started PRs touch more files? Octoverse reports 87% vs 79%.
# Pull the file count per PR and split the two cohorts.
import json, statistics, urllib.request
from concurrent.futures import ThreadPoolExecutor

OWNER, REPO = "your-org", "your-repo"

def get(path):
    req = urllib.request.Request("https://api.github.com" + path,
                                 headers={"Accept": "application/vnd.github+json",
                                          "User-Agent": "octoverse-check"})
    with urllib.request.urlopen(req, timeout=30) as r:
        return json.load(r)

def files_for(pr_number):
    return len(get(f"/repos/{OWNER}/{REPO}/pulls/{pr_number}/files?per_page=100"))

numbers = [pr["number"] for pr in get(f"/repos/{OWNER}/{REPO}/pulls?state=closed&per_page=50")]

with ThreadPoolExecutor(max_workers=5) as pool:
    counts = list(pool.map(files_for, numbers))

multi = sum(1 for c in counts if c > 1) / max(len(counts), 1)
print(f"multi-file share: {multi:.1%}   median files: {statistics.median(counts)}")

# A five-point move in either direction across two months is worth a look.
# A one-point move is noise on a sample of fifty.

4. Multi-model is the default and the routing is being automated

In September, 61% of GitHub Copilot users who selected a model themselves used more than one model across their sessions, up from 50% four months earlier. Paid plans touched 29 distinct models in May and 47 in September, and no single model carried more than 25% of requests that month. Of every 100 developer-selected requests, 38 went to general-purpose models, 37 to deep-reasoning-and-planning models and 25 to fast, lightweight ones. Sixty-three percent of paying developers used auto model selection at least once. Model orchestration, previewed as Project HydraFusion, routed almost 60,000 sessions and is now generally available as GitHub Copilot Fusion. The practical takeaway: if your harness still hardcodes a single model with a single set of sampling parameters, you are now the outlier in this dataset, and the cost of that hardcoding shows up as a bill rather than an incident.

# Model diversity inside your own agent fleet: which models actually carry
# your traffic, and what share does the top one hold?
# Point this at whatever gateway or proxy log you already keep.
import json
from collections import Counter

MODEL_KEYS = ("model", "model_name", "deployment")

def iter_requests(path):
    with open(path, encoding="utf-8") as fh:
        for line in fh:
            line = line.strip()
            if line:
                yield json.loads(line)

counts, sessions = Counter(), {}
for req in iter_requests("gateway.jsonl"):
    payload = req.get("request") or req
    model = next((payload[k] for k in MODEL_KEYS if payload.get(k)), "unknown")
    counts[model] += 1
    sessions.setdefault(req.get("session_id"), set()).add(model)

total = sum(counts.values()) or 1
top_model, top_hits = counts.most_common(1)[0]
multi = sum(1 for m in sessions.values() if len(m) > 1) / max(len(sessions), 1)

print(f"distinct models: {len(counts)}")
print(f"top model share: {top_hits / total:.1%}  ({top_model})")
print(f"multi-model sessions: {multi:.1%}")

# Compare against the Octoverse reference points: 47 models on paid plans,
# 61% multi-model users, no model above 25%. If your top model is at 90%,
# you do not have a routing problem yet — you have a concentration risk.

5. Language choice is being nudged by whoever picks the language

TypeScript held first place by contributors, Python second, JavaScript third. From September 2025 to September 2026, TypeScript added 3.62 million monthly contributors, Python 3.23 million and JavaScript 1.82 million; Rust doubled, the fastest percentage growth in the top ten. The sharper finding is where AI shows up. TypeScript, Python and Rust sit at roughly 40% to 44% of merged pull requests with detected AI involvement, while Java, C# and C++ land between about 21% and 34% — AI appears in more than one in five merged pull requests in every language shown. Among 2026 repositories carrying an agent signal, TypeScript was the primary language in 35%, against 24% of those without one. GitHub's reading is that developers gravitate toward languages where agent output is easier to verify. The uncomfortable implication is the reverse direction: when nobody specifies a language, the agent's own preference starts shaping the stack.

# Two-week merge rate, agent cohort versus everyone else.
# Octoverse: 83% vs 86% in February, 90% vs 86% by September.
from datetime import datetime, timezone
import json, urllib.request

OWNER, REPO = "your-org", "your-repo"

def get(path):
    req = urllib.request.Request("https://api.github.com" + path,
                                 headers={"Accept": "application/vnd.github+json",
                                          "User-Agent": "octoverse-check"})
    with urllib.request.urlopen(req, timeout=30) as r:
        return json.load(r)

def parse(ts):
    return datetime.fromisoformat(ts.replace("Z", "+00:00"))

def within_two_weeks(created, merged):
    return (parse(merged) - parse(created)).days <= 14

cohorts = {"agent": [0, 0], "other": [0, 0]}
for pr in get(f"/repos/{OWNER}/{REPO}/pulls?state=closed&per_page=100"):
    if not pr.get("merged_at"):
        continue                      # closed without merge is a different metric
    is_agent = "agent" in (pr.get("body") or "").lower()
    key = "agent" if is_agent else "other"
    cohorts[key][1] += 1
    cohorts[key][0] += within_two_weeks(pr["created_at"], pr["merged_at"])

for name, (hit, n) in cohorts.items():
    print(f"{name:<6} {hit}/{n} = {hit / max(n, 1):.1%} merged within two weeks")

# Also worth tracking and rarely tracked: merged-then-reverted within 7 days.
# Speed without that number is just velocity in one direction.

6. What to measure on Monday, and one reason to distrust the forecast

Three metrics are cheap to compute from your own repository and more actionable than any aggregate. First, the share of pull requests whose first draft came from an agent. Second, the median time from an agent-started pull request to merge. Third, review comments per 100 changed lines in agent versus human pull requests. Watch the third one closely: more pull requests merging faster with less review attention is not obviously progress, and the second number can improve while the third one rots. On forecasting, GitHub ran more than 40 models forward to 2031 and they no longer agree with each other — about half predict developer counts more than tripling, just under half predict doubling to tripling, and only three models expect anything under twofold growth. A spread that wide is itself the finding, and it argues for building the measurement before the forecast.