AI exploit agents shrink the patch window: what Google's GTIG found

Google's GTIG reports AI agents that turn a patch into a working exploit with no human involved. How to shrink your own patch window, step by step.

AI exploit agents: AI agents turn a patch into an exploit in about a day

TL;DR

  • Google Threat Intelligence Group (GTIG) published its AI Threat Tracker on November 17, 2026. It reports attackers using agent frameworks that read a patch, write an exploit and run it on their own.
  • For two PaperCut print server flaws, working exploits built with language models existed within a day of disclosure, and a wide campaign followed four days after it.
  • The goal of this guide: shrink your own patch window for internet-facing software from weeks to days.
  • The key step is knowing where each component runs, at which version, before the next advisory lands.
  • You know it worked when a new advisory gets an answer to "where does this run?" within hours, and the fix is confirmed on every host.

What GTIG found

The GTIG AI Threat Tracker, written with Mandiant, covers the last quarter of attacker use of AI. Three findings matter most to anyone who runs servers and applications.

Patch diffing is now automated. GTIG says it has, for the first time, seen attackers use language model frameworks to find and exploit flaws with no human taking part. On an exposed staging server it found a framework it calls exploit_agent. The framework takes popular web application code from before and after a patch is announced, works out what was fixed, drafts an exploit and runs it. One example target in the report is a WordPress plugin.

The gap between disclosure and attack is short. GTIG points to two PaperCut print management flaws, CVE-2026-81578 (an authentication bypass) and CVE-2026-82078 (unsafe dynamic class loading). Chained, they give unauthenticated remote code execution, and attackers used them as zero-days in late August 2026. Researchers and the security company Huntress then had working exploits, built with language models, inside a day of disclosure. Four days after the first disclosure, GreyNoise reported a campaign against many organisations, in which the attacker likely used language models to write exploits and choose targets.

Most of the growth is in n-days. In GTIG's count, total disclosures and exploits came close to doubling between January and August 2026. Zero-days grew far more slowly: from an average of 8 a month in 2025 to 11 a month in 2026, then 22 in August. The rest of the rise is flaws that already had a patch. GTIG sums it up as language models shrinking the patch window for organisations.

Why the patch window matters now

The mechanics of the attacks are not new: stolen credentials and unpatched software. What has changed is speed. When an agent can turn a published patch into a working exploit in about a day, the slowest step is usually on the defender's side, and it is rarely the patch itself. It is finding out where the affected component runs.

That is an inventory question. A monthly scan, or a registry scan that only sees container images, says nothing about the PaperCut server on a Windows box, the WordPress site on a forgotten virtual machine, or the LiteLLM proxy a team set up last month. If finding those takes a week, an exploit built in a day has a week of open targets.

The report also shows two other paths that touch day-to-day operations:

  • LLMJacking. Mandiant handled several cases in 2026 where attackers broke into cloud accounts to use the victim's language model access and compute quota. GTIG reports single-day fraudulent charges above $100,000 USD in some cases and total abuse reaching $1 million USD in the worst. In one intrusion an attacker exploited CVE-2026-40217 in LiteLLM, which GTIG describes as turning limited "Virtual Keys" into full administrative credentials. Initial access often came from valid credentials, some of them collected from public GitHub repositories.
  • Coding agent configuration as an entry point. GTIG describes a suspected North Korean cluster, tracked as MIDNIGHT NEPTUNE, that changed .claude/settings.json files in internal repositories so that starting Claude Code fetched a backdoor GTIG calls SOMBERMEME. The general lesson applies to any coding agent: configuration files in a repository can run commands, so they deserve the same review as CI workflow files.

Before you start

  • A list of what is reachable from the internet: web applications, VPN and remote access, print servers, CMS sites and AI gateways. A spreadsheet is enough to start.
  • Access to the cloud accounts where language model services or GPU instances could be turned on, with permission to read audit logs and billing alerts.
  • Someone who can approve a short patch window for internet-facing systems without waiting for the next monthly cycle.
  • A staging copy, or at least a backup, of anything you plan to patch in a hurry.

