2.7 Million Pull Requests: What Agents Actually Merge

LinearB's 2026 AI engineering benchmarks cover 2.7 million pull requests, 83,000 developers, and 253 engineering organizations (LinearB, 2026). The most useful thing in that data is not how much faster AI makes developers but where the speed shows up and where it does not. Split developers by how heavily they use AI and the top band - AI on 75 percent or more of coding days - merged code at 2.3 times its June 2025 rate by May 2026, while developers using no AI stayed roughly flat. The same dataset offers a counterweight that is easy to miss: at elite organizations, fewer than 5 percent of pull requests come from autonomous agents, and agent-opened PRs merge at a clearly lower rate than human ones.

Merge rate is the metric; AI usage share is only the input

1. How the 2.3x Number Is Built

The banding has to be stated precisely or the number gets misread. Very high usage means AI on 75 percent or more of coding days, high means 50 percent or more, and moderate means 20 percent or more. Measured year over year for the same developers, the median improvement was 95.7 percent in the top band, 65.4 percent in the high band, and 24.4 percent in the moderate band, while developers using no AI declined 3.6 percent. Because a minority with outsized gains pulls the average up, the top band's collective output rose 134 percent (LinearB, 2026). The authors are explicit that this is correlation: heavier AI use tracks with a higher merge rate, it does not prove AI alone caused it. Establish that caveat first and the rest of the numbers hold up.

-- merge_rate_bands.sql - your own version of the 2.3x number
WITH dev_days AS (
  SELECT author_id,
         date_trunc('day', authored_at)                     AS day,
         COUNT(DISTINCT pr_id)                              AS prs,
         COUNT(DISTINCT pr_id) FILTER (WHERE ai_used)        AS prs_with_ai
  FROM pr_authors
  GROUP BY 1, 2
), banded AS (
  SELECT author_id,
         CASE WHEN AVG(prs_with_ai::numeric / prs) >= 0.75 THEN 'very_high'
              WHEN AVG(prs_with_ai::numeric / prs) >= 0.50 THEN 'high'
              WHEN AVG(prs_with_ai::numeric / prs) >= 0.20 THEN 'moderate'
              ELSE 'none' END                               AS ai_band
  FROM dev_days GROUP BY 1
)
SELECT b.ai_band,
       COUNT(DISTINCT p.id)                                   AS merged_prs,
       ROUND(COUNT(DISTINCT p.id)::numeric / COUNT(DISTINCT b.author_id), 1) AS prs_per_dev
FROM banded b JOIN pull_requests p ON p.author_id = b.author_id AND p.merged_at IS NOT NULL
WHERE p.merged_at >= CURRENT_DATE - INTERVAL '30 days'
GROUP BY 1 ORDER BY 1;

-- LinearB's 2026 benchmarks put the very high band (AI on 75%+ of coding
-- days) at 2.3x its June 2025 merge rate, and the no-AI group slightly down.

Unclaimed agent pull requests tend to sit unmerged

2. Adoption Is Not Leverage

Everyone using AI and AI actually changing delivery are two different statements. At organizations in the top 10 percent, 54 percent of pull requests involve AI coding assistance and 45 percent of merged code lines are written by AI, yet only 4.7 percent of pull requests come from autonomous agents. AI code review sits at 57 percent, against 26 percent at the top 30 percent and 8 percent at the top 60 percent (LinearB, 2026). The value of these figures is that they supply comparable percentile lines. Most teams can already report a respectable AI usage share; what separates leaders is the share of work that gets AI review, and that gap is sevenfold.

# ownership.py - an agent PR with no owner is not a contribution
AGENT_ACTORS = ("codex-bot", "claude-agent", "cursor-agent")

def gate(pr):
    if pr["author"] not in AGENT_ACTORS:
        return {"ok": True}
    if not pr["requested_reviewers"]:                 # needs a human owner
        return {"ok": False, "action": "assign an engineer before CI spend"}
    if pr["changed_lines"] > 800 and not pr["linked_tests"]:
        return {"ok": False, "action": "require linked tests"}
    return {"ok": True, "label": "agent-assisted"}

# The benchmark explains the 79% vs 92% gap by ownership rather than
# capability: an agent PR nobody owns tends to sit unmerged.

AI code review is the fastest available gain in the data

3. Autonomous Agents Are Not the Shortcut

