Google’s threat team said Monday it has seen something it spent two years warning about: an AI system that finds a flaw, writes the attack, and runs it — with no person at the keyboard. The finding appears in Google Threat Intelligence Group’s quarterly AI Threat Tracker, published November 16, 2026, under the title “Agentic Threat Activity Crosses a Significant Threshold.”
“For the first time,” the report says, researchers observed threat actors “using LLM frameworks to fully automate vulnerability discovery and exploitation without a human in the loop.” Google called the moment a “critical inflection point.”
The patch itself became the weapon.
That last line is the part defenders should sit with. For years, the race after a patch release was measured in days: a vendor shipped a fix, researchers reverse-engineered it, and attackers eventually built an exploit for the machines that had not updated yet. Google says that chain now runs on its own, start to finish.
What Google found on the server
Google Threat Intelligence Group, working with Mandiant, found the framework on an exposed staging server — a test machine left reachable from the internet. The system, which Google dubbed exploit_agent, is a multi-agent framework that plugs into several large language models, both commercial frontier models and ones the operator ran locally. Google didn’t name the models in the report.
That server held more than the framework. Google found scripts for internal reconnaissance, brute-forcing passwords, installing webshells, and even removing webshells left behind by rival attackers, along with data taken from victims. A configuration file on the server carried Russian-language comments, one translated by Google as “LLM API keys for auto-exploitation (exploit_agent pilot).”
Google didn’t name a group or a country behind the operation, and the Russian comments alone do not prove who ran it. Victim telemetry on the server suggested the operator was interested in French websites in the media, entertainment, and education sectors. Google gave no victim count and no dates for the activity it saw.
One limit matters here, and Google is upfront about it. The report doesn’t identify a specific vulnerability exploit_agent actually exploited, gives no success rate for the framework, and reports no measured time from patch to working exploit. What it establishes is that the system existed, that it was built to run the whole chain by itself, and that it was sitting on a live server with victim data next to it.
How exploit_agent turns a patch into an attack
The framework does four things in a row, and none of them needs a person to approve it.
First, it watches popular web application software for patch announcements. Then it compares the code before and after each fix — a technique called differential analysis — and works out which flaw the update closed. Third, it drafts an exploit aimed at that flaw. Finally, it runs the attack against websites still on the old version.
Security researchers have a name for the flaws this targets: n-days. A zero-day is a hole with no fix yet. An n-day already has a patch — but plenty of systems have not installed it. The patch notes and the code change tell an attacker exactly where to look, which is why the window between a fix shipping and everyone applying it has always been the most dangerous period. Exploit_agent just shrinks that window to machine speed.
The shift is stark when set against Google’s own reporting from two months earlier. In the previous edition of the quarterly tracker, the group said it had not seen fully autonomous attack pipelines used against real targets. This quarter, it says, that changed.
The patch window is now a race
Exploit_agent is not the only example in the report. Google also describes open-source, multi-agent penetration testing frameworks already in use during real intrusions: ARTEX, CAIRN, CyberStrikeAI, and PentAGI, plus experimentation with HexStrike AI. The FBI has separately warned that the ARTEX tool helped hackers break into real networks in under three hours, including a US IT company and parts of South Korea’s financial sector.
The report points to two flaws in PaperCut print management servers, CVE-2026-81578 and CVE-2026-82078, which were chained together and exploited as zero-days in late August. Security researchers and Huntress Labs used large language models to produce working exploits within a day of disclosure, according to the report. Another campaign, tracked by GreyNoise, followed four days after disclosure.
The numbers behind the trend are blunt. Google says vulnerability disclosures and exploits nearly doubled between January and August 2026. Exploited zero-days averaged 8 a month in 2025, rose to 11 a month in 2026, and hit a peak of 22 in August alone.
None of that proves every patch becomes a working exploit within hours. It proves the direction of travel: the people writing exploits are automating, and the time defenders get after a disclosure is shrinking.
Why this matters
Patching has always been a chore that IT teams put off. A server that works does not feel urgent, and updates break things. That math just changed, because the cost of building an exploit collapsed while the cost of patching stayed the same.
The practical answer is not exotic. Patch internet-facing software fast, and patch the boring stuff too — print servers, WordPress plugins, the web apps nobody on the team thinks about. Google’s report even shows the framework inspecting access controls in version 2.19.25 of Spectra, a WordPress plugin with more than a million active installations. It does not say the agent found a flaw in Spectra. It shows where the agent was looking: at the software everyone runs and nobody watches.
There is a second lesson here for defenders, and it cuts the other way. The same models that write exploits can also read patches, triage alerts, and test fixes. Security teams that automate their own patching and detection are not copying the attackers — they are the only ones who can keep up with them.
Google’s report does not claim the age of the human hacker is over. It claims something narrower and harder to dismiss: the first fully automated patch-to-exploit loop has been observed in the wild, and the teams that still treat patching as a monthly task are now racing a machine.
FAQ
What is exploit_agent?
It is a multi-agent AI framework found by Google Threat Intelligence Group that compares software code before and after a security patch, drafts an exploit for the flaw the patch fixed, and runs it with no human in the loop.
Has exploit_agent actually hacked anyone?
Google has not named a specific vulnerability the framework exploited or given a victim count. Victim telemetry on the server pointed at French media, entertainment, and education websites.
Does this mean security patches are dangerous?
No. Patches still close the flaw. The risk falls on systems that stay unpatched after a fix ships, because the patch itself tells attackers exactly what was wrong.
What should companies do about it?
Patch internet-facing software as fast as possible, watch for unusual activity right after patch releases, and treat patch day as the start of the attack window rather than the end of it.
Sources: Google Threat Intelligence Group, BleepingComputer, The Decoder, The Register, VentureBeat, TechTarget
