top of page

Patch Management Wasn't Built for AI

Writer: Matthew Wold
Matthew Wold
10 minutes ago
7 min read

Throughout my cybersecurity career, there have been plenty of occasions when I've identified a serious vulnerability, brought it to the attention of the team responsible for remediation, and then watched the process unfold. First, the change needs to be reviewed and approved. Then there's testing to complete, a maintenance window to schedule, and eventually the patch gets deployed. Sometimes that means waiting until the following month.



What has always frustrated me is that, by the time we work through the entire process, the vulnerability might only be remediated a few days earlier than if we'd simply waited for the next regularly scheduled update cycle. And attempting to expedite the process often introduces an entirely new set of hurdles. Is it a zero-day vulnerability? Is it being actively exploited? Have the appropriate department heads signed off on the change?


I understand why these processes exist. I've spent enough time working in IT to know that an improperly tested update can cause significant problems, and nobody wants to be responsible for taking down a production system. Change management exists for a reason, and operational stability matters. But sometimes, all we do is get in our own way. For years, we've accepted these delays as part of the necessary balance between security and operational stability, but I'm beginning to question whether we can afford to continue operating this way, particularly as artificial intelligence changes how quickly vulnerabilities can be discovered and exploited.


The Time We Thought We Had

Historically, discovering a software vulnerability and developing a working exploit required considerable technical knowledge, time, and effort. Researchers might spend weeks or months examining software, identifying weaknesses, and determining whether those weaknesses could actually be exploited. Even after a vulnerability became publicly known, developing a reliable exploit wasn't necessarily straightforward. Attackers needed to understand the affected software, identify the conditions necessary for exploitation, and develop a method of taking advantage of the weakness.


Of course, there have always been exceptions. Some vulnerabilities are relatively easy to exploit, and attackers have been automating portions of this process for decades. But the time and expertise required to discover and exploit vulnerabilities provided organizations with at least some opportunity to respond, and our patch management processes developed around that reality. A critical vulnerability might receive an expedited remediation deadline, while less severe vulnerabilities could be addressed during the next scheduled maintenance cycle. Some organizations established 30-day remediation windows for critical vulnerabilities, with longer periods for lower-severity findings. Others adopted different schedules based on their operational requirements and tolerance for risk.


Artificial intelligence is beginning to challenge those timelines. AI-assisted vulnerability research is making it possible to examine large amounts of code, identify potential weaknesses, and accelerate portions of exploit development. Tasks that previously required substantial manual analysis can increasingly be assisted by automated tools. Perhaps more concerning is the possibility of using AI to analyze software patches themselves. When a vendor releases an update, the differences between the vulnerable and corrected versions of the software can reveal information about the underlying weakness. This technique, commonly referred to as patch diffing, isn't new. Security researchers and attackers have used it for years, but what's changing is the potential to automate much more of that work.


Imagine an automated system that monitors software releases, identifies security-related changes, analyzes the underlying vulnerabilities, and begins developing potential exploits. An attacker no longer necessarily needs to spend days manually examining every patch. Increasingly capable tools may be able to perform substantial portions of that analysis automatically. Not every vulnerability will be exploitable, and AI-generated exploits certainly won't always work, but attackers don't need every attempt to succeed. They only need to find one vulnerability that provides an opportunity. Meanwhile, the organization responsible for defending the affected systems may still be waiting for its next scheduled change advisory board meeting.


This also raises an uncomfortable question about how we prioritize remediation. When we ask whether a vulnerability is actively being exploited before approving an emergency change, what are we actually measuring? The absence of known exploitation doesn't necessarily mean a vulnerability isn't being exploited, and it certainly doesn't guarantee that it won't be exploited tomorrow. That distinction becomes increasingly important when the time required to develop an exploit may be shrinking considerably.


The Problem With Simply Patching Faster

The obvious response is to shorten our remediation timelines. If organizations previously allowed 30 days to remediate a critical vulnerability, perhaps that window needs to become seven days, 72 hours, or even less under certain circumstances. I think reducing those windows is necessary, particularly for vulnerabilities affecting internet-facing systems or those already being actively exploited. But changing a deadline doesn't necessarily change an organization's ability to meet it.


Consider an organization operating a critical production application that depends on several interconnected systems. A security vulnerability is discovered in one of those components, and a patch becomes available. The security team identifies the affected systems and recommends immediate remediation. Unfortunately, the application team hasn't tested the update, the infrastructure team is concerned about compatibility, and the business has scheduled an important operational event that makes an unexpected outage particularly undesirable. The organization now faces two legitimate risks. Delaying the patch increases the possibility that an attacker could exploit the vulnerability, while installing it without adequate testing increases the possibility of disrupting a critical business service. Neither risk disappears simply because someone changes the remediation deadline in a policy document.


