How AI is reshaping Linux kernel security and infrastructure

The Linux kernel has entered a new era. Around early 2026, something changed so dramatically that long-term graphs of bugs and security reports now show a clear inflection point. That turning point isn’t a new programming language or a change in leadership—it’s AI.

A scary graph that tells a story

Imagine a graph showing security vulnerabilities (CVEs) per kernel release. For years, it’s relatively stable. Then, around Linux 6.19 in February 2026, the line suddenly spikes, more than tripling per release. These aren’t just vulnerabilities being discovered; they’re also being fixed. Still, the jump is so sharp that it’s hard to ignore.

This data comes from long-time kernel maintainers and paints the moment as a likely historical turning point—not only for the Linux kernel, but for how the entire software industry finds and fixes bugs.

Why the kernel suddenly has so many CVEs

To understand the spike, it helps to know how the Linux kernel handles vulnerabilities. In 2024, the kernel project became its own CVE Numbering Authority (CNA). That means the project itself assigns CVE IDs to its own security issues, similar to projects like Curl and Python.

The reason was simple: external CVE handling had become messy. Some bugs were misclassified, some were overhyped, and others were inconsistently labeled. By taking control, the kernel team could be more consistent and transparent.

Importantly, the kernel is extremely liberal in what it considers a security issue. Because the kernel has deep access to your system, almost any crash can be treated as a denial-of-service vulnerability. As a result, many bugs are given CVEs by design. This explains a gradual rise in CVEs over time—but not the huge spike in 2026.

The real inflection point: AI-assisted security work

So what actually changed around 2026? The big shift is how capable AI tools became in the hands of skilled security researchers and kernel developers.

Early AI coding tools were noisy and unreliable. They generated false positives, hallucinated vulnerabilities, and spammed maintainers with low-quality reports. But by early 2026, these tools had matured enough that, when used by people who actually understand security and kernel internals, they became powerful amplifiers.

AI still isn’t at the point where a random person with no background in security can press a button and reliably find critical kernel bugs. But for experts who know how to drive these tools, the effect is dramatic: more real vulnerabilities found, faster analysis, and a higher rate of CVE-worthy issues being uncovered.

Two graphs, two very different stories

Alongside the CVE spike, another graph tells the other half of the story: the number of new bugs being introduced into the kernel is actually dropping. Over time, the rate of bug introduction has been trending downward, but around the same inflection point, that decline becomes much steeper.

If you only look at the CVE-per-release graph, it looks like the kernel is getting less secure. But when you combine it with the data on new bugs, a different picture emerges: the kernel’s existing bug pool is being drained faster, while fewer new issues are being added. AI-assisted review and analysis seem to be helping uncover long-standing problems that had quietly lived in the codebase for years.

When AI floods maintainers with duplicate reports

AI’s impact isn’t all positive. One growing issue is duplication of security reports. Here’s how it happens:

Someone finds a real security issue using AI, reports it privately (as is standard for serious vulnerabilities), and maintainers start working on it. Then another person, using a similar AI-assisted workflow, finds the same bug. And another. And another. Since these bugs aren’t public yet, the AI tools have no way to know they’re duplicates.

This problem has always existed with human security researchers, but AI makes it much easier to become a “competing” security analyst at scale. Kernel maintainers can end up juggling multiple private reports about the same issue, all from different people, all wanting attention.

Some people even try to have AI agents directly interact with maintainers. The kernel community has pushed back hard on this: they don’t want to talk to your bot. If you use AI to find a bug, you’re expected to understand it yourself and explain it as a human, not outsource the conversation to an LLM.

Overwhelmed subsystems and the death of old hardware drivers

The influx of real, AI-augmented reports has another side effect: maintainer burnout. Subsystems like networking, which attract a lot of attention, are particularly under pressure. More reports mean more triage, more patches, more reviews, and more mental load.

One visible outcome is the removal of old hardware drivers from the kernel. AI tools love untouched, dusty corners of the codebase—drivers that haven’t been touched in a decade, full of bit rot and outdated patterns. These are fertile ground for vulnerabilities.

But many of these drivers support hardware that is 30+ years old, which practically nobody uses with modern kernels. Rather than spend precious maintainer time cleaning up and securing code for hardware that’s effectively dead in the real world, maintainers are increasingly choosing to drop those drivers entirely.

It’s a pragmatic move: remove code that only creates maintenance and security burden, without real user benefit. AI is helping highlight where the rot is—but also forcing tough decisions about what’s worth saving.

Why the kernel is wary of AI-generated code

While AI is proving useful for finding bugs, there’s much more caution around using AI to write kernel code or drivers outright. The Linux kernel is critical infrastructure for the modern world. Stability and security matter far more than raw speed of development or sheer volume of features.

Yes, AI can churn out huge amounts of code quickly. But the kernel community’s priority is correctness, maintainability, and long-term reliability. A flood of AI-generated code that’s hard to audit or reason about would be a net negative, even if it looks impressive in the short term.

This is a broader theme across software development: moving fast is only good if you can still keep the system safe, understandable, and maintainable. Some developers are already experimenting with running powerful AI models locally for more controlled workflows, similar to what guides like running AI locally instead of relying on cloud tools aim to enable.

AI crawlers and the hidden infrastructure tax

