Anthropic’s Claude models have flagged nearly 38,000 candidate vulnerabilities in open-source software. About 5,000 have reached maintainers. Just 629 are patched upstream.
You might think this is a patching speed problem. It isn’t. It’s a people problem, and most of those people aren’t paid.
When the people who fix the code are overwhelmed, the patch you’re waiting for arrives late, or never. This article explains why AI vulnerability discovery broke traditional vulnerability management, and how to triage for the bugs attackers actually use while upstream catches up. Along the way, I’ll show you one statistic that makes this crisis look worse and better at the same time. Let’s get stuck in!
Why Vulnerability Management Is Drowning in 2026
Let’s start with the scale. I pulled yearly Common Vulnerabilities and Exposures (CVE) counts straight from the National Vulnerability Database (NVD) API, and the curve is brutal.
| Year | CVE records published in the NVD |
|---|---|
| 2021 | about 22,000 |
| 2025 | about 50,000 |
| 2026 (to mid-November) | more than 100,000 |
That’s over 300 new CVEs a day. Five minutes of human triage each is more than 25 analyst hours daily before anyone fixes anything (your analysts would like a word).
And the catalog just stepped back.
Since 15 April 2026, NIST has prioritized only a narrow slice of CVEs for enrichment: those in the Cybersecurity and Infrastructure Security Agency (CISA) Known Exploited Vulnerabilities (KEV) catalog, federal software, and critical software under Executive Order 14028. Everything else may never get a Common Vulnerability Scoring System (CVSS) score or a Common Platform Enumeration (CPE) product mapping.
Many scanners match on CPE, and a scanner can’t match if the record doesn’t exist!
Your scanner isn’t reporting a clean estate. It may be reporting a blind one. Check how your tooling handles CVEs marked “Not Scheduled” before you trust another green dashboard.
The Clock Got Shorter Too
On 2 November 2026, Microsoft published an analysis of roughly 383,000 CVEs. The mean time from CVE publication to a KEV listing fell from 89 days for 2024 CVEs to 57 days for 2025 CVEs, and 20 days for 2026 CVEs published through September.
The median? Three days.
One caveat: 2026 CVEs have had less time to reach KEV, which drags that average down. But VulnCheck’s State of Exploitation 2026 report points the same way: 28.96% of 2025’s known exploited vulnerabilities were exploited on or before the day their CVE was published.
Before means no CVE-based scanner could flag it. On the day means your patch window is zero.
Why AI Exploitation Broke the Patching Timeline
For three decades, defense ran on a timing advantage. Finding a flaw took months of code auditing. A working exploit required scarce reverse-engineering talent. Weaponization could take weeks or months.
AI broke that.
The red loop took about a decade to automate, from DARPA’s Cyber Grand Challenge in 2016 to today’s frontier models.

The blue loop still has a change board blocking decisions.

