Written by Jeremy Souffir Founder, JTS Tech Services

The direct answer first. Until now, the AI attack stories we have covered needed something to already exist: a public exploit to download, a key left in a file, a password reused by a customer. Google's report today describes an attacker's system that needs none of that. It needs the same thing you receive when a vendor fixes a flaw: the patch. The framework Google found compares a piece of popular web software before and after each security update, reasons about what changed and why, drafts an attack for the hole the update closed, and runs it against websites still on the old version. Google's words: in the past quarter it identified threat actors using LLM frameworks to fully automate vulnerability discovery and exploitation without a human in the loop for the first time. The screenshot Google used to show it at work is the framework inspecting a WordPress plugin, Spectra, at version 2.19.25. The listing for that plugin on wordpress.org reports more than a million active installations. If your store, your blog, your landing-page builder or a side site you forgot about runs WordPress, this report is about the gap between the day a plugin update appears and the day someone clicks it.
What did Google publish today?
- A quarterly report with a new headline. Google Threat Intelligence Group's AI Threat Tracker for the quarter, published 16 November, is titled Agentic Threat Activity Crosses a Significant Threshold, and its summary says the adversarial AI landscape has reached a critical inflection point. The previous editions described attackers using chatbots as helpers. This one describes attackers running agents.
- An exposed server. Google says it identified an exposed staging server hosting a multi-agent vulnerability research and weaponization framework, dubbed exploit_agent, which integrates with multiple frontier and local LLMs. The server also held scripts for internal reconnaissance, brute-forcing, installing webshells and removing other attackers' webshells, plus data taken from victims. A configuration file on it carried Russian-language comments, one translated by Google as LLM API keys for auto-exploitation (exploit_agent pilot).
- A loop with no person in it. The framework runs what Google calls continuous differential analysis of popular web application software: it compares the code before and after a patch announcement, analyses the difference for the vulnerability that was fixed, drafts an exploit and, in Google's phrase, automatically executes them without human intervention. Victim telemetry on the server, Google says, suggests the operator was specifically interested in French websites in media and entertainment, and in the education sector.
- A wider cast. The same report lists other agent frameworks seen in real intrusions: ARTEX, an open-source penetration-testing tool whose abuse Amazon and the FBI have also described this month; CAIRN, used against targets including aerospace in the United States; and a customised build of PentAGI used for reconnaissance and vulnerability scanning across organisations in Asia between late August and early October. Two more, CyberStrikeAI and HexStrike AI, which wire a model to more than a hundred security tools each, Google has seen only in experimentation.
Whose findings these are, and what the report does not say
This is Google's own threat intelligence, drawn from a server the attacker left exposed, and Google is careful about its limits. The report gives no success rate for exploit_agent, no count of sites it got into, and no name or country for the operator; The Register, reading the same material, says only suspected Russian-speaking. Google does not say the agent found a flaw in the WordPress plugin in its screenshot. It shows the agent reading the plugin's access-control code, and it describes what the framework is built to do with what it reads. We have kept those two things apart below, and so should you: the mechanism is established, the body count is not.
Why is the example a WordPress plugin?
Because that is what the loop is for. Google's argument, in its own words, is that threat actors may find it more efficient to use LLMs to rapidly weaponize patched n-day vulnerabilities, as they can focus research on a finite set of source materials, whereas searching for zero-day vulnerabilities requires casting a wider net. An n-day is a flaw that has already been fixed. The fix is public, the old code is public, and the difference between them is a short, precise description of exactly where the hole was. A model does not need to be brilliant to read that; it needs to be patient, and it is. Popular open-source web software is the ideal feedstock: thousands of plugins, each with a public changelog, each installed on sites whose owners update on their own schedule, or never.
- The plugin in the screenshot. Figure 4 of the report is captioned, in full: Agentic framework inspecting access control implementations in the Spectra (Ultimate Addons for Gutenberg) WordPress plugin, version 2.19.25. The code shown is a capability check on the plugin's popup endpoint. The wordpress.org listing for that plugin, now renamed Spectra Legacy, shows more than a million active installations, a current version of 2.20.6 dated 3 November, and a changelog in which the last three releases, on 28 September, 9 October and 3 November, each say they fixed a security issue reported by Wordfence or Patchstack.
- What 2.19.25 means. It is the last version before 2.19.26, which in May closed a flaw rated 8.8 out of 10 that let a user with the low Contributor role run their own code on the server, according to the write-up by ZeroPath. Google does not say whether the agent was looking for that flaw, a different one, or found nothing. What the version number tells you is that the agent was studying code that was already a year of patches out of date, on a plugin where the vendor fixes something roughly monthly. That is the population it is built to find.
- Why this is different from August. On 30 August we wrote about an agent that read its host's kernel version, downloaded a public exploit and became root. That agent still needed someone else to have written and published the exploit. This one does not. The patch is the only input, and every patch comes with one.
- Why the drafts do not all work, and why that does not help you. Google gives an example from October: when the PHP project fixed two flaws on 21 October, early patched code and proof-of-concept exploits appeared before the official patches, followed by hundreds of claimed proof-of-concept exploits generated by language models that did not function. BleepingComputer's reading is that this flood added a significant burden on defenders. A site owner cannot tell a working exploit from a broken one by looking. The only move that works against both is to not be on the old version.

