Few things feel more routine than a Chrome update notification. The little icon appears, the browser asks for a restart, and life goes on. For years, users have mostly treated these updates as background maintenance, sometimes waiting for a shiny new feature to justify all those restarts. But the truth is far more unsettling: some of those updates were fixing vulnerabilities that had been hiding in plain sight inside Chrome’s code for more than a decade.

Google has been quietly rewriting that story with artificial intelligence. The company built an AI agent using its Gemini models, gave it access to Chrome's codebase, and asked it to find the kinds of bugs that humans and older automated tools kept missing. The AI agent did not just find minor memory leaks. It found a sandbox escape flaw that allowed a compromised renderer process to trick Chrome into reading local files. That flaw had survived for more than 13 years.

How exactly is AI catching these bugs?

Chrome is one of the largest software projects on Earth. Chromium, the open-source base that Chrome is built on, contains tens of millions of lines of C++ code, and its security depends on a handful of deep architectural barriers. The most important is the sandbox, a containment system that tries to ensure even if an attacker gains control of a rendering process, that process cannot touch the operating system, the file system, or other tabs.

Finding a flaw that crosses that boundary is exceptionally difficult. Conventional testing, such as fuzzing, throws random or unexpected inputs at the browser to provoke crashes. Fuzzing has been enormously useful, and Google’s OSS-Fuzz project helped find tens of thousands of bugs across many open-source projects. But fuzzing tends to expose crashes in memory handling, not necessarily the subtle logical flaws that can turn a memory corruption bug into a full sandbox escape.

Google’s Gemini-based agent is different. It reads code the way a security engineer would, tracing paths, comparing assumptions, and looking for places where the browser’s internal rules are violated. It can reason about what a component is supposed to do, then check whether it can be tricked into doing something else. That approach has already proven itself, as the 13-year-old sandbox escape showed.

From detection to triage

Finding bugs is only one part of the problem. Security teams are also drowning in reports. Many bug trackers are filled with spam, duplicate reports, and vague descriptions that require hours of manual investigation. Google’s AI system now handles triage too. It automatically sorts incoming bug reports, filters spam, attempts to reproduce the issue, and attaches severity ratings. What used to take a human anywhere from five to thirty minutes per report is now done in the background by software.

After a bug is confirmed, the pipeline continues. A “fixing agent” generates candidate patches. A “critic agent” reviews those patches for regressions, style violations, or incomplete fixes. Test-writing agents then verify the fix across every platform Chrome supports, including Windows, macOS, Linux, Android, and ChromeOS. Only after all of this automated work is done does a human developer step in to review the final result. Google says this multi-agent workflow is saving hundreds of developer hours every month.

So does this actually mean more bugs are getting fixed?

Yes, and the numbers are almost hard to believe. In just two recent Chrome updates, versions 149 and 150, Google fixed 1,072 security bugs combined. That is more than the previous 23 updates put together. The jump does not mean Chrome somehow became dramatically less secure overnight. It means the AI-powered tooling is finally catching a backlog of old weaknesses that slipped through older review processes.

• 1,072 security bugs fixed in Chrome 149 and 150.
• More than the total fixed across the previous 23 releases.
• One critical bug was a sandbox escape present for over 13 years.
• AI handles triage, fix generation, review, and test-writing.

The patch gap race

Finding a bug is only the beginning. Once a fix exists, it still has to reach users. The period between those two events is known as the patch gap, and Google is trying hard to shrink it. The company is piloting two security releases per week instead of the usual one, giving attackers less time to reverse-engineer a fix and exploit vulnerable browsers before users update.

Google is also exploring something called dynamic patching. The idea is to apply a security fix to the running browser without requiring a full restart. If that technology matures, it could close the patch gap almost entirely, eliminating one of the biggest practical reasons people stay on vulnerable versions of Chrome. But dynamic patching is still experimental, and it will need to be tested carefully to avoid causing instability or opening new compatibility issues.

Why the old bugs matter

Bugs that survive for years are especially valuable to attackers. They are not the kind of issue that gets caught by a simple crash report. They sit quietly in code, waiting for the right combination of conditions to be abused. The 13-year-old sandbox escape is a perfect example. It required a compromised renderer to exploit, meaning it was probably never an initial entry point on its own. But in combination with another exploit, it could have turned a limited memory bug into a much more dangerous local file read.

This is why security researchers treat sandbox escapes with so much respect. Chrome’s entire security architecture assumes the renderer will eventually be compromised. The sandbox is the last line of defense that protects the rest of the system. A sandbox escape means an attacker who has already broken out of a web page can start interacting with the operating system, reading files, installing malware, or moving laterally across a network. That is the difference between a nasty browser bug and a full system compromise.

A broader shift in security engineering

Google’s AI-generated results are also reordering the company’s security priorities. Instead of waiting for external researchers to stumble across a bug and report it, Google can proactively search its own enormous codebase for the same patterns. That gives defenders an advantage they have rarely had in the history of software security.

It also raises the bar for what counts as a vulnerability. If AI can scan and understand code at scale, old assumptions about how long a bug can stay hidden start to break down. The same technology that helps Google defend Chrome can also be used by attackers, but the public release of these findings suggests the defensive side is currently seeing concrete results.

None of this means Chrome suddenly has more bugs than it did before. It means Google is finally catching the ones that were always there, faster than attackers can exploit them.

Source: Digital Trends News