Latest

Cybersecurity

The kernel receives more CVEs than it can fix

The kernel publishes dozens of CVEs a week and distributions cannot keep up. AWS already uses AI agents to triage them and the LPC discussed how to respond.

The kernel receives more CVEs than it can fix
The kernel receives more CVEs than it can fix

The Linux kernel assigns so many CVE identifiers that the bottleneck is no longer finding the flaws, but deciding which ones matter and applying them in time. The Linux Plumbers 2026 conference devoted a session to the problem, with two Amazon engineers explaining how the infrastructure behind its services responds. The conclusion was uncomfortable: the system works through the discipline of a few people, not through a process designed for this volume.

The case of CVE-2026-98432 illustrates the pace. A 9.8 flaw in the kernel's TCP code affected Ubuntu, RHEL and other distributions, with an exploit written by an Anthropic model and no immediate patch on some platforms. When a single flaw requires coordination between the kernel team, half a dozen distributions and thousands of administrators, the number of CVEs published per week stops being a statistic and becomes an operational burden.

The response that is gaining ground is not to hire more people. It is to automate the part of the work that consists of reading, classifying and prioritizing, leaving the final decision to humans. That division makes sense and also carries an obvious risk, because an agent that errs in discarding a flaw produces the same result as an unpatched flaw.

A tap that never closes

The kernel security team publishes advisories at a pace no distribution can match. Each CVE means identifying the affected version, writing the patch, backportingit to the stable branches and notifying consumers. Older branches add an extra layer, because what is fixed in the latest version has to travel backwards without breaking anything.

That work rests on a small group of people with a lot of judgment and little time. The Linux Plumbers session focused precisely on users rather than developers, a revealing choice. The problem is no longer detection, it is absorption by those who have to decide whether to update their fleet or assume the risk.

The number distributions deal with is brutal. A systems administrator sees dozens of advisories a week, many with no known exploitation, and has to distinguish the one that requires an urgent maintenance window from the one that can wait for the monthly cycle. That classification is done by a tired person at eleven at night, with a list that never stops growing.

AI steps in where it hurts

Amazon presented at the conference a system that uses agents to triage the kernel CVEs that affect its infrastructure. The idea is for a model to read the advisory, locate the affected code, check whether the system in question uses that path and propose a priority. What previously took an engineer half an hour is now resolved in seconds, with human review in doubtful cases.

The practical result shows up in response times. A flaw affecting an exposed service can be isolated and patched before anyone publishes an exploit, and one affecting a module nobody loads can be postponed without remorse. Fine-grained classification is precisely what was missing when the volume spiked.

The risk is proportional too. An agent that misreads an advisory can conclude that a path is not used when it is, and that erroneous conclusion travels into a decision not to patch. The difference from a human is that the error repeats a thousand times without tiring. Any deployment of this kind needs auditing of the discarded decisions, not just the accepted ones.

From CVE to patch in record time

The other half of the problem is the patch. Commercial distributions maintain old versions with backports, and there AI is also starting to be used to adapt fixes to branches that no longer receive the original code. It is mechanical and delicate work, ideal to automate and terrible to automate badly.

The ecosystem has a perverse incentive at this point. A flaw without a patch in a distribution with long-term support generates headlines, and the team handling it is usually smaller than the one reporting it. Companies that depend on those distributions do not always contribute to maintenance, even though they are the first to benefit from it existing.

In that context, automation is a way to buy time, not a solution. If 80% of advisories can be triaged automatically, the team frees up hours for serious cases. If the system is used as an excuse not to look, the same 80% becomes invisible debt that surfaces on the day of the incident.

The judgment of whoever decides not to patch

There is a question the session left hanging. When an agent decides that a CVE does not apply, who signs off on that decision? In a bank, the answer is a committee with names and surnames. In most companies, the answer is a closed ticket with no trace beyond an automatic comment.

That gap is the same one that already exists with vulnerability management tools, except that now it is filled faster. The difference is that a model can justify a decision with plausible and wrong reasoning, and that text ends up looking like an assessment when it was only an inference.

The recommendation coming out of the conference is reasonable and unglamorous. Record the decision, separate the discards from the pending items and review by sampling what the system decided to ignore. Without that discipline, automation does not reduce risk, it only makes it less visible.

The least visible part of the problem is the branches that no longer receive development. A distribution with ten years of support has to backport every fix to a tree that does not resemble the current one, and that work is done with fewer hands than made the original code.

That is where automation really helps, because adapting a patch to an old version is mechanical and verifiable. It is also where an error propagates to thousands of servers that nobody is going to review one by one. Human review remains the bottleneck and will continue to be.

What the kernel teaches everyone else

The kernel is an extreme case and that is why it serves as a warning. Any project that accumulates security advisories will end up in the same situation, from a cryptography library to a web framework. The difference is that the kernel has a huge community to respond and most projects do not.

With more than 40 million lines of code, nearly 20,000 changes per merge window and a stream of vulnerabilities that does not stop, the kernel has become the best laboratory for measuring how much security can be automated without losing control. What is learned here will be copied across the rest of free software in less time than it seems.

The question that remains is not whether agents are going to triage CVEs, because they already are. It is whether organizations will retain the ability to understand why they decided not to patch something, or whether in a year nobody will be able to explain why a particular server is still on a vulnerable version.

José Maldonado

Author

José Maldonado

Activist and blogger on technology, free software and blockchain.

The latest
From Huang to Botín, from Zara to Byron: corporate responsibility in global capitalism

Keep reading