The last time we solved this problem, we called it an operating system.
In the 1960s, programs wrote directly to hardware. You wanted disk access, you talked to the disk controller. You wanted memory, you reached for it. Every program was one bad pointer away from taking down the whole machine.
The OS fixed this with two ideas that now seem obvious:
write(). The OS translates intent into hardware operations — safely, with access control, with scheduling.Fifty years later, AI agents are writing directly to the hardware again.
Not actual hardware — infrastructure. Cloud APIs, IAM, firewall rules, DNS records. An agent with credentials is doing what those 1960s programs did: reaching past any abstraction layer, straight to the resource, and hoping nothing else is touching it at the same time.
The results look familiar too. A misaddressed API call deletes a database. An agent loops on a misconfigured task and spends $50k. A credential rotation goes wrong and takes down production. We've read these incident reports. They're not bugs in the agents — they're the natural consequence of raw resource access with no mediation layer between intent and execution.
What we built in the OS era was a kernel. What we need now is the same thing, one abstraction level up.
Nexplane is a control plane for infrastructure change. The mental model I keep coming back to: it's what an OS is to hardware, applied to infrastructure operations.
When an agent (or a human) wants to change something, they don't reach for the AWS SDK directly. They express intent as a typed operation — rotate this credential, deploy this image, harden this endpoint. The platform translates that into execution steps, routes it for approval if the blast radius warrants it, executes against the real infrastructure, and stores a rollback path before any action runs.
The typed interface matters more than it sounds. An OS syscall has a defined signature — you can't pass a negative file descriptor to read(). A Nexplane change request has the same property: rotate_ssh_key takes a host asset ID and a key type. It doesn't accept arbitrary shell commands. The operation is bounded before it touches anything real.
The approval gate is the scheduler. No two changes fight over the same resource without mediation. The platform knows what's in-flight, what's pending, what needs human review before it can proceed.
The rollback guarantee is the memory manager. Before every execution, current state is captured. If something goes wrong — or if an engineer just changes their mind — the pre-change state is available for restoration. One operation, not a forensics exercise.
I spent years teaching operating systems. The abstractions that make modern software possible — virtual memory, file systems, process isolation — all came from recognizing that raw hardware access didn't scale as programs got more complex and more numerous.
Infrastructure is at that same inflection point. The agents are here. They're capable. And they're running without a kernel.
The agents are here. They're capable. And they're running without a kernel. Nexplane is the control plane that changes that.