A large software vendor recently released a patch for a high-severity vulnerability in its product. We wanted to test whether the patch would hold up when sufficiently stress-tested the way an attacker would, so we applied it and had our harness try to bypass the patch. In less than 30 minutes, it found the bypass.
We've reported it, and we'll keep the vendor and product unnamed until it's fixed.
Most teams handle a security patch the same way. The vendor or the open-source maintainers publish the fix with a security advisory that lists the affected versions. Your team upgrades to the fixed version through a package manager, an installer, or an automatic update, and then closes the ticket.
For years, this process worked. Many breaches came from known vulnerabilities on systems that nobody had updated, so the real race was between your team applying the patch and an attacker using the published bug.
But a patch can miss part of the problem. Vendors usually fix the exact path that someone reported, while a closely related path stays open. But finding those gaps took a skilled researcher days of reading code and testing so few people looked, meaning an incomplete fix could easily go unnoticed for years. Closing the ticket once the patch was applied was the right decision; although some risk may be left over, it was small, and finding variants was slow and expensive.
AI makes that work fast and cheap. An AI agent can read the code that a patch changed and from that, work out what the fix assumes. Then it can look for the paths that the fix doesn't cover and test them, in minutes, for every patch a vendor publishes. Attackers have the same tools, so they can find the gaps that used to be hidden, and the patch only serves to show them where to look. You still need to apply the patch, but a patched version no longer proves that the vulnerability is closed.
The bug was in a web platform that many companies run, and was rated high severity under CVSS.
The advisory was short. Applications lock some form fields so that users can't change them, for example, a field that stores the ID of the signed-in account. The bug lets an attacker change those fields client-side and have it trusted by the server. If an attacker can change that ID, they can get past access control, for example, by acting as another user. Once they get past that control, they're in the system.
The advisory didn't include a proof of concept, and although it named the affected releases, it didn't say which requests or field types the fix covers. So, from the advisory alone, your team can't tell if the patch closes the whole problem or only the example that someone reported.
We built both releases side by side. The patch works on the path the advisory described: a normal form submission. The old release wrote the value into server-side state. The patched release rejected the request and wrote nothing. We checked this in the data store as well as in the HTTP response.
Then we read the function that the patch changed. The new check is only a few lines:
accept_item(item, value, request):if (request == PAGE_SUBMISSIONand item.type == HIDDEN):# the added checkif (item.protected anditem not inpage.protected_items):reject("blocked")# still reached otherwisewrite_state(item, value)
The check runs only when two conditions are both true: the request is a page submission, and the field type is HIDDEN (a value that the page keeps in the form but doesn't show to the user). If either condition is false, the code skips the check and goes straight to write_state.
The patch misses a path that the check never runs on. A form submission isn't the only way to set server-side state. The page can also send a background (async) request that updates a single value. That request reaches the same code, but nothing marks it as a page submission, so the code skips the check. In the same session on the patched build, we sent both requests against the field that the form path now refuses:
# Patched build, same session,# no authentication.# 1. Form submission (reported)POST /<app>/submititem=<PROTECTED_ITEM>value=attacker_controlled=> 403 rejected# 2. Async value updatePOST /<app>/staterequest=set_valueitem=<PROTECTED_ITEM>value=attacker_controlled=> 200 value written
So on a fully patched system, with the ticket marked done, an attacker can still overwrite the protected field.
A variant is a second way to trigger the same underlying flaw. A published fix shows exactly where the original vulnerability was. If you read the function it changed and the conditions on the new check, you can find the paths the patch missed. Automated offensive agents now do this work quickly: they take a patch commit and probe the code around it on their own.
If your process ends as soon as the updated dependency version is deployed, automated offensive tools end up deriving far more value from the patch than your defense does.
A patch fixes one bug, but it also shows you where the application was weak. Before you move the ticket to done, use it as a chance to ask some wider questions:
If the answers are good, a variant that the patch missed can do far less damage.

Bring a recurring problem from your security backlog. We’ll look at what your team already knows, what it keeps re-checking, and how to get ahead of it.
Shlomie Liberow · Founder, aisy · shlomie@aisy.ai