The Devil Is in the Delta

AI is accelerating our ability to find what changed. The harder problem is understanding what that change can reach.
A friend said something to me on November 17 that immediately caught my attention.
"The devil is in the delta."
I told him I was stealing it.
The traditional expression puts the devil in the details. But delta, the mathematical shorthand for change, gets at something more specific. Especially if you spend much time around software, networks, or the people responsible for keeping complicated systems running.
My brain immediately translated it into another version:
The devil is in the diff.
A diff compares two versions of something and shows what changed. A permission check appears. A configuration value moves. A dependency gets updated. A function that used to accept a request now rejects it.
To a developer, that difference may represent a repair. To an attacker examining the same versions, it may identify the weakness that needed repairing. To the engineer responsible for deploying it, the difference raises another question entirely: what else will this affect?
Same change. Three different problems.
And increasingly, three very different clocks.
I've been writing about the infrastructure surrounding AI, the concentration of authority in control systems, and what happens when automation connects actions that used to require someone to coordinate them. The security disclosures and outages between November 12 and November 17 bring those threads together.
The size of a change tells you remarkably little about the size of its consequences.
A few lines can alter who has access. A routing decision can redistribute an entire service's workload. A script delivered by a trusted provider can change what thousands of browsers do.
The diff might be tiny.
The authority attached to it might be enormous.
When a Repair Becomes a Lead
When a vendor releases a security patch, it necessarily changes something about the software's behavior. That change can provide a useful research lead.
Suppose the previous version of an application processed a request without an explicit authorization check. The patched version adds one. That doesn't automatically prove the old version was exploitable; other controls might exist elsewhere. But it gives a researcher a narrower and potentially valuable question to investigate.
Why did this check become necessary?
That is the basic logic of patch diffing. Researchers and attackers have been doing it for years. The emerging change is how much of the work can be connected into an automated process.
On November 16, Google Threat Intelligence Group and Mandiant described an exposed staging server hosting a framework called exploit_agent. It was configured to compare software versions around patch announcements, analyze potential vulnerabilities, draft exploits, and execute them without a human directing each step. Google also reported finding victim data and post-compromise tooling on the server. That is evidence of an operational environment, though it doesn't establish that every attempted exploit succeeded. Google Threat Intelligence Group
This connects directly to the argument I made in The Model Behaved. The Attack Still Worked.: the important development is the orchestration between technical actions.
Comparing code, investigating a suspicious change, testing a hypothesis, interpreting the result, and deciding what to try next are familiar activities. Connecting them into a system that keeps working changes the economics of the operation.
The attacker can spend less time moving between the steps.
Meanwhile, the defender still has to operate the business.
The FBI's November 13 advisory on the ARTEX autonomous penetration-testing framework illustrates that broader acceleration. It described some intrusions progressing from initial targeting to privileged access in under three hours. That figure measures an intrusion sequence, not the time required to reverse-engineer a patch. But it shows why the distinction between an AI assistant and an automated operational framework matters. FBI FLASH
A known vulnerability can be quite sufficient when the affected organization hasn't finished addressing it.
That is the appeal of n-day exploitation: the weakness is already public, frequently with a fix available. Attackers can focus their attention on a defined problem while defenders locate affected assets, evaluate exposure, test changes, and deploy protection.
The patch is available. The environment is still vulnerable. Both statements can be true.
And the information can escape before the formal release. Google reported that early patched code and proof-of-concept material for October's PHP vulnerabilities became public before the official patches. It also described hundreds of claimed but nonfunctional exploits appearing afterward, likely generated with LLM assistance. Google's analysis
That creates a second burden for defenders. They have to determine what is real while responding to what might be urgent.
Generating another plausible claim is getting cheaper. Establishing whether that claim applies to your actual environment still takes work.
Just Patch Faster Is an Incomplete Answer
Patching promptly matters. So does ensuring that the act of protecting a system doesn't disable the service it exists to provide.
Microsoft's November 12 outage offers a particularly uncomfortable example, and the report is more instructive than the summary most people read.
The change that caused it was itself a fix. Microsoft had prepared it specifically for its Microsoft 365 networking gateway servers, and it went through the company's normal safe deployment process, saturating globally over several weeks. For more than three months it ran worldwide without impact. Normal load testing didn't catch what was inside it: lock contention in an internal Windows process that caused servers to stop responding under certain conditions. Microsoft's preliminary report
Then the operating conditions moved. A shift in traffic load, combined with reduced gateway capacity, arrived at the latent defect all at once. In under two hours, more than 80 percent of the servers in the networking gateway were unresponsive. And because the servers that failed passed their load to the ones still running, the failure propagated from server to server.
Microsoft's architecture is supposed to prevent that. The gateway is built from thousands of capacity units organized into regions, and there are normally bulkheads between those partitions. In this case, the report says, a separate issue meant those bulkheads didn't stop the cascade. That is what let a single latent defect take out gateway infrastructure globally.
The update had survived deployment. The system had operated for months.
Then the conditions changed.
That is the limitation of treating a successful rollout as a permanent verdict. Software behaves within an environment. Change the load, available capacity, dependencies, or timing, and you can expose a failure that previous operation never exercised.
The delta that matters may be in the operating conditions, even when the code hasn't changed at all.
This is also why reviewing the latest deployment can be necessary without being sufficient. Sometimes the consequential change is older than the incident everyone is investigating. In this case it was four months older, and it was the thing that was supposed to make the system safer.
I explored the tension between protection and stability in my CrowdStrike analysis. The enduring question is how much damage a protective component can cause when something goes wrong inside it.
Security software has authority. Deployment systems have authority. Network control systems have authority. We grant that authority because they need to accomplish useful work.
It also determines how far their mistakes can travel.
Authority Determines How Far a Mistake Travels
The FAA's November 13 ground stop raises a related issue. The agency reported excessive connection traffic destabilizing its legacy network and affecting 17 of 22 Air Route Traffic Control Centers. Its initial investigation identified two possible originating locations, including a site where a contractor had been deploying a router. Isolating the locations stabilized the network. The FAA said it had no indication of a cyberattack, and the root cause remained under investigation. FAA investigation update
We should resist turning that preliminary account into a tidy story about one defective box.
The engineering question is broader: how did behavior originating in a limited part of the environment become consequential across so much of it?
That question concerns the relationships between components, the boundaries, protocols, dependencies, and assumptions that determine whether trouble stays local.
On November 17, the NSA also reported temporary degradation during scheduled maintenance. It said mission-critical capabilities remained operational and pointed to multiple layers of redundancy. The statement didn't establish a detailed technical cause. It did illustrate why continuity matters alongside prevention: some systems can experience problems while essential operations continue. NSA statement
These incidents have different causes. Their proximity on the calendar doesn't establish a coordinated attack or an AI connection.
The useful common question is what happens after a component behaves unexpectedly.
Does the failure stop there?
Or does the architecture help distribute it?
The Change Nobody on Your Team Approved
On November 16, Scott Helme and Report URI reported malicious JavaScript being served through Optimizely to visitors of 178 organizations. Their investigation found injected code in customer project scripts delivered through infrastructure the affected websites already trusted. The delivery system could serve the altered content without the website operator making a corresponding change to its own application. Report URI investigation
Your repository can be unchanged while the software your customers receive changes underneath you.
That should make anyone responsible for a website pause.
A remote dependency is an ongoing relationship with someone else's change process. When a browser loads a third-party script, it executes the content supplied at that moment, subject to the controls you have put around it. The fact that the address was approved in October doesn't tell you everything about what it serves on November 16.
Helme's follow-up makes the visibility problem explicit, and it's blunter than the incident report. Those third-party script tags are dynamic by design. The code they serve can and does change, which makes it close to impossible to control what's running if you don't know what you're supposed to be running. His question is worth sitting with: most organizations can't answer what code they're running at any given moment, or what was running when the incident started. Helme's analysis
The part that should sting is that this isn't a novel attack. Helme notes he's been covering this class of JavaScript supply-chain compromise for more than a decade, hundreds of times. The defense has been available since 2015 in the form of Subresource Integrity, a browser feature you turn on with one attribute, and it remains largely unused on the sites that were affected.
The technology existed. The discipline didn't.
This is another version of the principle behind Authority Is Not a Security Control.
Permission explains why something can act. It doesn't establish that every action it takes will remain safe.
The same reasoning applies to a vendor, an administrator, a software update, or an AI agent. The more consequential the permissions, the more important it becomes to observe their use and limit their reach.
In The New Attack Surface Is the Agent Control Plane, I focused on the systems holding credentials and connections to everything downstream.
An attacker who gains control of that layer can inherit capabilities the organization has already assembled.
The delta might be a changed configuration, an altered tool definition, a new destination, or a permission that became broader than intended. Its significance comes from the authority available on the other side.
Counting Changed Lines Is a Poor Proxy for Risk
A thousand lines of presentation code and a one-line authorization change can have radically different consequences. The important questions concern behavior: what becomes possible, for whom, under which conditions, and across which boundaries?
AI can help investigate those questions. It can compare versions, flag suspicious changes, connect logs, and assist with testing. But producing an explanation is only part of the job.
Someone still has to establish whether the explanation is correct.
And a defensive agent with permission to modify production systems becomes another source of consequential changes. Its speed is useful only within an architecture that constrains mistakes, records actions, and supports recovery.
Otherwise, we have built a faster mechanism for distributing assumptions.
Three Clocks
One measures how quickly an attacker can turn actionable information into a working compromise. It may start before public disclosure, especially when code or research leaks.
Another measures how quickly a defender can turn that information into effective protection. That might mean a patch, but it can also mean disabling an exposed feature, restricting access, isolating a component, or applying a validated mitigation.
The finish line is reduced exposure, with the necessary service still operating.
There is also a recovery clock: how long it takes to contain and reverse damage when the attack or the update succeeds in breaking something.
Organizations often discuss these clocks separately. Security owns remediation. Operations owns availability. Engineering owns deployment.
Production experiences all three at once.
The attacker can tolerate failed attempts against systems they don't care about. The defender has customers, transactions, employees, and obligations attached to the environment being changed.
That asymmetry makes the work difficult. The defender needs speed and care in the same process.
The way out is to prepare for urgent change before the emergency arrives.
Know what is deployed and who owns it. Understand which services depend on which components. Test under conditions that resemble actual operation. Roll changes through limited populations with meaningful observation between stages. Keep credentials narrowly scoped. Preserve evidence. Practice recovery instead of assuming the rollback button will work when everyone needs it.
Those are familiar engineering disciplines. Their value increases when the time available to improvise decreases.
And they change how we should think about resilience.
A resilient system gives mistakes less room to spread. It makes consequential changes visible. It lets operators isolate trouble without disabling everything around it. It provides a credible route back to a working state.
That matters because perfect foresight is unavailable. No team can anticipate every combination of software, traffic, configuration, permissions, and dependency behavior.
We can still decide how much authority a component receives and how widely its failure is allowed to propagate.
We cannot make every change harmless. We can make fewer changes capable of becoming everyone's problem.
That, to me, is the deeper meaning of the phrase.
A patch diff can reveal a weakness. A configuration change can expose one. A shift in workload can activate a dormant defect. An altered dependency can introduce behavior your team never reviewed.
Finding the difference is the beginning of the investigation.
Understanding its consequences means following the connections: into permissions, into workloads, into other systems, and eventually into the people depending on them.
AI is making us faster at finding and acting on those differences. It is also making it cheaper to connect analysis directly to action.
That puts more responsibility on the architecture surrounding the action.
Because "it was only a small change" tells us almost nothing until we know what that change was allowed to touch.
The devil is in the delta.
And the blast radius is in the architecture.
Rich Washburn is a technologist, strategist, and Founder & Chief AI Architect of ARIA AI Labs, working at the intersection of AI, infrastructure, communications, and capital. He also serves as Managing Partner and Chief AI Officer at Eliakim Capital.





Comments