Artificial intelligence is transforming vulnerability research across major operating systems. Linux is one of the clearest examples of this effect, with a sharp rise in CVEs and patches that is putting pressure on its maintainers, but it’s not an isolated case. Microsoft already uses agents to hunt for bugs in Windows, AI has found vulnerabilities in FreeBSD and OpenBSD, and these techniques are also reaching the software underpinning Android, iOS, and macOS. The difference lies in how much gets published and how those findings are counted, a trend that echoes recent warnings that AI is finding vulnerabilities faster than teams can patch them.
AI hunting for vulnerabilities: the key facts
- Linux is approaching unprecedented CVE counts per release as automated analysis increases.
- Microsoft credits an agentic system with finding 16 vulnerabilities in Windows.
- AI-assisted research has confirmed dozens of bugs in FreeBSD.
- Android combines open-source code, fuzzing, and new automated-analysis techniques.
- iOS and macOS publish numerous kernel bug fixes, but Apple doesn’t attribute their discovery to AI in a comparable way.
This calls for care when interpreting the statistics. The fact that Linux publishes far more CVEs than another operating system doesn’t automatically prove it’s less secure.
Linux, Windows, Android, macOS, iOS, and the BSD systems have different development models, attack surfaces, and disclosure policies. Comparing CVE counts alone would be like comparing the number of faults found in two vehicles without knowing how many inspections each one has undergone.
AI is making it possible to multiply those inspections.
Linux Is the First to Show the Problem of Finding Too Much
For much of the Linux 6.x series, the number of CVEs fixed per release hovered around 500. That figure later passed 1,000, and Linux 7.2 went past 1,500. If the trend continues, Linux 7.3 could approach or exceed 2,000.
But there are two different phenomena behind those numbers.
On one hand, there’s the model Linux currently uses to assign CVE identifiers. On the other, automated tools and AI systems make it possible to continuously review parts of the kernel that previously could go a long time without detailed inspection.
An agent can analyze old drivers, rarely triggered error paths, subsystems used by relatively few teams, or code that barely changes.
That makes it possible to find real defects.
It also produces noise.
The kernel’s official documentation warns about AI-assisted reports that include speculative security consequences, reproduction steps that don’t work, or explanations far longer than necessary. Maintainers want reproducible issues, identified affected versions, and, when possible, a fix that has been compiled and tested.
The problem became especially clear during the development of Linux 7.3.
Networking maintainers Jakub Kicinski and Paolo Abeni had to handle 632 patches for net and another 648 for net-next. Kicinski estimated that between a third and half of the net-next patches looked like minor fixes, cleanups, or clarifications tied to AI tools.
A machine can generate the finding and propose the patch in seconds. A maintainer still has to understand it, verify it, and decide whether it deserves to go into Linux.
That’s where the new bottleneck is appearing.
Windows, FreeBSD, and Android Are Also Using AI to Hunt for Bugs
Microsoft faces the same shift, though from a closed development model.
The company introduced MDASH in 2026, an agentic security system that uses several models to analyze code and hunt for vulnerabilities.
Microsoft says the system helped uncover 16 previously unknown vulnerabilities in Windows networking and authentication components, four of them classified as critical and tied to remote code execution.
It’s an important example because it shows the phenomenon doesn’t depend on the code being open source.
Microsoft can run these systems internally against Windows and publish only the results it decides to disclose. Linux carries out much of that process in plain view of anyone.
FreeBSD offers a more direct comparison.
Its source code is available, and the project has updated its procedures to ask researchers to disclose when they used automated tools or artificial intelligence to discover a vulnerability.
A broader AI-assisted research campaign confirmed 34 vulnerabilities in FreeBSD and seven proof-of-concept local privilege escalation exploits. The same effort found a use-after-free issue in OpenBSD’s System V semaphore implementation that had been sitting in the code for around 23 years.
Android presents a different situation.
Much of its technology base, including the Android Open Source Project (AOSP), can be examined by outside researchers. Google has also spent years using fuzzing and other forms of automated analysis to catch bugs before they reach devices.
The arrival of language models and security agents widens those possibilities: it’s no longer just about feeding a program millions of random or semi-structured inputs to trigger a crash. An AI system can try to understand relationships between functions, trace data flows, and formulate hypotheses about how to reach specific vulnerable conditions.
However, there is currently no equivalent public figure that would allow anyone to say AI has found X Android vulnerabilities and compare that directly with the roughly 2,000 CVEs a Linux release could accumulate.
Additionally, Android uses the Linux kernel, so there’s some technical overlap. A kernel bug can potentially affect Android depending on the version, configuration, and code used by each device.
| System | Public use or evidence of AI in security | What can be concluded |
|---|---|---|
| Linux | High volume of AI-assisted reports and patches | Human review is starting to limit the capacity to process findings |
| Windows | MDASH helped find 16 vulnerabilities | Microsoft integrates agents into its internal research |
| FreeBSD | 34 vulnerabilities confirmed in an AI-assisted campaign | AI can systematically analyze mature kernels |
| OpenBSD | Discovery of a bug that had been in the code for about 23 years | Even heavily reviewed code can hide old bugs |
| Android | Extensive historical use of automated analysis and growing AI-based research | Its partly open nature makes large-scale analysis easier |
| macOS | Numerous kernel fixes, without an equivalent public AI attribution | Its count can’t be directly compared with Linux’s |
| iOS/iPadOS | Numerous kernel bugs fixed, but Apple doesn’t systematically identify which came from AI | Public figures measure fixes, not specifically AI-driven discoveries |
The table also makes clear why it’s worth avoiding any ranking of which operating system has “the most bugs found by AI.” The available data doesn’t measure the same thing.
iOS and macOS Also Have Plenty of Kernel Bugs, But One Piece Is Missing
Apple offers a particularly useful example.
iOS security updates show that finding problems in low-level components isn’t exclusive to Linux either.
iOS 26.6 and iPadOS 26.6 alone, released on July 27, 2026, fixed numerous kernel-related issues. These included use-after-free bugs, memory corruption, out-of-bounds reads and writes, race conditions, and problems capable of causing unexpected shutdowns or exposing kernel memory.
There was even a buffer overflow that could let an app execute arbitrary code with kernel privileges.
The iOS 26.6.1 update later fixed several more kernel issues, including a remotely exploitable use-after-free that could cause the system to shut down, along with other bugs capable of reading or corrupting kernel memory.
This doesn’t mean iOS is especially insecure.
It demonstrates exactly the problem with interpreting CVEs: modern operating systems contain enormous amounts of code and are under constant scrutiny.
And there’s an important difference compared with Linux.
Apple discloses who reported many vulnerabilities, but its security advisories don’t systematically state whether the researcher used AI to find them. So it wouldn’t be rigorous to add up iOS or macOS CVEs and present them as “bugs found by artificial intelligence.”
Something similar happens with macOS. In addition, macOS and iOS share technologies such as the XNU kernel and various system frameworks and components. The same type of bug can show up across several Apple products or require related fixes.
The relative opacity of the internal process makes it impossible to observe the activity in the same detail as with Linux.
AI Is Shifting Security’s Bottleneck
The most important shift probably isn’t that Linux could reach 2,000 CVEs per release, or that an agent found 16 vulnerabilities in Windows.
What’s changing is the cost of hunting for bugs.
Until just a few years ago, tracking down a complex vulnerability could require a researcher to spend days or weeks understanding a component.
Traditional automation had already changed that process quite a bit. Static analysis tools, sanitizers, and fuzzers have been finding huge numbers of issues for years.
AI adds another layer.
Agents can read code, formulate hypotheses, write tests, interpret errors, tweak a test, and run it again. If they also work autonomously for hours at a time, the potential inspection capacity increases considerably.
That doesn’t eliminate the researcher.
In fact, Linux’s experience points in the opposite direction: the cheaper it becomes to produce a potential finding, the more important it becomes to prove it’s correct.
The new process can end up having several layers. One AI finds an anomaly, another model tries to rule it out, conventional tools run tests, and a human reviews only the results that clear those filters.
Linux is already experimenting with models to review some patches before they reach the maintainer.
Proprietary systems can do something similar internally.
Microsoft can analyze Windows without publishing every discarded candidate. Apple could use comparable tools on XNU, iOS, and macOS without needing to make preliminary results public. Google, meanwhile, has long experience combining human research with automation for Android and other projects.
The upshot is that public vulnerability counts could become even less comparable.
An open, heavily scrutinized project can look worse simply because it finds, documents, and fixes more defects out in the open.
The arrival of AI reinforces that paradox.
Linux is showing, ahead of other systems, the problem that emerges when the automated capacity to hunt for bugs starts to outpace the human capacity available to review them. Windows, Android, FreeBSD, OpenBSD, macOS, and iOS aren’t exempt from that transformation.
The question will no longer be just how many bugs an artificial intelligence can find.
It will be how many of those findings can be reproduced, assessed for severity, and fixed without introducing new problems before the next automated wave reaches the maintainers.
Frequently Asked Questions
Is AI finding more vulnerabilities in Linux than in Windows?
That can’t be said based on the available data. Linux and Windows use different development, disclosure, and CVE-assignment processes, and Microsoft carries out much of its research internally.
Has artificial intelligence found real vulnerabilities in Windows?
Yes. Microsoft has reported 16 vulnerabilities discovered with the help of its agentic MDASH system, four of them classified as critical.
Does AI also hunt for bugs in Android?
Android and its open components have been subject to fuzzing and automated analysis for years, and new AI tools are expanding the available techniques. However, there’s no public counter directly comparable to Linux’s current figures.
Are iOS and macOS vulnerabilities being found with AI?
It’s technically possible to use AI to research these systems, but Apple doesn’t systematically state in its advisories whether a vulnerability was discovered using artificial intelligence. So its recent CVEs shouldn’t automatically be counted as AI findings.
