May 2026

June 2026

My AI desktop agent killed itself last week — and it was entirely my fault.

The setup was straightforward: I asked it to downgrade my NVIDIA drivers to fix a stability issue. It followed through. New drivers out, old drivers in. Reboot. Screen stays black.

The problem was a classic supply chain mismatch. The older driver set didn't support the GPU-accelerated desktop environment the agent itself needed to operate. On reboot, the agent's process manager couldn't initialize because the display stack it depended on was no longer functional. The last process it killed before the reboot was the one it needed to restart.

If you want a textbook example of the carwash problem — an agent modifying a system in a way that destroys its own operating conditions — there it is.

This is not a story about bad AI. It is a story about what happens when iterative, AI-driven change meets a system that was never designed to absorb it.

The Hyper-Loop

The architect John Ousterhout once wrote that "a little bit of slop can dramatically increase complexity." AI-assisted development has turned that observation into a law of motion. Agents don't write one perfect solution — they iterate. They loop. They try something, test it, fail, adjust, and try again. Twenty, thirty, sometimes fifty iterations before a solution reaches production quality.

I've been calling this pattern the Hyper-Loop — though I am open to a better name. It is a process that sets a baseline, iterates until a solution is found, then promotes that solution to the next assembly stage where the loop repeats. Each stage bundles, tests, and promotes upward. The result is a pipeline that looks less like a waterfall and more like a particle accelerator.

The critical detail: this loop does not require IT. It runs on your corporate assets, on your data, increasingly without your awareness. Your average knowledge worker with a laptop and a free-tier AI account is already cooking up their next breakthrough on your infrastructure.

The Single-Threaded Bottleneck Is Dead

Enterprise IT has spent the last thirty years consolidating the means of production. Development goes through IT. Deployments go through IT. Change management goes through IT. It is a single-threaded model — one review pipeline, one approval chain, one set of controls.

AI has broken that model.

The source of software artifacts is no longer single-threaded through IT. It is multi-threaded, distributed, and running on endpoint machines you barely control. The question is not how to stop this — you cannot, and should not try. The question is how to build an acceptance process that matches the new reality.

What is needed is a testing harness — an additional audit loop that sits between production intent and production deployment, regardless of whether the artifact came from the official development team, a contractor, or a business analyst who figured out how to prompt their way to a working microservice.

This is the Obelisk model from the Harvard Business Review called out in Enterprise IT terms. The consulting industry has already recognized that AI enables senior teams to deliver what used to require pyramids of junior staff. The same principle applies internally: your organization now produces software from every level. You are now a software reviewer, like it or not.

The Three Things That Break

Every organization I've watched navigate this shift hits the same three walls.

1. Security Telemetry and Blast Radius Containment

The default security posture for most enterprises assumes a known set of developers producing code through a known pipeline. When anyone can produce a deployable artifact, that assumption collapses.

The answer is not tighter gates at the front — it is better containment at the edge. Look for monitoring solutions in the telemetry space for wide-angle visibility, and serverless functions for providing a safety net. The goal is not to prevent adventurous employees from building things. It is to ensure that when something breaks, the blast radius is measured in inches, not city blocks.

2. Supply Chain Integrity

System patching, dependency updates, and software supply chain security were already hard when the pipeline had one entry point. Now multiply that by every AI-generated artifact that pulls from public registries, unpinned versions, and hallucinated package names.

The supply chain is an increasingly viable attack vector. Every loop in the Hyper-Loop that pulls an external dependency is a potential compromise point. Organizations need automated dependency scanning that treats AI-generated artifacts as higher-risk until proven otherwise, strict pinning policies enforced at the artifact level, and runtime attestation that can prove what dependencies were actually used — not just what was declared.

3. FinOps and Token Economics

The cost surface has shifted. Token maxing — running excessive inference to brute-force a solution — is being corrected by the market, but the correction is not producing a standard. It is producing a proliferation of routing, prioritization, and spend-management solutions.

OpenRouter, Cloudflare AI Gateway, and a dozen others are competing to be the billing plane for AI-generated work. The problem is that without a unified cost model, each team's experiments become shadow IT with a credit card. The answer is not to ban experimentation — it is to make experimentation visible and budgeted at the source.

What IT Actually Needs to Do

The Hyper-Loop model is not a threat to Enterprise IT. It is the most important function IT will serve in the next decade.

The migration from IT as the single source of production to IT as the provider of a safe operating environment for distributed production is already underway. The organizations that navigate it successfully will be the ones that build the testing harness — the audit loop, the acceptance gate, the guardrails — that lets the business produce software without destroying itself in the process.

The alternative is a future where every team runs its own loop, its own dependencies, its own cost model, and its own security posture, and IT only finds out about any of it when something breaks.

I only get to look at the solution when something is broken and needs attention. That has to change. Without an overarching method to review and check against a consistent standard, this is going to be a rough ride.

The good news: we have the architectural patterns. The Obelisk, the Hyper-Loop, the testing harness — these are not new ideas. They just need to be applied to a problem that is moving faster than most enterprises are ready to admit.

The carwash problem is real. The only question is whether your organization builds the systems to handle it before your AI agent reboots into a black screen.