Google Warns: Agents Can Turn Patches Into Exploits

Google says attackers now use agents to compare a patch with old code and weaponize the bug. The defense is a shorter patch window, not a smarter prompt.

By Muhammad Saif and Aashan Khan · Techtribe co-founders

AI-powered vulnerability exploitation, in the form Google described on November 16, 2026, does not start with a mysterious new bug. It starts with the patch you have not installed. Google's Threat Intelligence Group says adversaries are now using language models and agent frameworks to automate the dull middle of vulnerability work: read the release notes, compare the old code with the new code, and produce something that hits the systems still running the old code. They call the result an n-day. The vulnerability is public. The race is who moves first, the person who updates, or the agent that diffs the update.

That is a different article from the one about a single IRC bug. CVE-2026-114713 is one known-exploited flaw with a version to print. This note is the factory that turns many such flaws into campaigns before your change window meets. It is also different from a lab that spent days looking for bugs on purpose. The ninety-hour research note is what a defender's agent looks like when a person owns the target. GTIG is describing the other direction: nobody asked your server to be the target, and there is no human waiting to read a write-up before the next host is tried.

This piece stays on the defender's side of that report. It does not show how to diff a patch into an exploit, and it does not repeat anyone's proof of concept. The useful part is the clock, and what a software team can still change about the clock.

What "differential analysis" means without the recipe

A patch is a confession. It says the old behavior was wrong, and it shows the lines that changed. A person who understands the software can often see the bug by reading only that difference. GTIG's point is that an agent can be pointed at that difference continuously, for many projects, and can draft an attack from the difference without a researcher sitting in the loop.

The report is plain about why attackers would prefer this to hunting for unknown bugs. An n-day has a finite pile of source material: two versions of the code, the release notes, public research, and any proof of concept already posted. A zero-day requires searching a much wider space. Models are better at the finite pile. GTIG's own counts, from a September look at vulnerability statistics, fit that story. Between January and August 2026, disclosures and exploits nearly doubled. Zero-day exploits rose only from a 2025 average of about 8 a month to about 11 a month in 2026, then spiked to 22 in August. The volume is in the known bugs, not in the unknown ones. If your strategy is "we will worry when it is a zero-day," you have aimed at the smaller pile.

The report also says the lower barrier produced a wave of exploits that claim to work and do not. That sentence matters as much as the successful ones. A model that emits a confident script is not a model that tested it. Defenders who chase every upload will spend the week debunking noise. Defenders who ignore every upload will miss the one that was tested. The job is a version check plus a log review, not a debate with a gist.

The staging server GTIG found

In the past quarter, GTIG says it saw threat actors fully automate discovery and exploitation without a human in the loop, which it distinguishes from earlier work that only automated pieces of the sequence. The concrete object is an exposed staging server hosting a framework GTIG dubbed exploit_agent. It integrates with frontier models and with local models. It is set up to keep comparing popular web application software before and after patch announcements, analyze the difference, draft exploits, and run them. GTIG says the server also held data taken from victims, and scripts for what happens after a foothold: internal reconnaissance, password guessing, installing webshells, and removing other attackers' webshells. The victim notes on that server pointed at French websites in media, entertainment, and education.

Read that as a description of an operation, not as a kit to copy. The details that matter for a builder are these. The server was exposed, which is how GTIG saw it. The loop did not wait for a person between "patch posted" and "try it." The target list was ordinary websites, not a fantasy list of banks. Popular web software is the software a generated app vendors without anyone noticing: a WordPress plugin, a PDF service, an admin package, a print server left on a side port. GTIG even shows the framework looking at an access-control function in a WordPress plugin. The lesson is not the function. The lesson is that an access check written in a plugin is now something an unattended agent will read the week the vendor changes it.

A comment GTIG translated from the operator's environment file is the tell for how these crews treat keys. The comment says the model keys for automatic exploitation go in the file, not in the chat, and that both lines are required. They have learned the same lesson a careful engineering team learns: do not paste the production key into the prompt. The people automating the attacks are ahead of a lot of product teams on that one habit. Your agent environment should not be the looser of the two.

Two public clocks from the same report

GTIG uses two incidents to show the speed, and both are about known software, not a secret zero-day brand.

