Back to Explore
NewsVibeFix editorialUpdated Nov 19, 2026

The Patch Just Shipped and the Exploit Is Already There: Google Finds the First Fully Autonomous AI Exploitation Framework

On 16 November 2026, Google's Threat Intelligence Group reported the first fully automated vulnerability discovery and exploitation chain: no human in the loop. The evidence is an exposed server running exploit_agent, a framework that diffs code around patch announcements, writes exploits and fires them. The same report shows a North Korean cluster turning Claude Code's settings file into a backdoor trigger — and stolen cloud compute running up $100,000 bills in a day.

An analyst seen from behind in a dark security operations center, facing large screens showing world maps and network topology

In short: the patch just shipped, and the attack is already here

On 16 November 2026, Google's Threat Intelligence Group (GTIG), together with Mandiant, published its quarterly AI Threat Tracker, "Agentic Threat Activity Crosses a Significant Threshold". One sentence in it is worth stopping for: in the past quarter, GTIG confirmed for the first time that threat actors have used LLM frameworks to fully automate the whole chain of vulnerability discovery and exploitation, with no human in the loop. This is not a lab demo, and not a forecast. The evidence comes from a staging server the attackers themselves accidentally left exposed, running a multi-agent framework called exploit_agent, doing exactly this around the clock.

This matters not because there is a new term to learn, but because it rewrites the timeline defenders know best. The old common sense went like this: a vendor ships a patch, attackers need days or weeks to read the patch, find the flaw and write an exploit, and defenders use that window to patch. Now that timeline has been compressed to machine speed. The moment a patch announcement goes out, the framework starts diffing the code line by line, works out which flaw was fixed, writes an exploit, and fires it. The patch window still exists, but it is no longer measured in days. For people who write code with AI every day and plug agents into repositories and CI, the report carries a second message: the tooling the attackers use is, at its core, the same kind of tooling you use every day — pointed in the opposite direction.

What exploit_agent actually is: an exposed server, and a pipeline with no human in it

Start with the finding itself. GTIG found exploit_agent on an exposed staging server. The report's wording is careful: a "multi-agent vulnerability research and weaponization framework" that integrates multiple frontier and local LLMs, set up for "continuous differential analysis of popular web application software". The pipeline has four steps: watch patch announcements, diff the code before and after the patch, work out from the diff which vulnerability the patch fixed, draft an exploit, and then execute it automatically, without human intervention. The report's own words are that the framework "compares code before and after patch announcements, analyzes findings to identify potential vulnerabilities, drafts exploits, and automatically executes them without human intervention."

Alongside the framework, the server held two more things: data already exfiltrated from victims, and a set of ready-made attack scripts for internal reconnaissance, brute-forcing, installing webshells — and removing other attackers' webshells, so rivals would not compete for the same compromised box. Victim telemetry on the server also revealed the operator's taste: the targets of interest were French websites in the media and entertainment industries, and the education sector. GTIG published no success rate for the framework and no count of sites it broke into — those numbers are simply not in the report, and this article will not invent them.

The report prints two pieces of raw material. The first is a snippet of PHP: an access-control check from version 2.19.25 of the Spectra plugin (Ultimate Addons for Gutenberg), which the framework was examining at the time. This is a WordPress plugin with more than a million active installations, according to its wordpress.org listing. The report does not say the framework found a vulnerability in this code — only that it was inspecting the access-control implementation. That distinction matters, and it should not be written up as "the framework broke a plugin on a million sites". The second is two lines of Russian comments from the framework's configuration file, translated by Google as "LLM API keys for auto-exploitation (exploit_agent pilot)" and "Enter the keys yourself — right here, not in the chat. Both lines are required." Russian comments only show that the operator writes Russian, or wants you to think they do. Google explicitly does not attribute exploit_agent to any group, and the secondary coverage agrees: comments alone do not settle who ran it.

What it watches: work starts the moment a patch lands, and n-day flaws become pipeline feedstock

The key to understanding exploit_agent is understanding why it watches patches rather than zero-days. Finding a zero-day means searching an ocean, with a low hit rate. A patch is different: it is a document that says, in effect, "there used to be a hole here". The patch announcement and the before-and-after code disclose the flaw's location, cause and fix in one go. That document used to be read by humans. Now a framework reads it. GTIG states the logic plainly: attackers may find it more efficient to use LLMs to rapidly weaponize patched n-day vulnerabilities, because the research is bounded — compare source versions, read release notes, security research and proof-of-concept code for specific flaws — while hunting zero-days means casting a much wider net.

