On Wednesday, Google’s Chrome Security Team published a blog post with a number that should stop you mid-scroll: 1,072. That’s how many security vulnerabilities the company’s Gemini-powered AI pipeline fixed across two browser releases in June—Chrome 149 and Chrome 150. For context, the team patched 1,036 bugs across the preceding 23 stable releases combined. Two releases did more security work than the previous two years.

The headline writes itself: AI is a tireless code auditor, a force multiplier for overworked security teams, a digital exterminator that found a sandbox escape bug—CVE-2026-3545, CVSS 9.8—that had been hiding in Chrome’s codebase for 13 years. The celebratory framing is already congealing. It’s also the wrong story.

The 13-Year-Old Ghost Is a Capability Demo, Not a Cleanup

That 13-year-old sandbox escape is being treated as a testament to how deep the rot goes—proof that even Google’s flagship product was riddled with invisible cracks. But look at it from the other direction: a machine found a critical, remotely exploitable flaw that survived every human code review, every fuzzer, every bounty hunter, and every internal red team for more than a decade. That’s not a janitor mopping up a mess. That’s a new kind of sensor, one that sees things human eyes cannot.

And it’s not a general industry trend. Apple, which doesn’t run an equivalent AI bug-hunting pipeline, patched 482 bugs across its products so far in 2026—roughly on pace with last year, and roughly equal to the number it patched in 2015, according to an independent count cited by TechCrunch. The curve is flat. Google’s curve just went vertical. This isn’t the tide rising; it’s one company building a submarine.

The Asymmetry Nobody Wants to Discuss

Here’s the uncomfortable question the blog post doesn’t answer: what happens when that same AI pipeline is pointed at someone else’s code?

Google has no legal obligation to find vulnerabilities in, say, Firefox, or Edge, or the Linux kernel’s networking stack, or the firmware running on industrial control systems. But it has the tool to do so, and it has demonstrated that the tool works at a scale that makes traditional vulnerability research look quaint. A single human researcher might find a handful of critical bugs in a year. Google’s AI found over a thousand in a month—in its own browser. The same approach, applied to a competitor’s product, would produce a stockpile of zero-days that would make the NSO Group envious.

As one former vulnerability broker, now working incident response for a midsize bank, put it in a Slack message after the numbers dropped: “If I had that tool, I wouldn’t be patching bugs. I’d be selling them.”

Google, of course, would never do that. The company has a vulnerability disclosure policy, a bug bounty program, and a public commitment to making the internet safer. But capability creates temptation, and temptation has a way of finding justification. Maybe the bugs get used for “active defense”—a term that always means whatever the user wants it to mean. Maybe they get shared selectively with friendly governments under a classified arrangement. Maybe they just sit in a database, a quiet insurance policy against future regulatory threats. The point is that the capability exists, it is concentrated in one company, and the rest of us are taking its benevolence on faith.

The Uncomfortable Policy Conversation

For a right-of-center audience, the instinct here is to recoil from any suggestion of new regulation. And fair enough: the last thing we need is a hastily drafted bill that treats AI vulnerability research like nuclear enrichment. But the alternative—doing nothing while one firm amasses a superhuman ability to find and potentially exploit software flaws—isn’t a small-government position. It’s an abdication.

A more serious conversation would start with mandatory disclosure: if a company develops an AI system capable of finding vulnerabilities at industrial scale, it should be required to disclose the bugs it finds in widely used software within a fixed window, regardless of whether it owns the code. Not a ban on the research. Not a licensing regime. Just a rule that says the hunter can’t keep the trophies. That’s a market-structuring rule, not a command-and-control one, and it’s the kind of thing conservatives used to be good at designing before we decided all regulation is socialism.

Google’s blog post is titled “Chrome: Stronger with every update.” It’s a nice sentiment. But strength that depends on one company’s goodwill isn’t strength—it’s a monoculture with a single point of failure. The 1,072 bugs are fixed, and that’s genuinely good. The machine that found them is still running, and nobody outside Mountain View knows where it’s pointed next.

Sources