How much time does this leave you?
- Less than you planned for. The report's clearest timeline is from late August: for two flaws in PaperCut, a print-management product, working exploits appeared within a day of disclosure, and a scanning campaign against hundreds of organisations began four days after it. Google says the attackers went from first foothold to domain administrator within minutes. That was with humans still steering. The point of exploit_agent is to remove the day.
- The baseline is already rising. Google's numbers: disclosures and exploits nearly doubled between January and August 2026, and zero-day exploits, which averaged eight a month in 2025, averaged eleven a month this year and spiked to twenty-two in August. Agents did not cause most of that, but they are arriving into it.
- Google's own forecast is unquantified in the text we could read: as these tools and the underlying models improve, it anticipates not only reduced human involvement in these operations but also increased stealth and sophistication. BleepingComputer, reading the report's timeline graphic, puts Google's estimate at unsophisticated attacks run mostly by multiple agents with little to no human interaction within three months, and sophisticated fully autonomous ones within six. Treat those as a trade outlet's reading of a chart, not as a Google quotation, but note the order of magnitude: months, not years.
- The trade-off that currently favours you. Google says these frameworks trade stealth for velocity. An agent that tries an exploit the day a patch ships is noisy: it scans widely, it fails often, and it leaves logs. A site that applied the patch sees nothing but noise. A site that did not is the one the noise was for.
Three days earlier, Amazon described the other half
On 13 November Amazon Threat Intelligence published what its decoy sensors had captured between 3 October and 5 November: agents built on the ARTEX framework working through the internet for exposed AI tooling, pulling out the provider API keys stored inside, testing them and pooling the working ones to pay for more model time. The targets it names are the things small teams spin up in an afternoon: LLM gateways such as LiteLLM, One API, New API, Veloera and Sub2API, and app builders such as Dify, FastGPT, Langflow, RAGFlow, Open WebUI, LobeChat and Ollama. The techniques were a default master key never changed, an admin page that never asked for a password, an installation never finished, a secret left in client-side JavaScript. Amazon says it cannot verify the outcomes the agents reported and attributes the campaign with only moderate confidence. Its one-sentence verdict is the same one Google's report earns: none of the techniques in these campaigns were new; what AI agents change is the speed and persistence of the attacker. Its one piece of advice for anyone running an AI service: watch for unexpected spend or unusual usage, because that is what a stolen key looks like from the inside.
What does this mean for a store?
Sort what you run into two piles. The first pile is software somebody else patches for you the moment a fix exists: Shopify's core platform, a hosted checkout, a managed CDN. Nothing in today's report changes your position there, because the window between patch and update is not yours to close. The second pile is everything you installed yourself and are responsible for updating: a WooCommerce store and its plugins, the WordPress blog beside a Shopify storefront, the landing-page site the agency built two years ago, the theme app that bundles its own code, and, increasingly, the AI tooling in Amazon's list that someone on the team set up to try an idea. On 20 October we wrote that when one hacker's agents got into more than a hundred stores, the way in was the side site nobody was watching. Today's report explains what happens to the side site next: the moment its plugin vendor ships a fix, the fix becomes the map, and the race to apply it is run against something that does not sleep.

