In September 2026, AI agents drafted 40 percent of all pull requests on GitHub. In March, that number was 17 percent. That’s a 135 percent jump in six months — a rate of adoption that, if it holds, puts agents writing the majority of code under review by early 2027. GitHub made that announcement Wednesday as it launched Copilot Fusion into general availability at its annual Universe conference, and while the company framed it as a milestone in developer productivity, the more important story is hiding in the denominator: who is reviewing all this AI-generated code?
The answer, increasingly, is another AI system.
What Copilot Fusion Actually Does
Fusion is not a single model. It is a routing and orchestration layer that dispatches each coding task to one or more of the models in its pool — currently a mix of Claude Opus 5.5, Claude Sonnet 5.5, GPT-6 Astra, and GPT-6 Sol — choosing execution patterns on the fly. A simple task goes to one model (Single). A harder task starts cheap, then escalates if the first attempt fails a quality check (Cascade). The most demanding tasks get a draft from one model, a critique from another, and a revision from the first (Critique). Developers pick an effort level — Standard, High, or Max — and Fusion decides the rest.
The benchmark numbers are real. On the Artificial Analysis Coding Agent Index v2.0, Fusion Max scored 60 — within two points of Claude Code running Opus 5.5 Max, which scored 62. On Terminal-Bench 4.0, Fusion outscored every competitor at 71. The average cost per task was $5.59 for Fusion Max versus $11.42 for the Claude Code/Opus 5.5 configuration, a 51 percent savings. Fusion completed tasks 40 percent faster and used roughly half the tokens — 7.2 million per task versus approximately 14.4 million for the Claude configuration.
These are not marginal improvements. A system that delivers near-frontier coding quality at half the per-task cost and 40 percent less latency will be used far more than the system it replaced, simply because the economics make the barrier to agent invocation nearly zero.
The Cost Math: Three Deployment Scenarios
Here is what Fusion actually costs across different deployment scales, using the $5.59 average per task with the 30 percent limited-time discount factored out (real sustained cost):
Small team (5 engineers, 20 agent tasks per developer per month): 100 tasks/month × $5.59 = $559/month in AI compute, plus $10/user standalone = $50/month in base subscriptions. Total: ~$609/month, or $122/developer. Compare this to paying $11.42 per task with a Claude Code setup: $2,284 in compute plus $50 base = $2,334/month, or $467/developer. Fusion wins by $345 per developer per month at this volume.
Mid-size team (50 engineers, 50 agent tasks per developer per month): 2,500 tasks × $5.59 = $13,975/month compute + $500 base = $14,475/month. The equivalent Claude Code configuration: $28,550/month. Annual savings: ~$170,000. This is the range where Fusion becomes an unambiguous budget decision, not just an experiment.
Enterprise (500 engineers, 100 agent tasks per developer per month): 50,000 tasks × $5.59 = $279,500/month. At Claude Code rates: $571,000/month. The difference is $3.5 million per year. Even if you factor in the internal tooling, training, and governance overhead of Fusion adoption — call it $500,000 annually — the net savings justify a dedicated team to manage it.
The breakeven point for switching from a direct-API Claude Code setup to Fusion is roughly 15 agent tasks per developer per month. Below that threshold, the simpler setup probably wins on operational overhead. Above it, Fusion’s economics are hard to argue with.
The Decision Framework
Stick with your current setup if: Your team runs fewer than 10 agent coding tasks per developer per month, your data residency requirements prohibit multi-model routing (Fusion touches multiple providers in a single task), or you need deterministic model selection for audit trails — Fusion’s routing is logged but not always predictable in advance.
Move to Fusion Standard if: Your team is between 10 and 30 agent tasks per developer per month, you’re on an existing Copilot subscription, and your workload is primarily greenfield code or isolated fixes. The cascade routing at Standard level handles about 70 percent of everyday development work effectively.
Move to Fusion Max if: You’re above 30 agent tasks per developer per month, your codebase involves complex multi-file refactors or legacy systems where the Critique pattern (model-vs-model review) adds real quality, or you need Terminal-Bench-class accuracy for infrastructure-touching code. The jump from Standard to Max adds roughly $2–3 per task at current prices.
Keep humans for: Security-critical code paths, proprietary architecture decisions, and any component where the reasoning process matters as much as the output. Fusion produces no audit trail of why it chose a particular approach — only what it produced. For regulated industries, that distinction matters legally.
The Contrarian Take Nobody’s Running
Most coverage of the 40-percent-agent-PR figure treats it as a productivity milestone. The more likely read is that it’s the earliest visible symptom of a review quality crisis.
GitHub simultaneously launched Copilot Code Review Max, which it claims achieved the highest F1 score on ReviewBench for high-severity issues. The company has not published the underlying score breakdowns. That matters because we now have a situation where AI systems draft code and AI systems review that same code, while GitHub’s data shows 225 million developers are on the platform — but not how many of them are actively reviewing AI-written PRs rather than approving them after a glance.
The number that deserves scrutiny isn’t 40 percent. It’s 7.4 billion code commits in September 2026, five times the level of a year earlier. GitHub added 4 million CPU cores, 160 petabytes of high-speed storage, and 50 terabits per second of network capacity during 2026 to absorb this. That infrastructure investment — substantial enough to move the needle at Microsoft’s scale — was built to handle a volume of commits that is, by definition, too large for humans to review line by line.
Software teams have always operated with incomplete review coverage. The difference is that previously, the cost of generating code was high enough to create natural throttling. When code costs nearly nothing to produce, the constraint moves to review — and if review is also automated, the real quality signal left is production incidents. That’s a worse place to catch bugs than code review.
The honest implication: if your team’s code review process works because engineers are reading every line, that process is already broken at 40 percent agent adoption, regardless of which tool generated the code. The fix isn’t to slow down Fusion adoption. It’s to accept that review must become statistical — coverage-based, not exhaustive — and to invest in the testing and monitoring infrastructure that makes statistical coverage safe.
What This Means for Engineering Organizations
GitHub’s data shows a structural shift, not a trend. A structural shift in how software is produced changes the economics of every company that sells development capacity: consulting firms billing on time and materials, SaaS companies pricing by engineer headcount, staffing agencies, and enterprise software vendors whose competitive moat is a large codebase few others understand.
The unit of software delivery is no longer the engineer — it’s the task. Fusion prices tasks at $5.59. The cost of a human engineer, fully loaded, is roughly $150,000 to $250,000 per year depending on seniority and location. If a human engineer completes an average of 800 meaningful coding tasks per year (a reasonable estimate for senior developers including meetings, planning, and review time), the implied cost per task is $187 to $312. Fusion at $5.59 per task is 33 to 56 times cheaper per unit of output — not for every task, and not for tasks requiring genuine judgment, but for an increasingly large share of the work that actually ships.
Engineering managers who read that sentence and conclude “we should cut headcount” are drawing the wrong lesson. The organizations that extract the most value from Fusion will be the ones that redirect human attention upward — toward system architecture, security review, product judgment, and the testing harness that lets statistical review work safely — rather than the ones that treat agent output as a drop-in replacement for human output and reduce supervision accordingly.
A Dated Action Checklist
By November 3: Run a query on your GitHub org to pull the last 90 days of PR data. Look for the Copilot Workspace or Copilot Automations label in PR metadata. If you don’t know what percentage of your team’s PRs are already agent-drafted, you’re behind the curve — you need that baseline before deciding how to proceed.
By November 17: Run Copilot Fusion Max on your five most complex outstanding issues — the ones your team has been delaying because they’re messy. Score the output against what a senior engineer would have produced. The gap (or lack of one) tells you where your quality ceiling actually sits.
By December 1: Review your enterprise Copilot admin settings and disable any models in the Fusion pool that conflict with your data compliance requirements. Fusion routes across providers; if your MSA prohibits sending code to specific vendors, you need to configure that before your engineers start using Fusion at scale.
By January 2027: GitHub’s multi-region Azure deployment is scheduled to complete in early 2027. Revisit latency benchmarks for non-US teams at that point — early adopters in Europe and APAC report meaningful delays in the current single-region configuration that will likely resolve then.
Q1 2027 onward: Begin tracking code quality metrics separately for agent-drafted and human-drafted PRs. Bug rates, security incidents, and test coverage don’t lie. If agent-drafted code performs worse at your organization, you’ll need that data to calibrate how much oversight to apply. If it performs the same or better, you’ll have the evidence to accelerate adoption confidently.
The practical bottom line: Copilot Fusion is the first coding agent system where the cost-per-task economics genuinely compete with human labor across a wide range of routine development work. The question isn’t whether to use it. It’s whether your organization has the testing infrastructure and review culture to catch what it gets wrong — because at 40 percent of pull requests and rising, the agent output arriving in your codebase isn’t a pilot anymore. It’s your production environment.