Step by step

  1. Set a patch target in days for reachable flaws. For internet-facing software, treat a vendor patch for a remotely reachable flaw as urgent from the day it is published, not from the day it shows up in the CISA Known Exploited Vulnerabilities catalogue. GTIG's PaperCut example shows the campaign can start before a flaw is listed anywhere.
  2. Know where each component runs. For every internet-facing application and service, record the product, the version and the host or image it runs on, including the ones outside your main deployment path. Test it with one question: can you say within minutes whether you run PaperCut or LiteLLM, and where?
  3. Patch LiteLLM if you run it. GitHub's advisory for CVE-2026-40217 lists the litellm package from 1.81.8 up to, but not including, 1.83.10 as affected, and its text recommends 1.83.11 or later. Its stated workaround, if you cannot upgrade at once, is to block POST /guardrails/test_custom_code at your reverse proxy or API gateway. Then review who holds admin keys for the proxy.
  4. Move and scope language model keys. Take provider keys out of code and configuration files and into a secrets manager, give each application its own key with a spending cap, and rotate any key that has ever been committed to a repository.
  5. Review coding agent configuration in your repositories. Look for .claude/settings.json and similar agent configuration files, and check for commands that run when the agent starts. Require code review for changes to them, as you would for CI workflow files.
  6. Watch cloud accounts for LLMJacking signs. Alert on new IAM and service accounts, administrative policies attached to service roles, service accounts created and deleted in quick succession, instances with powerful GPUs, quota increase requests and sudden jumps in AI API spend.

How to confirm it worked

  • Pick the most recent advisory for software you run and time how long it takes to list every host, application and image that has it. The answer should take minutes, not days.
  • After patching, check the installed version on each host or image again rather than trusting the change ticket.
  • For LiteLLM, confirm the running version is outside the affected range and that admin keys are held only by the people who need them.
  • Trigger a test billing or quota alert in each cloud account and make sure it reaches a person.
  • Open a pull request that edits an agent configuration file and confirm it needs a reviewer before it can merge.

How Stackurity helps

Stackurity keeps one inventory of the software on your servers, deployed applications, repositories, container images, Kubernetes and cloud managed services, and checks every hour, matching new vulnerability advisories and the CISA KEV catalogue against it. End-of-life dates are checked daily. For a fast n-day, that turns step two from a project into a search:

Fixes page listing package upgrades such as log4j-core 2.14.1 to a fixed version, ordered by urgency.
Fixes instead of a list of CVEs: each upgrade that clears issues, most urgent first, with every place it is needed.
Fix page for upgrading lodash from 4.17.20 to 4.18.1, showing where it is installed, how to fix it and the issues the upgrade clears.
One fix: upgrade lodash 4.17.20 to 4.18.1, the recommended version, with where it is installed and the issues it clears.
  • Search once, see everywhere. Search a CVE, package, host or image digest and land on every asset that carries it.
  • Get the upgrade, not just the alert. Each fix names the version to move to and every issue it clears, ranked by exploitation and exposure.
  • Confirm the fix. After an upgrade, Check again asks for a fresh report and records whether the issue is fixed, partly fixed or still open.
  • Python packages and images. PyPI dependencies read from poetry.lock, Pipfile.lock and requirements.txt in repositories, and the packages inside container images, are matched against advisories, so a vulnerable package such as litellm shows up where it is declared or shipped.
  • Leaked keys. The agent and stackurity scan find keys, tokens and passwords written in files, including keys in the OpenAI, Anthropic, Hugging Face and Google formats, and only a masked preview and a fingerprint leave the machine, never the value.

The limits matter too. Stackurity tells you what is exposed and what to upgrade; it does not block attacks and does not watch cloud billing, so the LLMJacking signs above need your cloud provider's own alerts. WordPress plugins are inventoried with their latest release, but their own vulnerabilities are not matched yet. The remediation workflow shows how fixes are tracked through to the check after the upgrade. For the wider picture, see how to check if you are affected by a KEV-listed CVE and how to respond to a leaked API key. Start a free trial of Stackurity and see where a new advisory lands across your estate.

FAQ

What is an n-day vulnerability?

An n-day is a flaw that has already been disclosed and usually already has a patch. GTIG's report says language models make n-days quicker to weaponise, because the patch itself points at the code that changed.

What is exploit_agent?

It is the name GTIG gives to a multi-agent framework it found on an exposed attacker staging server. The framework compares application code before and after a patch, writes an exploit for the flaw and runs it, with no person involved.

How fast were the PaperCut flaws turned into exploits?

According to GTIG, researchers and Huntress used language models to build working exploits within a day of disclosure. Four days after the first disclosure, GreyNoise saw a broad campaign using them.

What is LLMJacking?

LLMJacking is when attackers break into a cloud account to use, or resell, the victim's language model access and compute quota. GTIG reports single-day fraudulent charges above $100,000 USD in some of the cases Mandiant handled.

Which LiteLLM versions does CVE-2026-40217 affect?

GitHub's advisory for the litellm package on PyPI lists versions from 1.81.8 up to, but not including, 1.83.10 as affected, and its text recommends upgrading to 1.83.11 or later.

Sources

Sources: Google Threat Intelligence Group, the AI Threat Tracker report (November 17, 2026); the GitHub Advisory Database entry for LiteLLM CVE-2026-40217; and the Stackurity product facts.