We're Renting Our Own Computers and Calling It Progress

Microsoft wants you to think this is about making your computer smarter. It isn't. It's about making sure that when AI agents become the primary way people interact with computers (and Microsoft is betting everything that they will), every autonomous action your machine takes passes through infrastructure that Microsoft owns, monitors and charges for. The OS isn't the product anymore. The OS is the toll booth.

The technical story they're selling is genuinely impressive on the surface: AI agents baked into Windows, local models, purpose-built APIs, security containers, governance mechanisms for autonomous software. It sounds like engineering. It is engineering. It's also a land grab, and the two things aren't mutually exclusive. If the agent layer becomes how we work, how we search, how we manage files and make decisions and run workflows, then controlling that layer is controlling the computer, not in the abstract sense but in the concrete, transactional, every-single-action sense. You won't own the agent. You won't own the layer. You'll rent the experience while Microsoft collects on every pass through the gate.

The Linux move is the clearest tell. WSL looks generous. Expanded native command-line support, Linux containers, the whole thing packaged as Microsoft finally, graciously, making peace with open source. What it actually is: enclosure. A landlord doesn't give you a room out of affection. Microsoft isn't embracing Linux so much as drawing a fence around it, making sure that even the developers who'd rather live outside the Windows ecosystem are doing it inside Microsoft's walls, on Microsoft's terms, through Microsoft's infrastructure. The gift is the claim.

And then there's the security pitch, which would be funny if the stakes weren't so high. Microsoft, the company that spent decades turning Windows into one of the most reliably patchable attack surfaces in computing history (monthly patch cycles, browser exploits, malware ecosystems that flourished like something carefully cultivated), is now promising to keep autonomous software in check with "execution containers" and "governance mechanisms." I don't say this to be glib. I say it because I've worked in IT long enough to know what happens when you give software autonomous access to OS resources: things break, access controls get bypassed, containment fails in ways nobody predicted because nobody can predict all the ways containment fails. The containers Microsoft is building aren't primarily for your protection. They're for the system's protection, which is a different thing entirely, and the difference matters enormously when the goals diverge.

"Autonomous" is the word doing the heaviest lifting here, and it deserves more scrutiny than it's getting. Autonomous doesn't mean the software is working for you. It means the software is making decisions without your direct input, in an environment architected and owned by a corporation whose incentives are not your incentives. A copilot sits next to you. Autonomous software acts on your behalf inside infrastructure you don't control, and when the infrastructure's interests and your interests stop pointing the same direction, the infrastructure wins. That's not paranoia. That's just how infrastructure works. I've watched it happen with smaller systems, less consequential ones, and the pattern is consistent: the environment shapes the outcome, and whoever built the environment built it for themselves first.

None of this means AI agents are inherently bad, or that autonomous software can't genuinely serve people. It can. The question is always who controls the layer where that software operates, and right now Microsoft's answer is unambiguous: they do, they're building the architecture to make that permanent, and they'd like you to experience it as a feature. The tools should serve the people using them. That's not a complicated principle. It's just one that's very hard to hold onto when the company building the tools also owns the ground the tools run on, the pipes the tools communicate through and the governance layer that decides what the tools are allowed to do. At that point you're not using a tool. You're living in someone else's system and calling it yours.

We can build better than this. We've done it before, usually in garages and community spaces and open-source repositories where nobody was getting rich and everybody was trying to make something that actually worked for the person holding it. That's still possible. It just requires being clear-eyed about what we're being handed and what we're being asked to give up to hold it.