Google finds AI-assisted patch analysis in an attack framework

Google's GTIG found exploit_agent on an attacker staging server, linking patch comparison with exploit-code generation. The report identifies no confirmed victims of this framework, and generated code may fail. Defenders still need risk-based patching.
A vendor has just released a security patch, and an update notification appears on your screen.
You are busy, so you casually click “Remind me later.”
Meanwhile, hackers have been waiting for that patch too.
Whatever lines of code the vendor changed, they have AI examine those lines. If it finds a weakness, the AI can also automatically write exploit code and try it against the old version.
There is a window between a patch becoming public and your installing the update.
Your software still has the original vulnerability, while attackers may already have a “vulnerability manual” precise down to the line of code.
This week, Google Threat Intelligence Group (GTIG) published a report.

Google discovered an attacker’s staging server directly exposed to the public internet. Inside, it found an AI attack framework called exploit_agent.
Its task is chilling:
Continuously compare software code before and after fixes, infer the location of vulnerabilities from the differences, then automatically generate and execute exploit code.
Google said in the report that this was the first time it had found attackers using a large-model framework to connect the entire process from “finding vulnerabilities” to “exploiting vulnerabilities,” without a human involved in between.
Its conclusion: large models are shrinking the window enterprises have to apply patches.
Of course, this does not mean every unpatched system falls immediately upon a patch’s release. Google also did not disclose any targets that this framework had actually compromised.
But a dangerous signal has appeared: the moment a patch is released, the security alert has not simply ended. Instead, the starting gun has sounded for both attackers and defenders.
Wherever the vendor makes a fix,
AI-assisted hackers focus their attention
A vendor issuing a security patch is like a lock manufacturer announcing a recall and helpfully attaching a diagram comparing the old and new lock mechanisms.
Homeowners are busy at work and have not yet found time to replace their locks, while thieves use AI to study the diagrams thoroughly and try every door on the street whose lock has not been changed.
In a real-world setting, suppose you maintain a small website, and a plugin in its back end has just received a security update.
Following your usual routine, you plan to finish the work in front of you, make a backup when you have time, test compatibility and then upgrade.
But during those days of scheduling, if the fix is public, hackers can obtain the same material you can.
They use AI to place the old and new code side by side, turning every change into a signpost.
For instance, if the new version suddenly adds a permission check, it effectively tells outsiders that the old version was not strict enough at that point.
Finding a change is still some distance from launching a real attack. But with the patch as a clue, attackers no longer have to search blindly through the entire codebase.
The security community calls these n-day vulnerabilities: the flaw has been disclosed and a patch released, but large numbers of users have not installed it.
Google’s report argues that using AI to work through n-days may be “more economical” than laboriously finding zero-day vulnerabilities nobody has seen before.
The reference material is already available. Changes before and after a software update can be compared directly, and the vendor’s release notes may also explain what was fixed.
If hunting zero-days is a closed-book exam, using AI to take patches apart is like copying homework from the answer sheet.
One change in Google’s tracking data deserves attention. In 2025, an average of 10.5 vulnerabilities per month were used in actual attacks. In the first eight months of 2026, that number rose to nearly 18.
Which vulnerabilities account for the increase? Zero-days rose from an average of eight a month to eleven, reaching 22 in August alone. A rough calculation using the monthly averages in the report puts known vulnerabilities, or n-days, at about three a month previously and about seven now.