In late August 2026, two PaperCut bugs were exploited as zero-days and, chained, allowed unauthenticated remote code execution. GTIG names them: CVE-2026-81578, an authentication bypass, and CVE-2026-82078, unsafe dynamic class loading. Using models, researchers and the company Huntress produced working exploits within a day of disclosure. Greynoise reported a campaign four days after disclosure in which a threat actor likely used models to build and test exploits, build a target list, and hit hundreds of organizations. Greynoise also said an initial foothold was expanded to domain administrator within minutes. Four days is inside a normal change window. Minutes is inside a normal on-call page. If PaperCut, or anything like it, is on your network because a tutorial once needed printing, it is on this clock. Search for it. The absence of a ticket is not the absence of the service.

The PHP pair is the n-day version of the same clock. CVE-2026-109618 and CVE-2026-109619 were found with model-assisted analysis. Before the official patches on October 21, 2026, a proof-of-concept video and early patched code were already public. Anyone could compare versions and try to build an exploit before the patch most administrators would install. In the first days after the official patch, hundreds of claimed exploits appeared, many of them non-functional and likely model-written. The security community had to sort the real ones from the noise while also watching for actual exploitation. That is the tax. The attacker needs one working attempt. The defender needs to recognize it among hundreds of fakes, and also needs the servers patched.

UnrealIRCd's November release landed in this world. CISA put it on the known-exploited list with a three-day federal due date. That due date is what a catalog looks like when exploitation is already happening. An agent that diffs patches does not need your IRC daemon to be famous. It needs the daemon to still be the old version on a reachable port. Print the version. If you cannot, you are in the window.

What shrinks the window for a product team

You will not out-research GTIG. You can be a boring target. Boring means the internet-facing version matches the patched version, the admin panel is not on the open internet, and an old container an agent generated is not still answering.

Start with the inventory the patch factory assumes you do not have. Every hostname that answers. Every image tag. Every plugin. The generated app is the usual miss: a compose file copied from a post, a SaaS widget with its own version, a "temporary" admin host. Write the version that is running, from the running process, not from the Dockerfile you hope was deployed. "Latest" is not a version. A scanner that only looks at the application repo will not see the daemon beside it.

Then put a clock on internet-facing software that is not your code. Your own application can wait for review. The plugin, the PDF renderer, the print server, and the gateway cannot wait a sprint if the vendor shipped a security release yesterday. A same-week rule for those, with a named owner, beats a policy that says "critical within 30 days" and then argues about the word critical. GTIG's four-day PaperCut campaign is the argument. Thirty days is the campaign's vacation.

Do not let an agent apply the patch and also rewrite the app in the same afternoon. A security update is a version bump and a restart. A refactor is a different change with a different rollback. Mixing them is how you cannot tell whether the outage was the patch. The Postgres note on this site makes the same split for a database minor. Keep it.

Treat proof-of-concept posts as untrusted until you have a reason. After the PHP patches, most of the published exploits did not work. Blocking your week to reproduce them is how the noise wins. Check whether you run the affected version. If you do, patch. If your logs show the behavior the vendor described, then you have an incident. A random script from a forum is not the incident.

Edge software you do not own still needs a ticket. If a hoster hides the version, ask and keep the reply. A logo is not a patch level. If the hoster cannot patch, the mitigation the vendor offered, or turning the feature off, is the work. Leaving it up because the dashboard looks fine is the window.

Pre-release and preview channels are part of the report's warning. Attackers compare code that is public before the stable patch, including preview branches. If you run a preview image in production because a feature you wanted was only there, you are running the code the diff will be written against, on a delay. Pin a release. Read the security notes for that release. A floating tag is a future diff.

What this does to a team that ships with agents

The same models that write your pull requests can write the exploit for the dependency your pull request did not bump. That is not a reason to stop using the tools. It is a reason to make dependency updates a first-class path, with a person owning the versions that face the internet, and with production credentials kept out of the agent that is allowed to open those pull requests. An agent that can deploy and can also read the security mailbox will eventually be asked to "just handle the CVE." Without a version inventory, it will handle the CVE it can see and miss the container it cannot.

