Surveil or else: the patch is now the attacker's map
At vm2, Claude co-wrote 19 of 34 fixes – weeks later an AI agent bypassed one of them on the first try. That is the pattern of the year: AI finds flaws and builds exploits brilliantly but writes incomplete patches, and the patch itself becomes the map. An open-weight model compromised every Firefox release from a six-week window for $1,000 each. Why “patched” no longer means “safe” – and what remains once the patch becomes the attack plan.
As of 16 November 2026.
Over the summer the maintainers of vm2 – a JavaScript sandboxing library with a million downloads per week – shipped fixes for 34 sandbox-escape vulnerabilities; Anthropic’s Claude co-wrote 19 of them. Weeks later a security researcher pointed an AI agent at one of those fixes and asked for a way around it. The agent delivered.
That is the whole story in one sentence: the patch meant to close a gap shows the attacker where the gap was, what the defender thought the problem was – and where they got it wrong. A patch that only blocks the reported input marks the vulnerable spot and invites a look one step over: another encoding, another address range, another path into the same function. It is one of the cheapest forms of bug hunting, and a growing share of attacker effort – and AI tokens – goes into exactly that.
The numbers behind the problem.
The vulnerability flood is real and measurable. In June, FIRST projected around 66,000 CVE assignments for this year; two months before the end, the figure is approaching 100,000. Microsoft’s October Patch Tuesday alone addressed 1,415 vulnerabilities – against 180 in October 2025. Anthropic’s AI-assisted vulnerability programme (Mythos-powered, “Glasswing”) counted 37,966 findings seven months after launch; of 7,349 flaws made public, only 217 had been fixed according to VulnCheck. The bottleneck has moved: progress is no longer limited by finding flaws, but by verifying, disclosing and patching them.
Two examples show what that means inside companies. Bank of America added 1,000 outside contractors in the second quarter on top of roughly 3,000 staff to handle the patching work. At Meta, AI now writes 40 percent of fixes for critical vulnerabilities, almost half landing in production unchanged – and yet the time systems stay vulnerable did not drop. The reason: every AI patch still has to be reviewed by humans, while the amount of new code grows more than 100 percent a year, over 80 percent of it from AI agents. “Everyone is drowning in stuff to review,” one Meta engineer said.
AI is better at offence than at defence.
The decisive finding of several research groups: AI finds flaws and builds exploits brilliantly, but writes unreliable patches.
| Study | Result |
|---|---|
| 1Password / Off-by-1 Labs | 6,080 AI-generated patch candidates for six known flaws; about half left at least one attack path open – agents sometimes missed identical bugs elsewhere in the code |
| P2Patch benchmark | Two agents against each other: after patching 101 real flaws, the attacker agent found a new path to the same bug in 41 cases, sometimes repeatedly |
| Terra “PatchSlop” | Rate of incomplete or broken fixes in open-source projects up eightfold this year |
| Trail of Bits | Even 1 in 8 human-written fixes (of 2,265 reviewed) did not fully resolve the issue – the problem is not AI alone |
Two examples from the [un]prompted conference make the pattern concrete. Patching a firmware function, an AI agent rebuilt it without the stack canaries the original had – silently removing a protection. For a second flaw, the generated patch filtered double-quote characters out of attacker input but missed that single quotes would bypass the fix. That is the core: the patch stops exactly the one reported exploit and reassures everyone, while the bug remains underneath.
“Closed source” is no protection.
Anyone who thinks compiled, non-public software is safe because the patch sits inside a binary is mistaken. AI is now excellent at reverse engineering. In June, Anthropic’s researchers gave a model only what was public on patch day: within an hour of a Firefox fix, a working exploit. On Windows the same approach built eight full privilege-escalation chains from 21 kernel vulnerabilities, for roughly $2,000 each. Their conclusion: “In some ways, N-days are more dangerous than zero-days, because the patch itself provides a roadmap to the bug.” A team at Fudan University analysed 76 patches from 62 closed-source applications across 25 vendors; 26 could be bypassed into new vulnerabilities, resulting in 19 CVEs and $28,100 in bounties.
Current frontier models increasingly refuse such binary analysis via guardrails. That helps only so far: open-weight models like Qwen, Kimi or GLM are, in the words of Microsoft’s research chief, “extremely capable” and do not know those limits.
The patch gap is now exploitable in hours.
Between the moment a fix becomes visible in source code or a test build and the moment it reaches all users lies the “patch gap”. Epoch AI measured it: the freely downloadable model GLM 5.3 compromised every Firefox release shipped between 17 September and 26 October – for about $1,000 each and as little as twelve hours of work per target. “We did not trigger any safeguards or refusals from any provider.” For the most recent versions the model chained the flaw read from the patch with a second, undisclosed one; Mozilla closed that in Firefox 159 on 27 October. As a countermeasure, Mozilla no longer releases the regression tests tied to security fixes immediately – without that test, GLM 5.3 is markedly less successful.
Microsoft’s Edge team warns of patch-gap abuse too: attackers use fixes that become visible in Chromium builds before they reach the downstream browsers (Chrome, Edge). “The technique is not new, but the speed and expertise required are changing. AI-assisted analysis can compress weeks of work into hours.”
What this means for your organisation.
The old equation “patched = safe” is broken. It breaks in two places at once. First, the patch may be incomplete – the flaw is then still there, just less visible because everyone considers it closed. Second, even a correct patch is a blueprint: from publication a race is on, and the attacker side counts in hours. Those who apply the update next week are not facing a theoretical risk but a publicly documented path into their system.
For the Mittelstand this is not abstract research. It is the same pattern we have seen concretely three times this autumn: the first GitLab fix in the regex compiler left a second, identical flaw open. Zyxel’s June patch for the GS1900 switches did not stop the exploited zero-day. And with N-able N-central the hotfix was followed within two days by two new chains that worked against the hotfix too. In all three cases “patch and move on” was the wrong response.
None of this is an argument against patching or against disclosure – less transparency does not make the software safer, it only takes the information away from defenders. It is the insight that carries our name: once the patch becomes the map and can be exploited in hours, the only remaining guarantee is that you see the attack. Surveil or else. A patched system is not a safe system; it is a system where you must assume the fix was incomplete, and watch it accordingly.
What to do now.
- Patch faster, but do not trust blindly. The order of urgency follows reachability from the network, not the CVSS score alone. Every publicly described fix for an internet-reachable system is in the race from day zero.
- Treat the patch as incomplete. After every critical update, hunt for exploitation traces on the affected system – do not just check the version. Especially for fixes that block “only the reported input”.
- Put detection on what a patch does not cover. In XIEM: behavioural rules on the function that was patched (crashing workers, unusual input patterns, atypical calls), plus egress logging – a successful N-day exploit often leaves nothing in the application logs but a connection to the outside.
- Variant hunting in your own patch process. If you build software: after each fix, run an agent “as an attacker” against the patch (OpenSSF and OpenAI recommendation), fix the root cause rather than the reported input, sweep the rest of the code for the same bug class.
- Ask your suppliers. For critical products and service providers: how do they patch, do they check for variants, how fast does a fix reach your environment? This belongs in the NIS2 supplier assessment.
Progress on software security used to be limited by how quickly we could find flaws. Today it is limited by how quickly we can verify, disclose and close them – and by whether we see who uses the gap in the meantime.
Sources
- CSO Online: AI-written patches are becoming attack maps for hackers (vm2, Rubrik, Meta, Bank of America, FIRST, Fudan, Terra)(2026-11-16)
- Epoch AI: Open-weight AI models can exploit the patch gap (GLM 5.3 vs. Firefox, ~1.000 USD/Ziel)(2026-10-29)
- Mozilla Security Advisory MFSA2026-118: Firefox 159.0(2026-10-27)
- Mozilla Blog: Defending the patch gap against automated attackers (Regressionstests zurückhalten)(2026-11)
- Anthropic: Measuring LLMs' impact on N-day exploits (Firefox in 1 h, 8 Windows-Ketten aus 21 Kernel-Bugs)(2026-06)
- ITPro: Hackers are using patches to create vulnerability ‘maps’ – Terra PatchSlop (8-facher Anstieg)(2026-11)
- Microsoft Edge Security: Patch-Gap-Missbrauch bei Chromium-Downstream-Browsern(2026-10)