On 16 November 2026, Google Threat Intelligence Group (GTIG) published a report saying it found, on an exposed staging server, an attack framework called exploit_agent that watches popular web application software, compares the code before and after each patch, works out what the patch fixed, drafts an exploit and runs it "without human intervention". Google says this is the first time it has seen threat actors use LLM frameworks to fully automate vulnerability discovery and exploitation without a human in the loop. For a startup, the practical meaning is simple: the time between "a patch is published" and "someone is attacking the unpatched version" is shrinking toward hours. If your patch process still runs on a monthly sprint, it is now slower than the attackers' tooling. Below is what Google found, and the patch playbook I'd put in place this week.
Who should care
- Anyone running internet-facing software they didn't write: WordPress and its plugins, self-hosted dashboards, admin panels, print servers, VPN appliances, open-source tools exposed on a public IP.
- Startups with a dependency-heavy web app: Next.js, Node, Python or PHP apps where a framework advisory lands every few weeks.
- Founders without a security owner. If nobody's job is to read advisories and ship patches, the gap is exactly what these tools exploit.
- Agencies and dev shops maintaining dozens of client sites on old versions.
If everything you run is a managed SaaS that patches itself, your exposure is mostly through your vendors. Everyone else should keep reading.
What actually happened
The report
The post is titled "GTIG AI Threat Tracker: Agentic Threat Activity Crosses a Significant Threshold", published 16 November 2026 by Aurora Blum, Kelli Vanderlee, Jess Xia and David Mainor for GTIG and Mandiant. It is the latest edition of Google's tracker of how attackers use AI, and it covers several things at once. The headline finding is exploit_agent.
exploit_agent: patches in, exploits out
According to Google, exploit_agent is a multi-agent vulnerability research and weaponization framework that "integrates with multiple frontier and local LLMs". Google does not name the models. Its loop, in Google's words, is continuous differential analysis of popular web application software: "It compares code before and after patch announcements, analyzes findings to identify potential vulnerabilities, drafts exploits, and automatically executes them without human intervention."
A few details from the report matter for defenders:
- What it targeted. Victim telemetry on the server suggested the operator focused on French websites in media and entertainment, and on the education sector.
- What it looked at. One figure in the report shows the agent analysing an insecure capability check in a WordPress plugin, Spectra (Ultimate Addons for Gutenberg) version 2.19.25. That is exactly the kind of software startups and agencies run and forget.
- What it did after getting in. Google found exfiltrated victim data and scripts for internal reconnaissance, brute forcing, installing webshells and removing other attackers' webshells.
- Who ran it. The configuration file contains Russian-language comments, including one telling the operator to put the LLM API keys in the file "not in the chat". Google does not attribute the framework to a specific group, and I won't either.
It isn't the only one
The same report names other agentic attack frameworks. Google says CAIRN, an open-source multi-agent pentesting framework, was used in intrusion activity including against aerospace targets in the US, and that a threat actor used a customised platform built on the open-source PentAGI against organisations in Asia between late August and early October 2026. ARTEX, the pentesting framework behind the WorkOS incident I wrote about in The WorkOS Breach and ARTEX, is covered too. For CyberStrikeAI and HexStrike AI, Google describes "experimentation"; some news coverage lumps them in with the frameworks used in intrusions, but Google's own wording is more careful.
The report also gives the bigger trend in numbers. Google says disclosures and exploits "nearly doubled between January and August 2026", and that zero-day exploits went from a 2025 average of 8 per month to 11 per month in 2026, before spiking to 22 in August.
The PaperCut preview
We already saw what this looks like at scale. In late August 2026, two PaperCut print management flaws (CVE-2026-81578, an authentication bypass, and CVE-2026-82078, unsafe dynamic class loading) were chained into unauthenticated remote code execution. Google says researchers produced working exploits within a day of disclosure, and that GreyNoise saw a campaign four days after disclosure that likely used LLMs to build and test exploits and to pick targets.
The Hacker News, reporting GreyNoise and Blackpoint research in September, said the campaign compromised at least 440 PaperCut instances at 395 organisations in 48 countries, mostly in education, and that one US high school went from initial access to domain admin in seven minutes. Those figures come from the researchers via THN, not from Google, and a GovTech summary attributes the organisation count to a different source, so treat the exact numbers as reported rather than settled. The shape is not in doubt: patch published, exploit built by machines, hundreds of victims within days.
Why this changes the patching math
For years the unspoken deal was this: a vendor ships a fix, attackers need days or weeks of skilled human work to reverse-engineer it, and most teams patch somewhere inside that window. Patch diffing was always possible, but it was expensive, so attackers spent that effort on big targets.
LLM agents make diffing cheap. A patch is now two things at once: a fix for you, and a precise map of the bug for anyone who compares the old and new code. Google's own line is that attackers "may find it more efficient to use LLMs to rapidly weaponize patched n-day vulnerabilities". In other words, the cheapest path is not finding new zero-days. It is attacking everyone who hasn't applied last week's patch.
A patch used to be a fix. Now it is also a map, and machines read maps faster than your sprint planning does.
This also connects to two other trends I have written about this month: AI finding bugs at volume (OpenAI's 948 Linux root exploits) and attackers stealing AI access to pay for all of this (LLMjacking; the same Google report covers LLM mixers that resell stolen model access). More bugs found, exploited faster, with someone else's compute.
The patch playbook to put in place this week
None of this needs a security team. It needs an owner, a list and some automation.
1. List everything that faces the internet
You can't patch what you don't know is running. Write down every public hostname and what software answers on it: your app, marketing site, WordPress or CMS, admin panels, monitoring dashboards, staging servers, old demo environments. Staging matters: Google found exploit_agent itself on an exposed staging server, and attackers' staging habits are no better than ours.
On each Linux server, see what is actually listening:
sudo ss -tulpn | grep LISTEN
Anything listening on 0.0.0.0 or a public interface that doesn't need to be is your first fix: bind it to localhost or put it behind a VPN or an authenticating proxy.
2. Set patch deadlines by exposure, not by severity alone
Here are the windows I'd set at a startup today:
- Internet-facing and known exploited (in CISA's Known Exploited Vulnerabilities catalog or confirmed by the vendor): same day, 48 hours at most.
- Internet-facing, critical or high, no exploitation yet: within 72 hours. The PaperCut timeline shows "no exploitation yet" can change in four days.
- Internal or behind authentication: within 14 days.
- Everything else: in the normal monthly cycle.
Write the windows down and name one person who owns them. A policy nobody owns is a wish.
3. Automate the boring patches
Operating system security updates on Ubuntu and Debian should install themselves:
sudo apt install unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades
For application dependencies, let a bot open the pull requests. A minimal Dependabot setup that groups security updates for an npm project:
# .github/dependabot.yml
version: 2
updates:
- package-ecosystem: "npm"
directory: "/"
schedule:
interval: "daily"
groups:
security-fixes:
applies-to: security-updates
patterns:
- "*"
Then make merging them cheap: a test suite that runs on every PR and a deploy you trust. Teams that patch slowly are usually afraid of their own deploys, not short of patches.
For WordPress, turn on plugin auto-updates and delete what you don't use:
wp plugin list --update=available
wp plugin auto-updates enable --all
wp plugin delete $(wp plugin list --status=inactive --field=name)
4. Check your images and lockfiles, not just your servers
A patched host running an old container image is still vulnerable. Scan what you ship:
npm audit --omit=dev --audit-level=high
trivy image your-app:latest --severity HIGH,CRITICAL
Rebuild images on a schedule even when your code hasn't changed, so base image fixes actually reach production.
5. Shrink what can be reached at all
The cheapest patch is the one you never need. Admin panels, /wp-admin, database UIs, CI dashboards and internal tools should not be reachable from the open internet. Put them behind SSO or a VPN, or an identity-aware proxy. Turn off staging environments when nobody is using them. Remove old demo deployments. Every exposed thing you remove is one less thing a diffing agent can match against a patch.
6. Subscribe to the advisories that matter to you
Pick the five or six products you would lose sleep over (your framework, your CMS, your runtime, your VPN or remote access tool, your cloud) and subscribe to their security advisories or GitHub security alerts. Add CISA's KEV catalog to that list; it has a JSON feed you can filter for the vendors you use:
curl -s https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json \
| jq -r '.vulnerabilities[] | select(.vendorProject | test("WordPress|Node|Vercel|Atlassian"; "i")) | "\(.dateAdded) \(.cveID) \(.vulnerabilityName)"'
7. Use virtual patching as a bridge, not a plan
When you can't upgrade today, a WAF rule or a blocked route can buy hours. Treat it as a bridge to the real patch with an expiry date, not as the fix.
8. If you were late, look before you relax
If an internet-facing system ran a vulnerable version for days after a patch, assume it may have been touched and check. exploit_agent installed webshells and removed other attackers' webshells, so look for recently changed executable files in web roots:
sudo find /var/www -type f \( -name "*.php" -o -name "*.jsp" \) -newermt "2026-11-01" -ls
Then check for new admin users, new SSH keys and unexpected outbound connections, and rotate the credentials that system could read. The startup security checklist covers the rest of that baseline.
What I'd do as a CTO
I would not panic about "AI hackers". The techniques here are old: diff the patch, find the bug, exploit the stragglers. What changed is the cost, and cost decides who gets attacked. When exploitation was expensive, small companies were safe by being boring. When it costs a few dollars of stolen model time, being boring and unpatched is exactly what gets you found.
So this week I would do three things. First, make one person the owner of patching, with the windows in step 2 written down. Second, spend a day removing internet exposure: staging servers, admin panels, old demos and unused plugins. Third, make patch deploys boring with automated PRs, tests and a deploy you trust, so that "patch within 72 hours" is a merge, not a project.
Then I would measure one number every month: how many days between a fix being published and it running in production for each internet-facing system. If that number is bigger than a week, it is your biggest security risk, bigger than most of the fancy tooling you could buy. Recent examples like the Next.js October update and the Node.js November release are a good test: how long did each take you?
If you don't have anyone who owns this, that is the gap a fractional CTO closes in the first month, and a technical advisor can at least set up the process for your team to run.
FAQ
What is exploit_agent?
It is the name Google Threat Intelligence Group gave to a multi-agent attack framework it found on an exposed staging server and described on 16 November 2026. It compares web application code before and after patches, identifies the vulnerability each patch fixes, drafts an exploit and runs it automatically, using several frontier and local LLMs.
Can AI really turn a security patch into an exploit?
Yes. Google says exploit_agent did exactly that without human intervention, and in the PaperCut case Google says working exploits existed within a day of disclosure and a likely LLM-assisted campaign started four days after it. Patch diffing is an old technique; AI makes it fast and cheap enough to use against everyone.
How fast should a startup patch now?
My rule: internet-facing systems with a known exploited vulnerability within 48 hours, other critical or high internet-facing issues within 72 hours, internal systems within 14 days. The exact numbers matter less than having an owner, automation and a deploy you trust.
Who is behind exploit_agent?
Google has not attributed it. The configuration file contained Russian-language comments, and the victim telemetry pointed to French media, entertainment and education websites, but Google does not name a group, so neither should anyone else on that evidence.
Is WordPress more at risk from AI-driven exploits?
Popular web software with lots of public patches is the natural target for this approach, and Google's report shows the agent analysing a WordPress plugin. The fix is unglamorous: auto-update plugins, delete unused ones and keep /wp-admin off the open internet.
Does a WAF protect me instead of patching?
A WAF can block known exploit patterns and buy time, but an agent that drafts its own exploits can vary them. Use a WAF as a bridge to the patch, never as a replacement.
Want a second pair of eyes on how fast your team actually patches, and what's exposed that shouldn't be? Book a 30-minute call and we'll go through it.
Sources
- GTIG AI Threat Tracker: Agentic Threat Activity Crosses a Significant Threshold (Google Threat Intelligence Group)
- Google Finds Hackers Using AI Agents to Build and Run Exploits From Software Patches (The Hacker News)
- Google says an AI framework turned security patches into exploits with no human in the loop (SiliconANGLE)
- Report: Cyber Criminal Use of AI Increasingly Sophisticated (GovTech)
- PaperCut Attacker Uses Hundreds of AI Agents to Compromise 440+ Instances (The Hacker News)
- Known Exploited Vulnerabilities Catalog (CISA)
Written By
Kunal Vohra
Technical Co-Founder & Fractional CTO
I've co-founded 6+ startups across India, the UAE, and the US, spanning AI, Web3, fintech, and cybersecurity. I write about the technical and strategic decisions that determine whether a startup thrives or stalls.
Comments
Loading comments…