The report gives two cases that already happened, showing this pipeline is not a paper idea. The first is the PaperCut print management server flaws of late August 2026: CVE-2026-81578, an authentication bypass, and CVE-2026-82078, an unsafe dynamic class loading flaw, which chained together allow unauthenticated remote code execution. Within a day of disclosure, security researchers and the company Huntress had used LLMs to generate working exploits. GreyNoise reported a campaign four days after the initial disclosure in which a threat actor likely used LLMs to build and test exploits, assemble a target list, and run a widespread exploitation campaign against hundreds of organizations. GreyNoise also flagged the speed: the actor expanded an initial foothold to domain administrator within minutes.

The second case is the PHP vulnerabilities CVE-2026-109618 and CVE-2026-109619, discovered with LLM-enabled analysis. The official patches were released on 21 October 2026, but before that, a proof-of-concept video and already-patched code had been published — handing attackers the comparison material early. In the first days after the official patch, hundreds of claimed-but-non-functional proof-of-concepts appeared, likely generated with the help of LLMs. They broke into nothing, but they created a pile of verification work for defenders. Real exploits and fake exploits mixed together become a form of noise attack in themselves.

Comparison chart: monthly disclosed vulnerabilities doubled from 5,045 in January 2026 to 10,740 in August; monthly exploited vulnerabilities rose from a 2025 average of 10.5 to an 18 average for January–August 2026, and zero-days from 8 to 11 a month, spiking to 22 in August

Not just one tool: the attacker's side now has a whole bench of agents

exploit_agent is the headline, but what the report really wants to say is that a whole row of tools stands behind it. GTIG says multiple threat actors have now been observed abusing open-source, multi-agent penetration-testing frameworks to automate discrete phases and specific operational tasks during live intrusions. That is a different stage from last year, when attackers were merely "interested" in agents. Now they use them as standard kit. The report names four: ARTEX, CAIRN, CyberStrikeAI and PentAGI, plus HexStrike AI in experimentation, and the open-source agent framework Agent Zero and the inference service ZeroHollow.

Each framework comes with observed use. CAIRN is a multi-agent pentesting framework running an OODA loop — Observe, Orient, Decide, Act — in which specialist agents collaborate through a shared "blackboard", navigating from a starting parameter such as a target IP address toward an operational objective. GTIG observed CAIRN used in intrusion activity against targets including in the aerospace sector in the US. PentAGI is an open-source autonomous offensive framework designed to lower the barrier for entry-level operators; between late August and early October 2026, GTIG tracked a threat actor using a customized attack orchestration platform built off the open-source version of PentAGI to run systematic reconnaissance and vulnerability scanning against a wide range of organizations in Asia. CyberStrikeAI is an LLM-native offensive framework whose Go-based backend acts as a command-and-control and orchestration server, connecting commercial and open-weight LLMs to over 100 security tools, YAML attack recipes and custom scripts to automate end-to-end attack chains. HexStrike AI is an MCP-integrated harness that connects LLM clients to over 150 pre-installed offensive security tools, coordinated by more than 12 specialized autonomous sub-agents.

ARTEX is the best known of the set: an autonomous, multi-agent LLM-driven pentesting and offensive command-and-control platform written in Go, with an embedded Next.js web console, capable of automated Active Directory reconnaissance, privilege escalation, cloud-infrastructure profiling — such as harvesting Azure storage keys — and the synthesis and deployment of custom webshells. Its original repository was taken down by its creator in October 2026 because of widespread threat actor abuse. A campaign associated with ARTEX that Wiz has been tracking is tracked by GTIG as UNC7228 and overlaps with activity Microsoft tracks as the PRC-nexus actor STORM-0940. One judgement in the report is worth keeping: for now these frameworks "trade stealth for velocity" — unrestricted autonomous execution generates forensic traffic, relies on recognizable identifiers and leaves distinct code-level traces, which makes detection and mitigation more likely. But Google warns in the next breath that as the tools and the underlying LLMs improve, it expects "not only reduced human involvement in these operations but also increased stealth and sophistication of the activity". Part of the reason they can be caught today is that they are not yet quiet enough.

The second thread: your coding assistant's configuration becomes the poisoned point