What Claude Mythos Actually Demonstrated
Anthropic’s Claude Mythos Preview shows where AI exploitation sits now. Its launch findings included flaws that survived decades of review:
- A 17-year-old remote code execution bug in FreeBSD’s NFS server (CVE-2026-4747), found and exploited autonomously.
- A 27-year-old crash bug in OpenBSD’s TCP stack.
- A 16-year-old FFmpeg flaw in a line of code that fuzzers (tools that hurl random inputs at software) had exercised five million times.
Exploit development is the bigger shift. In Anthropic’s exploit evaluations, Mythos Preview achieved arbitrary code execution (ACE) on 21 of 41 real bugs in V8, Chrome’s JavaScript engine. Carnegie Mellon’s ExploitBench paper recorded 18 of 41 with no vendor scaffolding. No publicly deployed model came close.
So what? Exploit development used to be the scarce skill that bought defenders weeks. That scarcity is ending.
Why does discovery automate so well? The success condition is binary and runs locally. Generate a harness, fuzz it, and let sanitizers (runtime checks that catch memory errors) flag the crash. Crash or no crash.
Why Patching Is the Hard Half
Picture an inspector with a sledgehammer and a skyscraper. No plumbing diagrams. They just need one unreinforced bolt. One hit, done.
Now make the same system the architect. Fix that bolt without blocking the fire exit, shifting load onto the beam above, or breaking the building code. Success is multidimensional, and the feedback signal is a test suite that was never complete.
Here’s what that looks like in code. A length field overflows a 64-byte buffer. The proof of concept sends a 4,096-byte payload. The model adds a bounds check:
int len = read_length(pkt); // signed!
if (len > 64) return -1; // PoC blocked, tests go green
memcpy(buf, pkt->data, len); // len = -1 becomes SIZE_MAX (~18 quintillion bytes)
Run the proof of concept, and it’s blocked. Tests are green. Ship it?
Now send minus one. Because len is signed, the check passes, and memcpy reads it as an enormous unsigned value. That’s a crash, or worse.
This is test suite overfitting. The patch blocks the one crashing input. The crash stops, but the bug stays.
It’s not hypothetical. 1Password’s Off-by-1 Labs graded 6,080 AI-generated patches across six real CVEs. Only 26% fully fixed the vulnerability without changing application behavior, and the research paper found models often added fragile guard code that satisfied tests while missing the root cause.
Strong repair benchmark scores mean passing a repository’s tests… exactly the signal we just broke.
Project Glasswing and the Patch Management Bottleneck
Any discovery announcement without a merged fix count is a marketing metric. So let’s count fixes.
Anthropic launched Project Glasswing on 7 April 2026, and partners reported more than 10,000 high or critical findings in the first weeks. When I first saw the open-source totals, I assumed the candidate figure was a typo. Here’s the funnel from Anthropic’s coordinated vulnerability disclosure dashboard, covering Mythos Preview and other Claude models:
| Stage (dashboard of November 2, 2026) | Count |
|---|---|
| Candidate findings (680 projects in scope) | 37,966 |
| Reviewed by external security firms | 6,376 (6,009 confirmed valid) |
| Disclosed to maintainers | 5,087 |
| Acknowledged by maintainers | 3,635 |
| Patched upstream | 629 |

That’s 629 patches from 37,966 candidates. Under 2%. Even counting only disclosed findings, it’s about one in eight, and many recent disclosures are still inside their 90-day coordinated disclosure window.
Reading the dashboard carefully: the October snapshot showed higher disclosed and acknowledged counts, likely reflecting deduplication or withdrawals. VulnCheck counts 217 fixes in Anthropic’s public ledger, which lists only findings made public so far; the dashboard’s 629 counts everything patched upstream.
Severity is contested, too. VulnCheck’s November analysis found Claude rated 91.5% of ledger findings high or critical, while maintainers rated 51.3% that way. A severity label tells a maintainer to drop everything. Roughly half the time, that urgency isn’t warranted.
That time belongs to a human. In Tidelift’s 2024 survey, 60% of open-source maintainers were unpaid. Scanners run continuously on compute clusters; maintainers run on coffee and energy drinks!
When Maintainers Close the Door
Look at curl. Daniel Stenberg wrote that north of 15% of curl’s security submissions used to be confirmed vulnerabilities. Starting in 2025, that rate fell below 5%. A false report costs the same triage time as a true one, so curl’s bug bounty officially stopped on January 31, 2026.
Ending a bounty cuts the noise. It also cuts the reward for the one researcher holding a real bug. Your supply chain inherits that risk, because libraries like SQLite and FFmpeg sit inside millions of devices, from gateways to hospital networks.