Beyond code and bugs, AI is also reshaping the Linux ecosystem at the infrastructure level. Kernel.org and related services are prime targets for AI crawlers, which scrape massive amounts of data to feed training pipelines.

Why is the kernel so attractive to these crawlers?

• Linux development happens almost entirely in the open.

• Git repositories, mailing list archives (like LKML), and discussions are all publicly accessible.

• The project has 30+ years of high-quality, human-written code and conversations, much of it from before modern LLMs existed.

For AI companies, that makes the kernel’s history a goldmine: clean, rich, pre-AI training data. There’s also concern in the community that training models on their own outputs over and over (AI-on-AI) might act like a kind of “digital prion disease,” slowly degrading quality. That makes pristine, human-only datasets even more valuable.

When everything is clonable, scrapers go wild

The kernel community has always embraced openness: everything is clonable. You can grab the repositories, mirror the archives, and study decades of development history. That openness is a feature, not a bug.

But scrapers don’t behave like thoughtful humans. Instead of cloning repositories efficiently, many crawlers hammer web interfaces and generate billions of requests for individual commits, patches, and diffs. With tools like cgit exposing a huge space of valid URLs—including diffs between arbitrary commits—the number of potential URLs explodes into the quadrillions.

In theory, a well-behaved crawler would just do a simple git clone and be done. In practice, many don’t, and the result is a constant barrage of redundant traffic that mostly fetches the same data over and over again.

From IP bans to swarms of residential proxies

At first, kernel.org tried to fight back the simple way: blocking abusive IPs. It was easy to spot a single IP trying to fetch every commit from an abandoned fork. Those could be banned without hurting real users.

Then crawlers started distributing their traffic across entire subnets, and later across huge pools of residential and mobile IPs. Each IP would make only a handful of requests and then disappear. By the time you identified it as a bot, it was gone—and adding it to a blocklist just bloated firewall rules for no real gain.

This is tied to the rise of proxy SDK monetization: many consumer devices and apps quietly sell their users’ connections as exit points for proxy networks. Your smart TV or random mobile app might be part of a botnet-like swarm hitting open-source infrastructure without you ever knowing.

Enter Anubis: proof-of-work for humans and bots

To push back, kernel.org deployed a system called Anubis in front of key services like the LKML archives. Anubis works by asking the client (browser or bot) to perform a small amount of computation before accessing the site—essentially a proof-of-work challenge.

A typical challenge might be: find a string which, combined with your IP and a secret, produces a SHA-256 hash with a certain number of leading zeros. It’s trivial for real users on modern hardware, but it makes mass scraping more expensive.

Initially, this worked well: many bots gave up, and while some users were mildly annoyed, the trade-off was acceptable. But Anubis has difficulty levels, and as bots got stronger, they started solving higher levels too. Raising the difficulty slows down both bots and real users, and on low-end mobile devices, even modest difficulty can mean long waits just to load a page.

There’s a hard limit: make the challenge too hard and the site becomes unusable for humans, even if bots can still power through with enough compute.

98% of traffic is not real users

Today, git.kernel.org sees around 6 million daily requests for random commits. About two-thirds are blocked immediately by Anubis challenges. The remaining third solve the math and get through.

With generous assumptions, only about 2% of that traffic appears to be legitimate developer activity. The other 98% is likely scrapers and crawlers. The system still works and remains responsive, but the cost is real: around 16 CPU cores are effectively dedicated full-time to rendering commits for scrapers, with a baseline load that never drops below roughly 20%.

The Linux Foundation can afford this, but many smaller projects can’t. Think of independent GitLab instances, projects like GNOME and KDE, or community platforms like SourceHut and Codeberg. For them, this level of AI-driven scraping can be genuinely damaging.

Is this an AI bubble—or the new normal?

Looking at the graphs of kernel CVEs and bug trends, and the sheer volume of AI-driven traffic, it’s tempting to hope this is just a temporary bubble. Maybe the hype will fade, and things will return to normal.

But the data suggests that at least some of these changes are here to stay. AI tools are already delivering real value in security analysis and code review. As long as the cost of using them remains reasonable, it’s hard to imagine serious development work simply abandoning them.

We may see some deflation: the sillier, low-value uses of AI will likely die down. But for high-impact domains like kernel security, AI now looks more like a permanent part of the toolkit. The bigger question is how we adapt infrastructure, policies, and development practices to handle this new reality—without burning out maintainers or crushing smaller projects under the weight of AI crawlers.

This broader shift ties into ongoing debates about how far current AI can really go, and what its limits are. For example, some researchers argue that today’s systems, powerful as they are, may never reach true consciousness or understanding, as explored in pieces like why today’s AI may never be conscious. But regardless of those philosophical questions, the very practical impact on code, security, and infrastructure is already here.

The kernel will never be the same

The Linux kernel has always evolved, but the rise of AI marks a particularly sharp turn in its history. AI-assisted tools are uncovering more bugs than ever, pushing maintainers to clean up old code and drop dead weight. At the same time, AI crawlers are imposing a constant, mostly invisible tax on the infrastructure that keeps open-source development running.

Whether we look back at 2026 as the moment everything changed—or just an early step toward an even more AI-saturated future—one thing seems clear: the Linux kernel, and the ecosystem around it, will never operate the way it did before AI became a core part of the development and security landscape.