The report has a second thread that speaks directly to vibe coding, and it sits closer to daily development. A suspected North Korean cluster, MIDNIGHT NEPTUNE — Google's new naming scheme, previously tracked as UNC1069 — combined LLM-enabled social engineering with abuse of organizations' AI tools as a supply chain attack vector in multiple intrusions targeting cryptocurrency organizations in North America and Europe. The sequence runs like this: fraudulent recruiter profiles on professional networking platforms make first contact, their profile imagery carrying SynthID watermarks that confirm the use of LLMs to synthesize deceptive identities; the targets are directed to fraudulent meeting platforms featuring "ClickFix" social engineering lures, which prompt them to run diagnostic fix scripts that execute likely LLM-authored staging scripts. Once inside, the actor pivots into internal code repositories and modifies .claude/settings.json configuration files, so that when users start up Claude Code, it automatically triggers the download of a backdoor GTIG calls SOMBERMEME.

Every step of that sequence is worth pausing over if you build software. First, the attack surface is no longer your code but your tooling configuration: a file like .claude/settings.json is normally treated as personal preference and rarely gets serious code review, yet it can trigger a download at startup — a ready-made supply-chain poisoning channel. Second, the attackers use generative tools to camouflage their own tracks: they generated GitHub Personal Access Tokens (PATs) named after Microsoft Copilot to mask their lateral movement — a token name that looks like a legitimate tool is less likely to stand out in a log. Third, this thread is the other side of the same coin as the main story: exploit_agent is attackers using agents to hit other people's systems, while SOMBERMEME is attackers turning your agent into their foothold. The report publishes no hashes, domains or command-and-control details for SOMBERMEME, and names no victims — and this article will not fill in any of those gaps for it.

The stolen compute is being monetized too: one hijacked bill can run past $100,000 in a day

Another section of the report is about money. Adversaries are increasingly repurposing stolen credentials and cloud resources to power unauthorized LLM tooling and autonomous operational pipelines — a practice called LLMJacking: break into a cloud environment and burn the victim organization's cloud compute or LLM resource quotas. Mandiant responded to several LLMJacking incidents through 2026, and the numbers are specific: in some cases, single-day fraudulent charges exceeded $100,000. In the most severe cases, cumulative resource abuse reached $1 million before remediation. In one investigation, two separate attackers reached the same environment using the same set of legitimate credentials, potentially sold or leaked on underground forums. One of them — likely a botnet or proxy service — generated millions of LLM API calls in approximately 24 hours before the credentials were revoked.

And the stolen resources are resold. GTIG tracks a class of illicit storefronts called "LLM Mixers", which sell buyers unauthorized access to LLM services and the underlying proxy infrastructure, routing traffic through a pool of stolen credentials and compute instances to keep the service reliable while spreading query volume across multiple victim environments to reduce the chance of detection. GTIG analyzed numerous LLMJacking vendor advertisements on Russian- and Chinese-language underground marketplaces and found that most services offer access to multiple models, including frontier and jailbroken models that advertise support for malicious cyber activity. Advertised prices range from $0.10 to $25 per million tokens; one vendor, APIMart, applies a 5x price increase on both input and output once a prompt exceeds 100,000 tokens; others, such as JetNight, charge monthly subscriptions instead. The same section notes a technical detail: attackers exploited CVE-2026-40217, a sandbox escape in LiteLLM that lets an attacker elevate limited-access inference keys ("Virtual Keys") into full administrative credentials. Credentials, compute and model access now form a supply chain with clear division of labor in underground markets: someone handles initial access, someone sells stolen credentials, someone runs the storefront and customer service.

The defender's window is shrinking: what the numbers say

The most easily overlooked — and arguably most important — set of numbers in the report comes from a GTIG analysis of vulnerability statistics from September 2026. Disclosures more than doubled between January and August 2026: from 5,045 in January to 10,477 in July, reaching 10,740 in August. Exploitation rose with them: from an average of 10.5 vulnerabilities exploited per month in 2025 to an average of 18 per month from January to August 2026. In that eight-month window, 141 vulnerabilities were both disclosed and exploited, already more than the 127 recorded for the whole of 2025. Zero-day exploitation grew more modestly, from an average of 8 per month in 2025 to 11 per month in 2026 — before spiking to 22 in the month of August.