Burnout is a security control failure. We audit the firewall but never the human at the end of the pipeline. Nobody has a risk register line for “maintainer stops reading the inbox.”
If you consume open source, flip the question. Stop asking how many findings you received. Ask what you paid for:
- Fund the projects in your dependency tree.
- Staff upstream triage, even a few hours a month.
- Contribute patches, not tickets.
That lever moves the fix rate.
Running AI discovery at scale yourself? Require a human-verified reproducer, attach a candidate patch that passes the project’s own tests, and rate limit per project. A report that costs the sender nothing should never be unlimited.
Where Attackers Actually Aim
So you can’t assume a fix is coming quickly. The real question is which vulnerabilities you can’t afford to wait on.
It isn’t those 100,000 CVEs. It’s a very short list.
I pulled CISA’s KEV feed and grouped additions by year. CISA added 245 entries in 2025. As of the 13 November catalog, 2026 stands at 297, with six weeks left.
Here’s the statistic I promised. NVD records roughly doubled. CISA’s KEV additions, a conservative but widely used proxy for confirmed exploitation, rose about a fifth. Microsoft’s long-run data fits the pattern: only about 0.5% of all CVEs since 1999 have ever been tied to a real attack.

That’s the better part. Most of this flood is never used in the wild.
KEV undercounts. VulnCheck tracked 884 newly exploited CVEs in 2025, against CISA’s 245. Even so, exploited vulnerabilities remain a tiny fraction of the total.
The worse part? What does get used is concentrated: remotely reachable, often unauthenticated, on edge devices, and weaponized before your triage cycle finishes.
Why the Edge?
Edge devices are internet-facing, run specialized or legacy operating systems, and have no room for your Endpoint Detection and Response (EDR) agent. Verizon’s 2026 Data Breach Investigations Report found that 31% of breaches now start with vulnerability exploitation, overtaking stolen credentials as the top way in. A year earlier, Verizon reported edge devices and VPNs had jumped from 3% to 22% of exploitation targets.
They’re also the slowest thing you patch. Microsoft’s 2026 telemetry puts the median workstation vulnerability at about two weeks to patch. The median network appliance? More than a year.

Once an attacker is in, things move fast. The CrowdStrike 2026 Global Threat Report recorded a fastest breakout time (initial access to moving onto another system) of 27 seconds, and 82% of 2025 detections were malware-free. No signature to catch. No agent on the appliance to log it. That’s why behavior-based detection engineering matters at the edge, and why the same edge-plus-living-off-the-land approach shows up in Volt Typhoon’s campaigns.
Three edge case files, one pattern:
Ivanti Connect Secure (CVE-2023-46805 + CVE-2024-21887)
Authentication bypass into command injection. Volexity saw attackers tamper with Ivanti’s Integrity Checker Tool, then found over 1,700 compromised appliances.
Palo Alto Networks PAN-OS (CVE-2024-3400)
Unauthenticated root command injection on GlobalProtect gateways, followed by the UPSTYLE backdoor (Unit 42).
Fortinet FortiManager “FortiJump” (CVE-2024-47575)
Unauthenticated remote code execution; attackers registered rogue FortiGate devices into the managed fabric.
None of these needed AI. The edge was already the weak seam. AI just makes it bleed faster.
An edge device is a credential vault and a trust anchor: session tokens, VPN configurations, and management links into your network. Own the box, and you inherit the trust. Your crown jewel analysis should include the appliances that guard the crown jewels.
A Vulnerability Management Triage Process for 2026
Stop triaging by CVSS alone. Instead, borrow from CISA’s Stakeholder-Specific Vulnerability Categorization (SSVC), which weighs exploitation status, automatability, and impact to reach a decision. Here’s my edge-first triage process:
- Exposure: Is the affected asset on the edge or internet-facing?
- Authentication: Can it be exploited without credentials?
- Exploitation evidence: Is it in KEV, does it have a high Exploit Prediction Scoring System (EPSS) score (many teams use 0.1, a 10% chance of exploitation in the next 30 days, as a cut-off), or are access brokers selling access to that product?
- Compromise check: If the first three are all yes, assume the box may already be owned.
Count the yeses in steps one to three, then act:
| Yeses | SSVC-style decision | Target |
|---|---|---|
| Three | Act: emergency change plus compromise assessment | Hours |
| Two | Attend: next change window, add monitoring | Days |
| Zero or one | Track: normal patch cycle | Weeks |
Picture this. Tuesday morning, and a VPN appliance CVE lands in KEV:
- 09:00: KEV alert for a vendor you run.
- 09:15: Run an exposure check against your own inventory, not the NVD (which may never enrich it).
- 09:30: Three yeses. Act, whatever its CVSS score says.
- 10:00: Patch or mitigate, and open a second ticket: compromise assessment, credential rotation, and a check of every session token that touched the box. Patching doesn’t remove an implant, and CISA found attackers could deceive Ivanti’s integrity checker into missing a compromise.
- Less noise
Stop burning analyst hours on CVEs that are never exploited. - Faster response where it counts
Edge, unauthenticated, exploited flaws jump the queue. - Independence from the NVD
Your priorities no longer hinge on enrichment that may never arrive. - A defensible story
Every patching decision is explained in terms of exposure and threat.
Two Intelligence Requirements for Monday Morning
This is where threat intelligence earns its keep. Turn the problem into intelligence requirements your team can answer.
Requirement one: exposure
Which edge assets do we run, which versions, and who owns them? Keep your own inventory (a little data engineering for CTI goes a long way) and validate it from outside, as in threat hunting with Netlas.io.
Requirement two: exploit intent
Are exploit developers or access brokers discussing our edge vendors and versions before a CVE exists? That leading indicator is the one thing that buys back any of that three-day window. Make it a priority intelligence requirement, build it into your collection management framework, and name your sources in an intelligence collection plan. Intel 471’s open CU-GIR framework is a handy starting list.

