Rewiring at Machine Speeds
Agents can write security patches in minutes. Can we find out what those changes will do just as quickly?


The other day, I had a chat with Michael Argast, co-founder and CEO of Kobalt.io, about what happens when security threats move at “machine speeds.” A threat you’ve just learned about can become an incident while you’re still assessing your exposure. Much of our response practice took shape when attackers moved more slowly and had fewer resources. It assumes we’ll have time to find out what’s happening, decide what to change, and get that change into production.
You can revoke a credential or isolate a machine as soon as you have the evidence and authority to act. The harder cases arise when containment requires changing how several systems work together. You need to know where the change will take effect and what else depends on the behavior you’re about to change.
A faster patch still has to make it through production
An agent can open a pull request before an incident call gets underway. That buys time for the rest of the work. You still have to check whether staging covers the affected paths, what happens while old and new versions run together, and how you’ll tell whether the change worked.
Those questions are hard because the answers live on different sides of boundaries. Code is reviewed in one repository, infrastructure is managed in another, and production behavior is reconstructed from telemetry and conversations with the people who own each service. A test suite can tell you a component still honors its contract. Establishing what happens across the whole system takes more work, and much of it starts over with each change.
Those boundaries slow down preventive work, too. When a threat comes to light, even finding where we’re exposed can mean piecing together inventories, permissions, and runtime behavior. If each assessment takes a fresh investigation, we’ll do fewer of them while there’s still time to act.
Try the change while the system is running
At Inferal, we’re working on making the relationships between systems and the rules that govern them explicit. That lets you inspect which workflows a rule can affect and trace an individual decision back to the facts and rules that produced it. Together, those views give you a way to assess a proposed change against what the system actually does.
Say an agent proposes a tighter access rule. It could fork the relevant dataflow so both rulesets see the same production inputs. The fork would record what it would block, with enforcement off. The team might discover that a legitimate overnight job would lose access, see why, and have the agent revise the rule and compare again.
Some changes will still need a coordinated rollout, and some incidents call for immediate containment. Running a proposed policy alongside the current one gives you evidence before enforcement, when you still have room to revise it.
Find out before the next incident
Picture the next incident call. A compromised account can still read customer records. Someone has a rule ready to cut off that access, but nobody can say which legitimate services it will take down. Every minute you spend finding out is another minute those records are exposed.
This week, pick one access rule that protects sensitive data. Run a stricter version against live traffic in shadow mode, with enforcement off. Review the requests it would have blocked and trace any legitimate ones back to the service that made them. That’s a dependency you can investigate today, while you have time to do something about it.
The rest of the business could use that ability, too. Security gives us a reason to build it now.