Log the versions you checked and the date. The next report will name a different product. The inventory is what makes the next report a one-hour job instead of a search. If you cannot list the internet-facing software in the time it took Greynoise's actor to go from foothold to domain admin, the list is already too slow. Write it on a weekday.

A SaaS product that vendors other people's servers has this problem twice: once for the code you wrote, and once for the code you embedded. Customers will ask which one you patch. Answer with the list, not with a sentence about taking security seriously.

Generated apps make the window wider than a normal company's change calendar, because the person who can patch is often the person who no longer recognizes the service. A compose file from a tutorial, a plugin the agent added to satisfy a screenshot, a PDF renderer chosen because the import was one line: each of those has a version, and none of them appear in the sprint board. When GTIG says popular web software is what the staging server was built to watch, that is the list. Search the repo for image tags and the cloud account for listening ports. Then decide, in writing, which of those you still need. Turning a service off is a patch of a kind. It is the fastest one, and it is the one an agent told to "update everything" will not choose, because turning something off looks like a failure in a demo.

Keep a second person, or at least a second day, between "the agent opened a pull request that bumps a security release" and "that bump is in production," unless you already trust the test that proves the bump. The speed GTIG describes is an argument for a short human loop, not for no loop. A bad bump on a Friday is an outage you caused while trying to leave the window. The discipline is: version printed, change is only the bump, rollback is the previous version, someone other than the model looks at the diff if the diff is larger than a version number. That is a small process. It is the process that makes the rest of this article true in a repo an agent edits every day.

What to do this week

  1. List every internet-facing service, including plugins, sidecars, and old containers. Record the running version, not the tag in a README.
  2. For anything with a security release in the last two weeks, patch it or take it off the internet. Do not mix the bump with a feature change.
  3. Ignore unverified exploit posts until the version check is done. If you are on the affected version, the patch is the response. The script is not.
  4. Pin release versions. Stop tracking preview channels in production.
  5. Keep production credentials out of any agent you ask to bump dependencies. The crews in GTIG's note already keep their keys out of the chat.
  6. If a hoster hides versions, open a ticket and keep the answer. A green dashboard is not a patch.
  7. Put the list where the next person can find it. A patch window you cannot show is a patch window you do not have.

The patch is public. The agent that reads it does not need your permission. The version you are running is the only part of that sentence you control.

If this is your app, send the repo.

A 30-minute scope call. We read what is live, name what is dangerous, and quote a fixed scope.

How Techtribe closes a patch window on a generated app

We read the repo and the hosts, write down the versions that are actually running, and separate a security bump from a rewrite. You get that list, the things to take off the internet, and a fixed order for the updates. We do not paste exploit code into the ticket, and we do not let an agent "clean up" the app in the same change as the patch.

A handful of forgotten containers can be a fixed pass. A product with no version owner on anything it embeds is a Production MVP. The scope call is 30 minutes with a founder, and it is where we say which you are in.

Bring whatever you know is exposed, and say if you have never printed the versions. That is a fine place to start.

The fixed scope for taking a generated app to production is a page per tool: Lovable, Bolt, v0, and Replit.

Questions

What did Google say about patches and exploits?

On November 16, 2026 Google's Threat Intelligence Group said attackers are using agents to compare code before and after a patch, find the bug the patch closed, and turn that into a working exploit against systems that are not updated yet. They called this n-day work, not a new class of zero-day.

What is exploit_agent?

GTIG described an exposed staging server running a multi-agent framework it dubbed exploit_agent. The framework compared popular web software before and after patch announcements, drafted exploits, and ran them without a person in the loop. GTIG said the operator's notes pointed at French media, entertainment, and education sites.

Did AI-written exploits all work?

No. After PHP patches on October 21, 2026, GTIG said hundreds of claimed proof-of-concept exploits appeared and many did not work. Defenders still had to check each one. A flood of bad exploits is its own cost.

What should a team shipping a web app do?

Know the version that is actually running, patch internet-facing software on a clock shorter than a week, and do not treat an unverified proof of concept as evidence you were hit. A generated app that pinned an old image is in the window these agents are built to use.

Book a free call

Have a vibe-coded app in production?

30-minute free call. We'll read what you have, name what is dangerous, and quote a fixed scope.