The number of vulnerabilities exploited in the wild each month, January 2025 to August 2026. Dark blue indicates zero-days; light blue indicates known vulnerabilities, or n-days.
For anyone who has not installed patches, that light-blue portion deserves particular attention.
Between the vendor publishing its fix and your installing the update, the vulnerability remains in the old version, but attackers can already see where the vendor made changes.
Read the patch,
then move straight to attacking
The security community has had a joke for years: “Patch Tuesday, Exploit Wednesday.”
Microsoft usually releases patches together on the second Tuesday of each month. Once they are public, administrators may still be testing and scheduling, while attackers may already be investigating exactly what was fixed.
Previously, each step from reading a patch to writing exploit code required a person to pass the baton. What makes exploit_agent especially concerning is the attempt to hand that baton entirely to a machine.
When people use AI to assist analysis, they send it code, wait for an explanation, and then decide what to do next.
In an automated pipeline, however, the model’s output from one step directly becomes the next program’s input. Analysis feeds straight into code generation, and the resulting code immediately enters execution.
To connect this workflow, exploit_agent integrates multiple frontier and local models.
It focuses on popular web applications, continuously comparing code around each patch announcement. Once it finds a suspected vulnerability, it starts writing exploit code and then “opens fire automatically.”
Google’s report showed its “reading history” at the time:
A section of access-control logic in version 2.19.25 of the WordPress plugin Spectra.
Google did not say that it discovered a vulnerability there, but caught it in the act of “working through the problem.”
Looking further through the server, Google found an entire hacking toolkit, including scripts for internal-network reconnaissance, brute forcing and installing webshell backdoors.
Perhaps the most amusing was a cleanup script specifically designed to remove backdoors left by other hackers.
Although Google had not yet documented real-world successes for exploit_agent, the ability of large models to help hackers gain time had already been demonstrated in another live incident.
In late August this year, attackers exploited two vulnerabilities in the print-management software PaperCut as zero-days.
Within a day of disclosure, security researchers and Huntress had used large models to produce working exploit code.
By day four, GreyNoise had detected an attack affecting hundreds of organizations.
The hackers were very likely assisted by AI throughout: writing exploit code, testing whether it worked and listing targets to attack.
How fast was the intrusion? Only minutes elapsed between entering the first machine and obtaining privileges capable of administering the entire domain. That meant the attackers’ potential control extended far beyond the initial machine.
Although this attack was unrelated to exploit_agent, it reflects the same underlying issue: hackers have compressed attack preparation into a pipeline measured in hours, while most enterprises may still be waiting for next week’s meeting to approve updates.
When AI attacks automatically,
how often does it actually hit?
The exploit_agent configuration file contains two remarkably down-to-earth comments:
LLM API keys for automated exploitation (exploit_agent pilot);
Fill in your own keys here, not in the chat. Both lines are required.
Even an attack system described as “unattended” still needs a person to enter two lines of keys before startup. Its developer even has to repeat basic instructions as if guiding a novice, to prevent simple user mistakes.
“No human intervention” refers only to execution after the program is running. People must still set it up and insert the keys beforehand.
The “firepower” of the exploit code also needs to be viewed calmly.
At present, much AI-written exploit code may still be a “paper tiger.”
On October 21, official patches were released for two PHP vulnerabilities. In the following days, hundreds of supposedly working proof-of-concept exploits appeared online, but testing found all of them unusable.
Google’s analysis suggests that this batch of “padded-out code” was very likely produced by large models.
These frameworks have another clear weakness. Google describes them as “trading stealth for speed”: they are noisy, leave many traces and are easily exposed.
If they are crude, noisy and inaccurate, does that mean we can relax?
Quite the opposite.
Google is confident that cybercrime groups unconcerned with stealth will continue using these tools. For hackers whose profits depend on volume, even if nine out of ten shots miss, one hit can be enough to recover the cost.
Defenders should focus on how much human involvement these tools require, and which vulnerabilities they can repeatedly exploit in real environments.
The update notification arrives,
but remediation is only beginning
Attackers and defenders are now competing at two very different speeds:
On one side, machines work continuously, reading code, writing exploits and running scripts, day and night;
On the other, human ticketing workflows move through scheduling, testing and approval, waiting for the next maintenance window.
For individual developers and website maintainers, the most practical question is simple: after a security update is released, how long does it actually take to get your own system fixed?

Updating everything at once is difficult. The way forward is to prioritize.
In its guide to AI-assisted vulnerability management, security firm Mandiant recommends prioritizing by a system’s external exposure, the sensitivity of its data and evidence of actual attacks.
Fortunately, AI can help defenders gain time too.
Having it organize advisories, compare dependencies and draft remediation plans, alongside tests to check the changes, can eliminate a great deal of tedious screen-watching.
Beyond the mechanics of attack and defense, this also offers a reminder for the current debate over artificial superintelligence, or ASI.
People often worry about whether a future “godlike brain” might go out of control. exploit_agent shows us a more immediate risk:
AI does not need to develop superhuman intelligence. Once it can call tools continuously and turn analysis directly into action, the level of danger has already changed.
A vendor fixing its code does not automatically make your software immune. A patch sitting in the update list cannot block a single line of exploit code.
The window between a patch becoming public and the fix taking effect is exactly the time attackers want to seize.
They do not need AI to discover new vulnerabilities. They only need it to work through the old ones before you click “Confirm update.”
Perhaps, at the very moment you click “Remind me later,” the hackers’ AI is already reading that patch.
This article was originally published by Xinzhiyuan. Author: Yuanyu.
Related topics
After reading
Join the AINRK community
Read how to join the community and connect with people working in AI.