Then grade what you collect. A brand-new forum account claiming access to your vendor’s gateway is an F6 on the Admiralty scale: you can’t judge reliability or credibility. Corroborate with your other threat intelligence sources before you escalate. Underground chatter is full of recycled listings and hoaxes.
Say it to your CISO in one sentence: “Our risk isn’t the count of CVEs. It’s how many internet-facing, unauthenticated, uninstrumented assets we run, and how fast we learn they’re targeted.”
Need to turn that into a briefing? My CTI report writing guide shows you how.
Summary
This guide shows why traditional vulnerability management is breaking. Claude Mythos and its peers made finding cheap, while fixing still runs on one maintainer’s evenings. Project Glasswing’s funnel shows the gap; NIST has stopped enriching most CVEs, and exploitation lands in days.
The good news? Attackers aim at a short list. Edge, unauthenticated, and exploited or brokered flaws get your first hour, every time. Build your own inventory, collect against exploit intent, and fund the people upstream.
You can’t patch 100,000 things. You can decide in advance which questions need answering. Start with the VPN box.
Frequently Asked Questions
How Is AI Changing Vulnerability Management?
AI finds vulnerabilities and develops exploits far faster than humans, and AI-assisted discovery is a major driver of record CVE volumes. Patching hasn’t sped up, so exploitation-focused triage is essential.
What Are Claude Mythos and Project Glasswing?
Claude Mythos Preview is an unreleased Anthropic model with strong vulnerability discovery and exploit skills. Project Glasswing, launched in April 2026, uses it to find and disclose flaws in critical software.
Why Can’t AI Just Patch the Vulnerabilities It Finds?
Discovery has a binary signal: crash or no crash. Patching must preserve behavior, close the whole bug class, and pass incomplete tests. Many AI patches block the demonstrated exploit but leave the bug reachable.
What Is the CISA KEV Catalog?
The Known Exploited Vulnerabilities catalog is CISA’s list of CVEs with evidence of real-world exploitation. It’s a conservative, high-signal starting point for prioritization.
What Changed With NIST NVD Enrichment?
Since 15 April 2026, NIST prioritizes enrichment for KEV-listed, federal, and critical software CVEs. Others may lack CVSS and CPE data, leaving CPE-based scanners blind.