For years, we've approached patch management largely as a scheduling and coordination problem. We identify what needs to be updated, determine when the work can safely occur, and organize the people necessary to complete it. But what if the real problem is that we've built environments where routine security maintenance is inherently disruptive? An organization that requires six weeks to safely deploy a critical security patch may have a problem that extends well beyond its patch management procedures. It may have an architectural problem, an automation problem, or an operational resilience problem, and those are considerably more difficult problems to solve than changing a remediation deadline.


Automation Needs to Become the Standard

If AI is going to accelerate vulnerability discovery and exploitation, organizations need to become equally serious about using AI and automation to improve their defensive capabilities. That doesn't mean handing an AI system unrestricted access to production environments and allowing it to install whatever updates it considers necessary. Anyone who has experienced a failed software update should recognize the potential problems with that approach. But there's considerable room between entirely manual patch management and completely autonomous remediation.



Imagine a process where newly disclosed vulnerabilities are automatically evaluated against an organization's hardware and software inventory. Affected systems are identified, their exposure is assessed, and available patches are evaluated against known dependencies and compatibility requirements. From there, automated testing could help determine whether an update introduces problems before it reaches production. Patches could be deployed to a small percentage of systems, monitored for unexpected behavior, and gradually expanded across the environment when those initial deployments are successful. If something goes wrong, the process should be capable of stopping the deployment and, where technically possible, returning affected systems to a known working state.


None of these concepts are particularly revolutionary. Automated deployment, staged rollouts, continuous monitoring, and rollback capabilities already exist in various forms. AI may improve our ability to coordinate and evaluate these processes, but we don't need to wait for some future breakthrough to begin implementing them. Rather than treating every update as a special event requiring extensive coordination, we should be working toward environments where routine updates can occur continuously, safely, and with substantially less manual intervention.


Human oversight will remain important, particularly when dealing with critical infrastructure and systems where an unexpected failure could have serious consequences. But oversight doesn't necessarily require a human being to manually approve every individual step in a well-established process. There's also an important distinction between deploying a patch quickly and deploying it safely. If we respond to AI-driven threats by simply eliminating testing and approval requirements, we risk creating operational disruptions that could be just as damaging as the security incidents we're trying to prevent. This is why I believe faster remediation and operational resilience have to evolve together. Otherwise, we're simply exchanging one risk for another.


Achieving that requires more than the security team generating vulnerability reports and assigning remediation deadlines. Infrastructure, application development, operations, and security teams all have a role in developing environments that can tolerate frequent changes without introducing unacceptable risks.


The Holiday Freeze

There's another established practice I think deserves reconsideration: the holiday change freeze. Many organizations restrict or suspend production changes during major holidays. The reasoning is understandable. Staffing levels are often reduced, employees are taking time off, and organizations want to avoid unexpected disruptions when fewer people are available to respond. I've worked in IT long enough to appreciate why these policies exist. Nobody wants to spend Christmas morning troubleshooting a failed update that could have waited until January.



But vulnerabilities don't disappear because we've entered a holiday freeze, and attackers certainly aren't obligated to observe our maintenance schedules. As automated vulnerability discovery and exploitation become more capable, the idea that organizations can simply suspend security maintenance for several weeks becomes increasingly difficult to defend. I'm not suggesting that organizations should abandon every restriction on production changes during the holidays. There's a reasonable distinction between postponing a discretionary application upgrade and delaying a critical security patch affecting an exposed system.


If a critical vulnerability is discovered on December 23rd, an organization should have a process for evaluating and addressing it without waiting until the second week of January. Ideally, that process shouldn't require assembling half the IT department during Christmas dinner, either. A holiday freeze might still make sense for major infrastructure changes or unnecessary upgrades, but it shouldn't automatically become a holiday security freeze.


Rethinking What Good Patch Management Looks Like

I don't believe traditional patch management is going to disappear overnight. Organizations have decades of technology, operational practices, and technical debt that can't simply be replaced because artificial intelligence has introduced a new set of challenges. There will always be systems that require careful coordination, applications that cannot tolerate frequent changes, and environments where the consequences of failure justify additional precautions.


But the growing capabilities of AI-assisted vulnerability discovery and exploitation are forcing us to reconsider how much time we can reasonably afford to spend evaluating, approving, and deploying security updates. For years, we've measured patch management performance largely by how quickly vulnerabilities are remediated and how consistently organizations meet their established deadlines. I wonder whether we should begin paying just as much attention to how safely and routinely an organization can make those changes in the first place.

Comments

Rated 0 out of 5 stars.
No ratings yet

Add a rating
bottom of page