But those numbers have another side, and it matters as much as the growth. Only 0.23% of all vulnerabilities disclosed in 2026 — roughly 1 in 431 — were ever observed in active exploitation. Disclosure doubling does not mean danger doubling: the overwhelming majority of vulnerabilities are never exploited by anyone, and a defender who prioritizes by "how many were disclosed" will drown. GTIG draws the same conclusion: organizations must move from unprioritized mass-patching to threat-intelligence-driven triage, combining targeted edge-defense with automated, agentic remediation. A shrinking patch window does not mean "patch everything immediately". It means "the handful of patches being watched must be applied faster than before". And how do you tell which patches are being watched? The report's signals are clear: a public proof-of-concept exists, there are signs of weaponization, the software is widely deployed and already being scanned. The more of those that apply, the higher the patch goes in the queue.

One figure deserves a separate correction, because it is easy to misread: zero-days spiking to 22 in August sounds like attackers suddenly found many more unknown flaws. But the report calls it a spike, and in the same section it states that the large majority of vulnerabilities exploited in January–August 2026 were n-days — known flaws — not zero-days. The real trend is not "more zero-days", but "known flaws weaponized faster". That distinction decides defensive strategy: if your patch cycle runs monthly, frameworks like exploit_agent are aiming precisely at that month-long gap; if your cycle already runs daily, they are aiming at the few hours between "the patch is known" and "the patch is installed".

The boundaries of this finding: what Google did not say matters just as much

Half of a threat intelligence report's credibility lies in what it says, and half in what it does not say. This report has several explicit gaps, and this article preserves them as they are rather than filling them in. First, attribution: GTIG does not attribute exploit_agent to any organization or country; the Russian comments are raw material, not a conclusion. Secondary coverage — CoinDesk, and SecurityWeek's write-up — likewise says only "suspected Russian-speaking" or says nothing about attribution at all. Second, results: the report publishes no success rate for exploit_agent, no count of compromised sites, no victim names, and no hashes, domains or command-and-control details for SOMBERMEME. Third, measurement: the trend figures come from Google's own telemetry — frontline Mandiant incident response engagements, global threat actor tracking, live platform defenses — which outsiders cannot independently verify. That does not make the numbers untrustworthy, but readers should know where they come from.

There is also a boundary in the report's defense section. Google describes its own defenses: Big Sleep, introduced in 2024, an AI agent that actively searches for unknown vulnerabilities; CodeMender, which discovers, patches and remediates vulnerabilities; Gemini 4 Carbon, described as its strongest model, built with layered defenses against cyber misuse — safety training, input/output classifiers, activation-based introspection probes, and chain-of-thought and agentic trajectory monitors designed to block requests to develop functional, weaponized exploits or malware tooling; and the Fairwind Program, which gives vetted defenders, security researchers and government partners access to advanced dual-use cyber capabilities. These are Google's own product descriptions, cited here as "Google says", not as independently verified facts. Mandiant has also published a hardening guide for this class of attack, and Google Security Operations has deployed specialized behavioral and volumetric rulepacks to detect use of ARTEX. Those are things defenders are doing — not evidence that the fight is already won.

Drawing the line against the site's two earlier security stories: three different things

The site has already published two security stories in the last two rounds, and readers could easily blur all three into one vague "AI security is in trouble". The lines are worth drawing. The cycle223 device-code phishing story was about abuse of an authentication flow: attackers tricking users through the device-code login flow to steal sessions — the goal was "log in as you". The cycle224 Microsoft Lazarus study was about model weights being tampered with: rewriting fewer than ten dormant neurons, with no retraining, so an agent passes every evaluation until a trigger makes it run an attacker's command — the goal was "make the model itself untrustworthy". This story is a third thing: attackers using agents to automate vulnerability discovery and exploitation — the goal is "compress the gap between patch and exploitation to zero". Different mechanisms, different attack surfaces, different countermeasures: device-code phishing is defended in login flows and session management, Lazarus in model provenance and weight integrity, exploit_agent in patch speed and exposure management. Reading all three as the same sentence — "AI is unsafe" — is like mixing three different prescriptions into one bowl of medicine.

One more confusion is worth clearing up. The "agent frameworks" in this report come in two kinds: the open-source pentesting frameworks attackers use (ARTEX, CAIRN, PentAGI), and the coding assistants developers use every day (Claude Code, Codex and the like). The first kind is attack tooling; the second is development tooling. But the SOMBERMEME thread shows exactly how the second kind becomes a springboard for the first once its configuration is tampered with. That is not to say coding assistants are themselves the problem — the report does not say that, and neither does this article. The problem is the trust level of configuration files: a file like .claude/settings.json is treated today as "personal preference", but because it can trigger a download at startup, it should be treated as code — reviewed when it enters a repository, logged when it changes, and read before you start an assistant inside a repository of unknown origin.

