Patch-to-exploit at machine speed: Google's exploit_agent and shorter disclosure windows
Google's threat intelligence team found an attacker framework that reads security patches, works out the flaw and tries to exploit it with no human in the loop. Anthropic is shortening its disclosure windows. The gap between fix and attack is closing.
- Reading time
- 17 min
- Sections
- 7
- Code examples
- 1
- Tables
- 1
- Sources
- 10
- Published
- 18 Nov 2026
A security patch fixes a flaw for the people who install it. It also tells everyone else where the flaw was. For years, turning that hint into a working attack took skilled people days or weeks, which gave defenders time to update.
On 16 November 2026, Google Threat Intelligence Group (GTIG) reported that the window is shrinking in a new way. It described an attacker framework, called exploit_agent, that watches for patches to popular web software, compares old and new code, works out what was fixed, drafts an exploit and runs it, without a person directing each step. GTIG called this the first time it had seen threat actors fully automate vulnerability discovery and exploitation "without a human in the loop".
The same day, Anthropic said it will shorten its coordinated disclosure deadlines from 90 days to 30 days for high and critical issues. Both announcements describe the same pressure from opposite sides: attackers move from fix to exploit faster, and researchers are adjusting their clocks.
This article stays conceptual and defensive.
What happened
Google GTIG publishes its AI Threat Tracker on agentic attacks (16 November 2026)
Google's summary post says attackers are using autonomous LLM frameworks to continuously scan software updates, identify the patched flaw and build an attack for it. The full GTIG report is titled "Agentic Threat Activity Crosses a Significant Threshold". We could not load it directly, so details below come from Google's summary and news coverage that quotes it. Treat specific figures as reported.
According to Hackread, UC Today, AI TLDR and BERI, the main findings were:
- exploit_agent. GTIG recovered the framework from an exposed staging server. The server also held stolen victim data and scripts for reconnaissance, brute-forcing and installing webshells. The framework connects to several frontier and locally hosted LLMs and runs what UC Today quotes as "continuous differential analysis of popular web application software". Its configuration file had Russian-language comments. GTIG did not name a group or a country, and Hackread notes that the language does not establish the operator's nationality.
- Targets. Victim telemetry suggested the operator focused on French websites in media, entertainment and education.
- Other frameworks. GTIG also tracked open-source offensive multi-agent frameworks. Coverage names CAIRN, which was used against targets including the US aerospace sector, a customised build of PentAGI, and CyberStrikeAI and HexStrike AI in testing or experimentation.
- Stealth versus speed. GTIG said these frameworks "currently trade stealth for velocity". They generate noisy traffic and recognisable identifiers, which makes them easier to detect for now.
- Exploit volume. As reported by UC Today and AI TLDR, GTIG said disclosures and exploits nearly doubled between January and August 2026, and zero-day exploits rose from a 2025 average of 8 per month to 11 per month in 2026, with 22 in August.
- Fake proofs of concept. After two PHP flaws were patched in October, hundreds of claimed proof-of-concept exploits appeared, and many did not work. That created extra triage work for defenders.
The report also described a suspected North Korean cluster, MIDNIGHT NEPTUNE, that edited Claude Code settings files in internal repositories so that starting the tool downloaded a backdoor, and "LLM mixers" that resell stolen model access, a theme covered in our piece on LLMjacking and shadow AI data leaks.
Google used the summary to promote Google AI Threat Defense, which it describes as combining Gemini and other frontier models, Wiz's context and prioritisation, CodeMender's automated patching and Mandiant's expertise. That is a product claim. The summary's framing is that defending against machine-speed threats at human speed is not feasible.
The change matters. Coverage of GTIG's September report said it had not yet observed end-to-end autonomous zero-day discovery and exploitation against real targets; agents were mainly coordinating existing tools. Two months later, GTIG reported a pipeline that closes the loop on freshly patched flaws.
Anthropic shortens its coordinated disclosure timelines (16 November 2026)
Anthropic published an update to how it discloses vulnerabilities that its researchers find in other people's software. The changes, which apply to vulnerabilities reported on or after 1 January 2027, are:
- High and critical severity issues: disclosure deadline cut from 90 days to 30 days.
- All other issues: cut to 45 days.
- Escalation to an external vulnerability coordinator after 15 days without a maintainer response, instead of 30.
- Full technical details shared 30 days after a patch is available, instead of 45.
Reports already in progress keep their existing deadlines. The seven-day window for vulnerabilities under active exploitation is unchanged. Anthropic says hard-to-deploy software, such as critical infrastructure, and flaws that need a specification or RFC change may need a negotiated timeline. It also says the update "will not apply to AI-discovered findings that have not received human review".
Anthropic writes that "A 90-day window made sense when a vulnerability could be expected to stay private for months," and that "We are seeing a higher rate of vulnerability rediscovery as these capabilities increase."
Google Project Zero's policy also lists planned changes: from its current "Full 90" deadline to "Full 60" on 2 February 2027 and "Full 30" on 3 January 2028.
How patch diffing works, and why agents compress it
Imagine a lock company sends a letter to every customer: "Model 7 locks have a weakness. Please collect your free replacement." Customers who act quickly are safe. But the letter also tells every burglar in town that Model 7 locks are worth studying. If a burglar can compare an old lock with the new one, the difference points straight at the weak part.
Patch diffing is the software version of that comparison. Say a vendor releases version 2.4.1 to fix a security issue. The release notes may say little, but the code change is public, or can be recovered by comparing old and new binaries. An analyst who diffs the two versions sees which function changed, which check was added and which input is now rejected. That narrows a search across millions of lines to a few dozen.
A flaw that is already public and patched is an n-day; a zero-day is unknown to the vendor. The patch gap is the time between a fix being released and systems actually installing it. Attacks during that gap target organisations that have not updated yet. For an attacker, n-days are attractive because the vendor has already done half the work of finding the bug.
Historically, the hard part was the human step in the middle. Reading a diff, finding the root cause and building a reliable exploit took expertise and time, so attackers chose carefully which patches were worth it.
LLM agents change the economics of that middle step. At a conceptual level, the pipeline GTIG describes has five stages:
- Monitor. Watch release feeds and repositories for new versions of popular web applications.
- Diff. Compare the code before and after each update.
- Root cause. Ask a model to explain what the change fixes and what input would have triggered the old behaviour.
- Exploit attempt. Draft code that targets unpatched versions.
- Validate and act. Run it against targets and, in this case, follow up with post-compromise scripts.
None of these steps is new. What is new is that an agent loop can run them continuously, across many projects at once, at low marginal cost. It is the same shift described in our piece on always-on AI agents: work that used to happen in sessions now runs in the background, all the time.
A machine that tries many patches at once does not need every attempt to succeed. Coverage says GTIG expects cybercrime actors to keep adopting these tools because wider reach offsets lower success rates, while stealth-focused espionage groups may avoid them in sensitive networks.
| Pipeline stage | Human-speed attacker | Machine-speed attacker (as reported by GTIG) |
|---|---|---|
| Watching for patches | Selective, follows high-profile advisories | Continuous scanning of popular web software |
| Diffing and root cause | Expert reads the change, can take days | LLM analyses each change automatically |
| Exploit attempt | Built carefully for a few chosen flaws | Drafted for many flaws, many may fail |
| Execution | Planned and supervised | Runs without a human directing each step |
| Detectability | Often quiet and tailored | Currently noisy, "trades stealth for velocity" |
| Economics | High cost per exploit, few targets | Low cost per attempt, broad reach |
The table is qualitative on purpose: the sources we read gave no measured patch-to-exploit time or success rate for exploit_agent.
Why disclosure windows were 90 days, and what shorter windows change
Coordinated disclosure is a deal. The researcher reports a flaw privately, the vendor gets a fixed time to ship a fix, and after the deadline the researcher publishes either way. Without a deadline, some vendors would never fix anything.
One of the best-known fixed deadlines is Google Project Zero's. Its policy states the current deadline as 90 days, with a 7-day deadline when a flaw is being exploited against real users. Its stated aim is "Make zeroday hard". Project Zero says exceptions to its deadline are rare and publicly recorded, and that it has granted them five times in the last 12 years.
The 90-day number balanced two risks. A short deadline can force publication before users are protected. A long one leaves users exposed if someone else quietly finds the same bug. In Anthropic's words, it made sense when a vulnerability could be expected to stay private for months.
The balance has shifted, for two reasons:
- Rediscovery is more likely. Anthropic reports more rediscovery. When AI helps many people hunt for bugs, someone else is more likely to find the same flaw during the 90 days. A long private window then mostly helps whoever found it second and kept quiet.
- Weaponisation is faster. Once a patch is public, an automated system can try to turn it into an attack. Holding back technical details matters less if attackers can derive them from the diff, which fits Anthropic's change from 45 to 30 days for full details.
A shorter disclosure window does not itself make attacks faster. It changes who carries the time pressure. Vendors must triage, fix and ship sooner. Users must install sooner. The AI models that find vulnerabilities we covered earlier increase the supply of real bug reports. Shorter windows increase the speed at which those reports become public fixes. Together they put patch deployment, not bug discovery, at the centre of defence.
Anthropic's exclusion of unreviewed AI findings is a counterweight. The PHP episode showed that unverified "exploits" waste defenders' time; human review before the clock starts is a quality filter.
What defenders can automate
If the attacker side of the patch gap is automated, the defender side has to be too. Most of the tools exist; what changes is how fast they must run.
Knowing what you run. A software bill of materials (SBOM) lists the components and versions inside each application, so "are we affected?" becomes a query instead of a day of searching.
Prioritising by likely exploitation. Not every patch is equally urgent. FIRST's Exploit Prediction Scoring System (EPSS) is a machine-learning model that estimates the probability "that a published CVE will be exploited in the wild in the next 30 days", published daily for every CVE. Prioritisation tools like this help teams decide which patches cannot wait. GTIG's finding suggests one more factor: public patches for popular, internet-facing web software are now prime candidates for automated n-day attacks, whatever the base score.
Auto-patching. For many web applications, plugins and libraries, automatic updates are now safer than waiting for a manual change window. A car recall applied at your next service is fine when thieves need months to learn the weakness, not when they learn it the same afternoon.
Virtual patching. When a fix cannot be installed right away, a web application firewall or reverse-proxy rule can block requests that match the vulnerable pattern. This is a temporary barrier, not a repair, but it can cover the hours or days until the real patch goes in.
AI-assisted fixing. Google's CodeMender is an example of the defensive mirror image. Google DeepMind described it in October 2025 as an agent that patches new vulnerabilities and rewrites code to remove whole classes of bugs, with automatic validation of root-cause fixes, functional correctness and regressions. Google said all CodeMender patches are reviewed by human researchers before being submitted upstream. Similar tooling, combined with guardrails and human review, can speed up the vendor side of a 30-day window.
Treating agent configuration as code. The MIDNIGHT NEPTUNE case shows that settings files for coding agents can be an attack path. Files that tell an agent what to run on startup deserve the same review as build scripts. Our guide to governing AI agent access and the sandboxing for AI agents page cover how to limit what an agent can touch.
Watching for noisy automation. Because current frameworks trade stealth for speed, they leave traces such as noisy traffic and recognisable identifiers. Coverage says Google SecOps already ships detection rules for one of them.
What it means in practice
For organisations running public-facing web software, assume the time between "a patch exists" and "someone is trying it against you" is short. Patch targets written for human-paced exploitation may now be too slow.
For vendors and open-source maintainers, a high-severity report from Anthropic after 1 January 2027 means 30 days, not 90, before disclosure. Projects need a working security contact, a way to ship emergency releases and release notes that say how urgent an update is.
For security teams, more real bugs, more public patches and more fake proof-of-concept code arrive at once. Automation helps only if someone owns the process and can explain its decisions, which is an AI governance question as much as a tooling one.
For teams deploying agents internally, the lesson is not to avoid agents but to treat agent identity, credentials and configuration as attack surface, as described in our page on agent identity and delegation.
What to do now
- Inventory internet-facing software. List every public web application, plugin and framework you run, with versions, and keep an SBOM for each one so you can answer "are we affected?" in minutes.
- Shorten patch targets for exposed systems. Review your patch service-level targets for internet-facing software against the assumption that a public patch can be turned into an attack attempt quickly.
- Turn on automatic updates where safe. For plugins, libraries and managed web platforms with good rollback, prefer automatic security updates over scheduled manual windows.
- Prepare virtual patches. Make sure your web application firewall or proxy can deploy a blocking rule quickly when a fix cannot be installed the same day.
- Add exploit likelihood to prioritisation. Use signals such as EPSS and known-exploitation lists alongside severity scores, and weigh internet exposure heavily.
- Verify proof-of-concept code before acting on it. Treat public exploit code with caution, run it only in isolated environments, and expect some of it to be fake or broken.
- Lock down agent configuration files. Require review for changes to coding-agent settings and startup hooks in repositories, and limit which settings can run commands.
- If you maintain software, plan for 30-day windows. Publish a security contact, rehearse an emergency release, and write release notes that state clearly when an update fixes a security flaw.
Risks and open questions
The full report details are second-hand here. We could not load GTIG's full report page, so specifics such as the zero-day monthly counts come from coverage that quotes it. Those numbers should be checked against the original before being used in planning.
Success rates are unknown. Hackread notes the report did not confirm that every generated exploit worked. A pipeline that runs autonomously is not the same as one that succeeds often.
Shorter windows can hurt slow-to-patch sectors. Industrial and embedded systems often cannot deploy fixes in 30 days. Anthropic allows negotiated timelines for hard-to-deploy software, but how consistently that works is open.
Vendor framing mixes threat data and marketing. Google's summary moves from threat findings to its own defence product. The claim that a product closes the gap is a company claim.
Noisy today does not mean noisy tomorrow. Detection based on today's noise may weaken as tools mature.
Watch next: Whether Google publishes measured patch-to-exploit times for exploit_agent-style activity, whether other labs and research teams follow Anthropic and Project Zero in shortening deadlines, how open-source maintainers cope with the first 30-day deadlines after 1 January 2027, and whether attacker frameworks become quieter.
Frequently asked questions
What is patch diffing?
Patch diffing means comparing a program before and after a security update to see what changed, which points to the flaw that was fixed. Defenders use it to understand risk; attackers use it against systems that have not updated.
What did Google actually find?
GTIG reported recovering a framework called exploit_agent from an exposed attacker staging server. It reportedly uses several LLMs to watch web software patches, compare code, identify the fixed flaw, draft an exploit and run it without a human directing each step. GTIG described this as the first time it had seen attackers fully automate vulnerability discovery and exploitation without a human in the loop.
What exactly is Anthropic changing?
For vulnerabilities reported on or after 1 January 2027, Anthropic will disclose high and critical issues after 30 days instead of 90, and other issues after 45 days. The seven-day window for actively exploited flaws stays the same.
Does a shorter disclosure window help attackers?
It can look that way, but the argument is that the secrecy of long windows is weakening anyway. Anthropic says it is seeing more rediscovery of the same bugs, and GTIG's finding shows patches can be analysed automatically once public. Shorter windows push vendors to fix sooner, which reduces the time users stay exposed.
What is the single most useful step for a small team?
Know what internet-facing software you run and turn on automatic security updates wherever rollback is safe. n-day attacks, by definition, hit systems that have not installed an available fix.
Summary
Google's 16 November 2026 AI Threat Tracker reported an attacker framework, exploit_agent, that monitors patches to popular web software, infers the fixed flaw and attempts exploitation without a human in the loop. The same day, Anthropic said it will cut disclosure deadlines to 30 days for high and critical issues and 45 days for others from 1 January 2027, citing faster AI progress and more frequent rediscovery, and Project Zero has published a similar planned path to 60 and then 30 days. The common thread is that the patch gap, the time between a fix and its exploitation, is shrinking. Defenders should answer with inventory, exploit-likelihood prioritisation, automatic updates, virtual patching and tighter control of their own agents.
Sources
- Google: The latest AI Threat Tracker from Google Threat Intelligence Group
- Anthropic: Coordinated vulnerability disclosure timelines
- Hackread: Google Spots AI Agent Turning Security Patches Into Exploits
- UC Today: Google: AI Agents Now Turn Patches Into Exploits With No Human Help
- AI TLDR: GTIG AI Threat Tracker, attackers now run fully autonomous pipelines
- BERI: Google Finds Attackers Turning Patch Diffs Into Working Exploits
- CyberInsider: Google warns hackers are deploying AI agents in autonomous attacks
- Google Project Zero: Vulnerability disclosure policy
- FIRST: Exploit Prediction Scoring System (EPSS)
- Google DeepMind: Introducing CodeMender, an AI agent for code security
Continue learning
Cite this article
Kelahmet, Ö. C. (2026, November 18). Patch-to-exploit at machine speed: Google's exploit_agent and shorter disclosure windows. Özer Cem KELAHMET. https://www.ozercemkelahmet.com/articles/patch-to-exploit-at-machine-speed
BibTeX
@online{kelahmet2026patch,
author = {Kelahmet, {\"O}zer Cem},
title = {{Patch-to-exploit at machine speed: Google's exploit_agent and shorter disclosure windows}},
year = {2026},
month = {nov},
url = {https://www.ozercemkelahmet.com/articles/patch-to-exploit-at-machine-speed}
}How this article connects
8 pages link to or from it. Drag to turn, click a dot to open it.
- Guardrails
- AI governance
- Sandboxing for AI agents
- Agent identity and delegation
- Governing AI agent access with scoped credentials and undo buttons
- Always-on AI agents move from chat sessions to background teammates
- LLMjacking and shadow AI: how stolen keys and pasted data are leaking ou
- GPT-6 Cyber, Tencent Hy4 and DeepMind's RSA work on AI bug hunting
Version historyfirst version
- Published
Factual corrections are listed here with what changed. Wording and formatting edits are not listed.