On July 30, Google published Chrome’s AI-era security report card: Chrome 149 and 150 together fixed 1,072 security bugs, surpassing the total number fixed across the prior 23 milestones combined. The same post laid out a timeline that is just as striking. In May, tools integrated into Chrome’s CI blocked more than 20 vulnerabilities before they reached production, including a critical S1+ issue. By March, external bug reports through the Vulnerability Reward Program had already exceeded all of 2025, prompting rule changes to the VRP. And to the obvious worry — isn’t a bug surge bad? — Google’s answer is blunt: an increase in bugs found and fixed is not a sign of failure.
1,072 Bugs: Two Milestones Surpass the Prior 23 Combined
Put the number in context first. Bug “output” is a function of the ability to find bugs, not just of code quality. When the tool doing the finding changes from human review to AI agents, the amount of code you can sweep per unit of time changes completely, and fix counts explode with it. Google presents the report card as a health metric: more bugs flowing through the pipeline means defects that sat silently for years have finally entered a workable queue. The real risk was never fixing too much; it was nobody looking.
From Fuzzing to Big Sleep: The AI Toolchain Finding Bugs
The toolchain took three years to stack up. In 2023 it was AI-assisted fuzzing. In 2024, Project Zero introduced Naptime, letting an LLM behave like a researcher and probe for abnormal behavior in loops; its successor Big Sleep, built with DeepMind, reported its first real-world find that October — an exploitable stack buffer underflow in SQLite, fixed the same day before it ever reached a release. In 2025 Big Sleep kept surfacing real vulnerabilities in V8 and the graphics stack. And in early 2026, a Gemini-based agent harness began scanning the entire Chrome codebase, with one notable result: a sandbox escape that had quietly survived in the code for more than 13 years. Old, deep, and silent defects like that are exactly the corners traditional fuzzing struggles to reach.
AI Doesn’t Just Find Bugs Now, It Fixes Them
The fixing side has become a multi-agent workflow too: a fixing agent writes the patch, a critic agent mimicking code review picks it apart, and dedicated agents write tests — together saving what Google describes as up to weeks of developer time. Upstream, automated triage — filtering reports, reproducing them, enriching metadata, and routing — replaced a manual process that took 5 to 30-plus minutes per report, saving hundreds of engineer hours per month. That intake side explains the VRP numbers: when external reports exceed an entire prior year by March, the queue only stays workable if triage is automated. Once finding scales, the bottleneck always moves to triage and repair; this time Google automated both ends of the pipe.
Guardrails, Cadence, and Memory Safety
The guardrails are specific. AI analyzes source code only at rest, on disk, never running; analysis happens on air-gapped machines, network requests are intercepted against strict allowlists, and subagents cannot modify the system or leave designated directories. The release cadence is changing with the workload: major milestones move to a two-week cycle with weekly security updates, plus a pilot of two security releases per week. Dynamic patching — replacing background processes without a restart — is still under research, though Chrome 150 already added automatic restarts for windowless macOS background processes. Memory safety advances on two tracks: MiraclePtr and MiracleObject keep expanding, targeting up to 90% of use-after-free vulnerabilities on the GPU main thread; 97% of first-party code now compiles under strict unsafe-buffer warnings; and Rust adoption covers the highest bug-density modules. The ecosystem side matters too: Chrome carries 2,300-plus third-party dependencies, roughly 1,700 of which ship to users. Google donated $12.5 million to Alpha-Omega and co-founded the Akrites project to push the same hygiene upstream.
What Developers Should Take Away
Four things. First, treat “AI found a mountain of bugs” as the normal operating condition, not a crisis — budget for review and repair, not for denial. Second, the real time savings live in triage and test automation, not in bug discovery; 5 to 30 minutes of manual handling per report is where the money bleeds. Third, dependencies are your attack surface: Chrome’s 1,700 shipped third-party dependencies is a mirror for supply-chain risk in any large project, and Google’s answer — funding Alpha-Omega and co-founding Akrites — is one worth copying at smaller scale. Fourth, a two-week milestone cadence with weekly security updates means upgrade testing has to become a continuous process, not a quarterly chore.
Sources
- Chrome, stronger with every update — Google
- Using Large Language Models to Catch Vulnerabilities — Google Project Zero
AI-assisted summary compiled from the sources above, reviewed by a human before publishing.