AI coding agents pushed GitHub's commit volume up 14x. Its infrastructure didn't keep pace.
Nine outages in May, ~88% availability in June, and Microsoft now routing overflow through AWS. The capacity-planning lesson goes well beyond GitHub.
The numbers behind AI coding agents' commit surge
AI coding agents have changed the shape of GitHub's traffic enough to put a hard number on it. In April 2026, GitHub COO Kyle Daigle confirmed the platform was processing 275 million commits a week, a pace that puts 2026 on track for roughly 14 billion commits for the year. That's a 14x jump from the 1 billion commits logged across all of 2025.
Claude Code's share of that traffic shows how fast the shift happened inside a single tool. It went from roughly 100,000 commits a week in September 2025 to 2.6 million a week six months later, a 25x increase, and on its own about 4.5% of all public commits on the platform. GitHub Actions tells the same story from a different angle: weekly compute minutes climbed from 500 million in 2023 to 1 billion in 2025, then hit 2.1 billion in a single week in early 2026.
Most companies running AI coding agents internally don't publish numbers like these, which is part of why GitHub's figures matter beyond GitHub. They're one of the only hard, public data points anyone has on how fast agent-driven commits are actually growing, as opposed to how fast survey respondents say they're adopting the tools.
None of that growth should, by itself, be a crisis. A platform built for hyperscale should absorb a 14x increase in raw activity spread across a year without much drama. What actually broke wasn't the volume. It was the shape underneath it, and that shape shift is coming for whatever Git host and CI system your own team runs, whether or not you ever push a commit to GitHub.
Nine outages in May, and a CTO who'd already admitted the SLA was broken
The reliability numbers are public, and they're blunt. GitHub logged nine service-degrading incidents in May 2026 and ten in April. Estimated availability for June sits around 88.4%, against the 'three nines' (99.9%) standard that GitHub's own CTO had already acknowledged the platform breached back in February and March.
For a service sitting in the critical path of deploys and CI pipelines, the more interesting failure isn't the outage itself. It's what happens around it when the traffic hitting that path isn't human. A person who hits a failed push checks the status page and waits. An agent that hits a failed push retries on whatever schedule its loop runs, without checking anything. Multiply that by however many agents were mid-task when an incident started, and a service-degrading event that would have been a minor annoyance for human traffic compounds into a queue a person still has to untangle once things recover.
Why Microsoft is routing GitHub's traffic through a competitor
On June 16, Microsoft confirmed it is routing a share of GitHub's traffic through Amazon Web Services, the company it competes with directly at nearly every layer, from raw compute to AI infrastructure. The stated reason was capacity: Azure's ongoing migration of GitHub's remaining workloads isn't moving fast enough to absorb the overflow on its own timeline, so Microsoft is buying time on a rival's infrastructure while that migration finishes.
Public reporting hasn't detailed exactly which layers are running on that borrowed capacity, and Microsoft has stayed measured on specifics. The direction of the admission is the story regardless of which layer it is. Companies route around short-term capacity gaps constantly. What's unusual is a company that sells cloud capacity for a living admitting, in public, that its own flagship developer platform outgrew its own cloud faster than the migration plan accounted for.
That's the detail worth taking from this if you're not GitHub and never will be. Even an organisation with that much cloud depth to draw on still had to reach for a rival's infrastructure as a stopgap. Most engineering teams don't have a second hyperscaler on speed dial.
Agents don't commit like humans. That's what capacity planning didn't model.
Capacity planning for developer platforms, GitHub's and most others', is built around a shape that's been stable for two decades: traffic peaks on weekday mornings and afternoons across whichever time zones are awake, dips overnight, and drops further on weekends. That shape isn't incidental. It's load-bearing. Maintenance windows, index rebuilds, and backups get scheduled into the troughs. Rate limits get sized against the peaks, on the assumption that there's headroom somewhere in the cycle to fall back on.
AI coding agents don't have a cycle. They don't take weekends, they don't slow down for lunch, and there's no 2 a.m. local time that applies to them, because they don't have a local time zone. An agent opens a pull request, watches CI run, and pushes a fix at the same pace at 3 a.m. on a Saturday as it does at 10 a.m. on a Tuesday. Run a handful of agents in parallel across a team, and the daily and weekly troughs that capacity planning quietly depends on start to shrink. Run a few dozen across an org the size of GitHub's customer base, and they can disappear.
“The agents didn't just add load. They removed the off-peak.”
That's a structurally different problem from more traffic needing more scale. A platform sized for twice its average load during the daily peak can usually absorb steady 50% growth spread evenly across the board, because the peak was already its stress test. It's much harder to absorb the loss of the trough that platform was quietly using to catch up, recompute, and clean house.
What this previews for your own CI and Git infrastructure
GitHub is a useful preview precisely because it's operated by one of the three companies with the deepest cloud capacity on the planet, and it still hit a wall fast enough to need a competitor's help. Most engineering teams running Claude Code, GitHub Copilot's coding agent, Cursor's background agents, or an in-house agent against their own Git host don't have that depth to fall back on. The same mismatch, human-shaped capacity planning meeting machine-shaped traffic, applies to internal webhook receivers, CI runner pools, build caches, and API rate limits. It just shows up as a stuck pipeline or a surprising CI bill instead of a public incident report, which makes it easier to miss until it's already expensive.
| Layer | Human-paced assumption | What agent traffic breaks |
|---|---|---|
| Maintenance windows | Scheduled overnight and weekends, in the trough | Trough shrinks or disappears; jobs compete with live traffic |
| Rate limits | Sized against a human's realistic peak request rate | A single agent token can sustain peak rate for hours, not minutes |
| CI runner autoscaling | Scales to demand, self-limiting because humans eventually stop pushing | Scales to whatever budget ceiling exists, because agent demand has none of its own |
| Webhook delivery | Bursty, clustered around business hours | Continuous, with agent retries compounding queue depth |
It doesn't take a fleet of autonomous agents to start feeling this. A background agent set loose overnight on a backlog of small fixes can open, test, and merge dozens of pull requests before anyone's at their desk, each one triggering its own CI run. A team that's simply gone heavy on AI-assisted commits, more pull requests per engineer, more CI runs per pull request, more re-runs triggered by an assistant instead of a person deciding it's worth the compute, hits a milder version of the same curve. The mechanism is identical even when the scale is a hundredth of GitHub's.
The checklist, before this becomes your outage
The fix Microsoft reached for, buy more capacity, faster, is the same fix every team reaches for first, and GitHub's own numbers show it running out of runway even for a hyperscaler. The more durable fix is to stop treating agent traffic as more of the same traffic, and start treating it as its own workload class with its own limits, the way you'd treat any other automated, bursty system rather than a slightly faster human.
A few changes are concrete enough to make this week, not this quarter.
- Tag agent and bot tokens distinctly from human ones at the authentication layer, not just by naming convention. You can't apply a different rate limit to traffic you can't identify.
- Give agent tokens their own concurrency and rate-limit tier, sized below a human's realistic peak, not above it. An agent that can sustain peak request rate for hours needs a tighter ceiling than a person ever did.
- Put a hard, budget-tied ceiling on CI runner autoscaling, separate from demand-based scaling. Demand from an agent loop has no natural ceiling of its own; your invoice will find one for you if your config doesn't.
- Check whether maintenance windows, backups, and batch jobs still have a quiet period to run in. If agent traffic has filled the overnight trough, schedule those jobs explicitly instead of assuming the gap is still there.
- Break out agent-originated traffic as its own line in whatever dashboard tracks commits, PRs, or API calls. A trend you can see coming is a capacity conversation. A trend you can't see is an incident.
policies:
- match:
token_type: human
limit: 100/min
burst: 200
- match:
token_type: agent
limit: 30/min
burst: 60
concurrency_cap: 4`token_type` is doing the real work in that policy. It's the one field that turns agent traffic from a vague worry into something a gateway can actually enforce against. Everything else on the list above is a variation on the same idea: decide, on purpose, what an agent is allowed to do to your infrastructure, instead of finding out from an incident report.
GitHub's outage numbers will probably improve once the Azure migration catches up to the traffic it's carrying. The underlying mismatch won't fix itself the same way, because it was never really about GitHub's infrastructure specifically. It's about every assumption a human-paced system makes once a meaningful share of its traffic stops being human-paced. Most engineering teams will meet that mismatch on their own Git host and CI pipeline before they read about it happening to someone else's.
Frequently asked questions
Related reading
AWS Emulator Passes 56.5% of Its Fidelity Tests and Ships Releases 90 Minutes Apart. Pin One Before CI Trusts It.
AWS's agent-built local emulator publishes its own failing tests. Here is what a fidelity score counts, why patch releases can change your results, and how to pin it in CI.
OpenAI Reports 948 Linux Privilege-Escalation Findings. The Number Is a Review Queue, Not Your Exposure.
OpenAI says an unreleased cyber model produced 948 Linux kernel privilege-escalation results for about $1.2M. Here is what that number measures, and what to check on your own fleet.
Android Developer Verification Is Live in Four Countries. It Checks Who You Are, Not What Your App Does.
Google began enforcing Android developer verification on 30 September in Brazil, Indonesia, Singapore and Thailand. The check covers publisher identity for seven stores, not app safety, and ADB bypasses it.