On autonomous agents the data is colder than the marketing. At top-decile organizations, 79 percent of agent-opened pull requests merge within 30 days, against 92 percent for human-only pull requests. At the top 60 percent of organizations, agentic yield falls to 37 percent (LinearB, 2026). LinearB explains the gap through ownership rather than capability: when an agent opens a pull request that no engineer owns, it tends to sit unmerged. Agents are easy to run at the edges of real work; entering the delivery mainline requires someone accountable for the outcome. That is also why autonomous PR share stays below 5 percent even among the strongest teams. It is not that they cannot use agents. It is that they have not yet found a way to make an agent own the result.

# ai_review_routing.py - attach AI review where the baseline is weakest
THRESHOLDS = {
    "needs_focus": 0.08,    # bottom half: 8% of PRs get AI review
    "good": 0.26,           # top 30%
    "elite": 0.57,          # top 10%
}

def should_ai_review(pr, current_share):
    if current_share >= THRESHOLDS["elite"]:
        return True
    # cheapest wins first: large or cross-module diffs benefit most
    return pr["changed_lines"] > 200 or pr["modules_touched"] > 1

# In LinearB's data, AI-reviewed PRs merge at the highest rate of any
# category, up to five points above the all-PR baseline.

4. The Fastest Available Gain: AI Code Review

If you take exactly one thing from this dataset, take AI code review. Pull requests with an AI review attached merge at the highest rate of any category, up to five percentage points above the all-PR baseline and up to seven points above human-only pull requests, with the largest lift where the baseline is weakest (LinearB, 2026). It also asks the least of your process: no new merge permissions, no branch strategy change, just a machine opinion on every diff before a human reads it. For teams that bought AI coding tools but left the review process untouched, this is the half of the budget most often left on the table.

-- token_cost.sql - put the 481 dollar figure in context
WITH monthly AS (
  SELECT developer_id,
         date_trunc('month', ts)          AS month,
         SUM(cost_usd)                    AS ai_cost_usd
  FROM llm_usage
  WHERE ts >= CURRENT_DATE - INTERVAL '3 months'
  GROUP BY 1, 2
), ranked AS (
  SELECT month, developer_id, ai_cost_usd,
         PERCENT_RANK() OVER (PARTITION BY month ORDER BY ai_cost_usd) AS pct
  FROM monthly
)
SELECT month,
       ROUND(AVG(ai_cost_usd), 2)                                        AS avg_usd,
       ROUND(MAX(ai_cost_usd) FILTER (WHERE pct >= 0.90), 2)             AS cost_at_p90
FROM ranked GROUP BY 1 ORDER BY 1;

-- LinearB reports 481 dollars per developer per month at the 90th
-- percentile of spend, still under 4% of a fully loaded developer cost.
-- Measure your own p90 before arguing about the average.

5. Cost and Review: Put p90 and Time-to-First-Review on One Page

Two figures are habitually ignored. The first is cost: at the 90th percentile of AI spend, the bill runs about 481 dollars per developer per month, still under 4 percent of a fully loaded developer's cost (LinearB, 2026). The right use of that number is not reassurance but a reminder to measure your own p90 before debating the average, because averages hide a handful of runaway callers. The second is time: how well agent pull requests land correlates strongly with how long they wait for a first review, and most teams have never looked at that metric in isolation. The five examples below re-derive merge rate by usage band (example 1), require a human owner on agent PRs (example 2), route AI review to the weakest baseline (example 3), compute your own p90 cost (example 4), and break agent PR yield down by 30-day window and time-to-first-review (example 5). Do that and you can answer whether AI made your team faster using numbers from your own repository.

-- agent_yield.sql - why agent PRs do or do not land in 30 days
SELECT CASE WHEN age_in_days > 30 THEN 'over_30d' ELSE 'within_30d' END AS window,
       COUNT(*)                                                       AS prs,
       ROUND(100.0 * COUNT(*) FILTER (WHERE merged) / COUNT(*), 1)     AS merge_rate_pct,
       ROUND(AVG(reviewer_count), 2)                                   AS avg_reviewers,
       ROUND(AVG(hours_to_first_review), 1)                            AS hours_to_first_review
FROM agent_pull_requests
GROUP BY 1;

-- LinearB: 79% of agent PRs merge within 30 days at top-decile orgs versus
-- 92% for human-only PRs, and only 37% at the top 60%. Time-to-first-review
-- is the lever most teams have never looked at.