For people who vibe-code: four things you can do this month

Four things follow directly from this report, and none of them requires buying a new tool. First, triage patches by "is this being watched" rather than by "how long ago was it released". For high-severity patches in widely deployed software — WordPress plugins, print servers, PHP — the window is no longer "sometime this month" but "as soon as weaponization shows up". If your patch process has no step that watches proof-of-concept code and exploitation activity, add one now: in the PaperCut case, a widespread exploitation campaign appeared four days after disclosure, and anyone waiting for the monthly patch window was already late.

Second, treat agent configuration files as code. Claude Code's settings.json, Codex configuration, Cursor rules — anything that can trigger an action at startup belongs in version control and code review, with changes recorded. Before starting an assistant inside a repository cloned from the internet, read those configuration files first. In shared team repository templates, such files should be maintained by someone trusted, not edited casually by whoever happens to commit. The lesson of SOMBERMEME is not "don't use Claude Code". It is "don't let an unreviewed configuration file decide what your computer downloads at startup".

Third, manage credentials as if they will be stolen, not as if they will never be lost. In the LLMJacking cases, the attackers held legitimate credentials — harvested from public GitHub repositories, stolen from compromised endpoints, bought on underground forums. API keys, cloud accounts and CI tokens need three things: least privilege (only what they are supposed to do), regular rotation (so a leak has an expiry date), and usage alerts (so a bill that suddenly doubles in a day wakes someone up at night). A single-day bill of $100,000 is what "no usage alert" costs.

Fourth, don't let AI-generated proof-of-concepts set your agenda. In the PHP case, hundreds of claimed-but-non-functional proof-of-concepts, likely LLM-generated, created a pile of verification work for defenders. When exploit code circulates online, the first response should be "verify before panicking": does it have reproducible steps, is it backed by a credible security vendor, what does the vendor's official advisory say? Panic is itself part of what attackers want — with real and fake exploits mixed together, defenders' attention is the scarcest resource, and it should not be spent on fakes.

Conclusion: the attackers learned to use agents first — defenders have to catch up

The title of the November 2026 report — "Agentic Threat Activity Crosses a Significant Threshold" — is not rhetorical decoration. A threshold means a line that, once crossed, cannot be uncrossed. Attackers used to use LLMs mainly to go faster: write a phishing email a little quicker, write a script a little quicker, read code a little quicker, with a human still in the loop checking the work. Now frameworks like exploit_agent have wired both "find the vulnerability" and "exploit the vulnerability" into an automated pipeline, and the human has left the loop for the first time. GTIG's assessment is that this is not one group's secret weapon, but the inevitable result of open-source frameworks, an underground market and a pile of stolen credentials coming together — and once a threshold is crossed, copycats only multiply.

For people who vibe-code, the report really carries two messages. The bad news is that the tooling you use every day is also being used by attackers, with fewer scruples: your agent writes code for you, theirs writes exploits for them; your configuration file makes you faster, and two changed lines turn it into a backdoor. The good news is that the defenses have not become harder, only more urgent: patch a little faster, review configuration files a little more strictly, manage credentials a little more tightly, and verify exploit code before panicking. The most useful judgement in the report is worth quoting as it stands: these frameworks still "trade stealth for velocity", and the traces they leave make them easier to find. The window is still open — but it is shrinking at machine speed, and defenders can no longer afford to chase it at human speed.

Views 1Comments 0

Comments (0)

ME
0/1000
Loading comments...

Sources

Browse projectsPublish your project

Related articles

A developer with glasses types on a laptop at a wooden desk, an external monitor to the left showing C code on a dark background, a small plant on the desk
News
Microsoft's Coding Model Stops Playing Second Fiddle: MAI Code 2 Scores 96% of Opus 5.5 for 5% of the Cost — Read the Three Caveats First

On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.

Developer WorkflowProduct LaunchModel Updates
A developer types at a dual-monitor workstation; the left screen shows a dark code editor, the right a testing dashboard with green checkmarks and bar charts
News
Did Your Agent Get Better or Worse? AWS Open-Sources UAEF to Measure Agents from Every Framework with One Ruler

On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.

Developer WorkflowProduct LaunchTesting & Quality