The two conclusions that both get this wrong
We are on Shopify, so this is Shopify's problem
Your storefront is. The rest is not. In our experience the typical mid-size brand on Shopify also runs a WordPress blog, a landing-page or events site, a headless front end on a framework with its own dependency list, and at least one internal tool. Google's agent does not care which of those takes the orders. It cares which one is running last month's version of a popular open-source component, and a brand's side properties are exactly where that is true, because nobody's job is to update them. The report's victim telemetry was media, entertainment and education websites: content sites, not checkouts. The pattern is the same for a brand's content sites.
We will read the advisory and decide whether it applies
That was the right process when the attacker needed a week to turn an advisory into an attack. Today's report removes the week. The agent does not read the advisory; it reads the code, and it has started before the advisory is written. A review step that takes three business days is no longer a review step, it is a three-day window with your name on it. For the second pile, the decision has to be made once, in advance: updates apply automatically, and the review happens afterwards, on a staging copy, with the option to roll back. The one exception is software where an update could break the checkout itself, and the answer there is a staging site that updates first and a person who looks at it the same day, not a calendar entry for next sprint.
The encouraging part
The agent and you are reading the same document. It needs the patch to write the exploit; you need the patch to be immune to it. There is no version of this race in which the attacker has something you do not. If your site is on the fixed version by the time the agent's draft is ready, the agent has nothing to run, and Google's own description of the current frameworks, loud and fast rather than quiet and patient, means it will move on to a site that is not. Automatic updates, a staging copy, and a short list of what you actually run are not sophisticated controls. They are the finish line, and it is close.
What to do this week
- Write down the second pile. Every site, plugin, theme, framework and self-hosted tool your business runs that somebody on your side has to update. Include the ones the agency built and the one a developer set up to test an AI idea. If the list has to be assembled from memory, that is the finding.
- Turn on automatic updates for plugins and themes on every WordPress property, including the ones that are not the store. WordPress has offered per-plugin auto-updates since version 5.5. Pair it with a daily backup you have actually restored once, so that the rare update that breaks something costs you an hour rather than an argument about whether to update at all.
- Check the plugin in the report, and the ones like it. If any of your sites runs Spectra, confirm it is on 2.20.6 or later. Then open the plugin list and look for anything with a changelog entry in the last ninety days that mentions a security fix; those are the ones whose patches have already been read by someone.
- Give the side sites a staging copy. A clone that takes updates a day before production, with a person who loads the key pages the same day, is what turns automatic updates from a risk into a routine. For a WooCommerce store this is the only safe way to let payment and shipping plugins update themselves.
- Find the AI tooling. Search your cloud bill and your DNS for the names in Amazon's list: LiteLLM, One API, Dify, Langflow, RAGFlow, Open WebUI, Ollama and their relatives. For each one, confirm it is behind a login, that the default administrator key has been changed, that it is not reachable from the internet unless it must be, and that the provider key inside it has a spending limit and an alert.
- Set spend alerts on every AI provider account. Amazon's advice is the cheapest control in this post: a key that is stolen is a key that gets used, and the first sign is a bill. An alert at twice last month's usage costs nothing and arrives in hours rather than at month end.
- Look at your access logs for the week after any plugin fix. Google says the current frameworks trade stealth for velocity. A burst of requests to a plugin's endpoints from unfamiliar addresses, in the days after the vendor ships a fix, is what an automated attempt looks like, and it is visible in ordinary logs if anyone opens them.
Why this is worth getting help with
None of the steps above is difficult. The difficulty is that nobody owns them. The store team owns the storefront, the agency owned the blog until the contract ended, the developer who set up the AI gateway has moved on, and the hosting company patches the server but not what runs on it. Today's report describes an attacker that works across all of those at once and never forgets one. The defence has to be organised the same way: one person who holds the inventory, decides the update policy for each item, confirms the staging copy exists and the alerts are set, and reviews the list monthly as the business adds things. That is a leadership job, not a project, and it is the kind of work our Fractional Head of AI & Digital engagement exists for: a few days a month of senior direction that sets the policy, assigns the owners, vets the vendors and tools your team is adopting, and keeps the second pile from growing back. If the list in step one is longer than you expected, that is the conversation to have first.
Sources
- Google Threat Intelligence Group: GTIG AI Threat Tracker: Agentic Threat Activity Crosses a Significant Threshold (16 November 2026; the exploit_agent server, the differential-analysis loop, the French-website telemetry, Figure 4 on the Spectra plugin, the n-day argument, the PaperCut and PHP timelines, the disclosure and zero-day counts, and the ARTEX, CAIRN and PentAGI findings)
- The Register: Google: AI agent turned a security patch into a working exploit with no human help (Jessica Lyons, 16 November 2026; the suspected Russian-speaking operator and the webshell-removal scripts)
- BleepingComputer: Google warns that fully-automated AI attacks are coming soon (Bill Toulas, 16 November 2026; the three-month and six-month reading of the report's timeline, and the patch-window and PHP proof-of-concept observations)
- Amazon Threat Intelligence, AWS Security Blog: Amazon Threat Intelligence observes threat actors running cybercrime campaigns with ARTEX AI agents (CJ Moses, 13 November 2026; the MadPot capture window, the targeted gateways and app builders, the techniques, the verification caveat, and the spend-monitoring advice)
- The Hacker News: Amazon Uncovers AI Agent Campaign Targeting LiteLLM, Dify, and Other Apps for API Keys (16 November 2026; the technique table and the ARTEX repository history)
- WordPress.org: Spectra Legacy – Gutenberg Blocks (plugin listing read 16 November 2026: 1+ million active installations, version 2.20.6, last modified 3 November 2026, and the changelog entries crediting Wordfence and Patchstack)
- ZeroPath: Spectra Gutenberg Blocks CVE-2026-7465: Brief Summary of a Contributor-Level RCE via Block Callback Injection (the CVSS 8.8 flaw in versions up to 2.19.25 and the fix in 2.19.26)
- JTS Tech: Agents don't need zero-days (30 August 2026; the agent that downloaded a public exploit, and the patch-deadline argument this post extends)
- JTS Tech: The agents came in through the side site (20 October 2026; the 1,200-store campaign and the unwatched properties)
- JTS Tech: The key you forgot you published (18 October 2026; exposed keys as the way in)
- JTS Tech: Your automation layer is the attack surface (2 October 2026; the four-day gap between disclosure and exploitation Google observed then)


