Two things I already have
The first is memory. Not the chat history that evaporates when you close a tab. A durable place where thinking accumulates as plain files: notes, decisions, how I fixed that stubborn driver last March.
I wrote about the bricks of that setup recently: markdown as the format humans and machines already share, and Obsidian as the app that turns a folder of those files into a map you can walk. The fair shorthand is still true. Mine lives as a vault of markdown. The useful part is not the app brand. It is that the same files are readable by me and by the agents that help me work. Shared memory. No export step.
What the shorthand hides is how much time this actually costs. I did not stop at installing a note app. I keep investing in how I look at those notes, and how agents can search, append, and link them the way I do, instead of treating my knowledge as a one-off paste into a chat. Memory, if you mean it, is infrastructure you keep investing in. Not a weekend vault you abandon after the honeymoon.
Without that, every session starts from zero. An OS that forgets between prompts is still a chatbot wearing a desktop theme.
The second is reach. Agents need to touch the same surfaces I use, without me acting as the USB cable between windows. My concrete version is unglamorous. Some of my everyday apps run in little browser windows. A script can read what is on the page and hand that text to an agent. No screenshots. No “please paste that here.” Machine to machine.
If that sounds like plumbing, it is. Plumbing is the point. An agent that can only talk inside its own chat box is a guest. An agent that can see the apps you live in starts to look like a colleague with a badge.
Two things. Memory and reach. And yet nothing moves until I type. That is the whole gap.
The OS needs ears
Today almost every AI setup I know is polite to a fault. It waits. You prompt, it answers, it goes idle again.
In the picture I am drawing, a useful OS would listen to the machine the way you listen to a car that starts making a new noise. A disk filling up. An update that broke something. An app that keeps freezing. The technical names are dull. The behavior is not.
Picture this: overnight, a Windows update finishes and a tool you need on Monday morning no longer opens. A small local model notices the error, checks your notes for the last time something similar happened, drafts a fix, and leaves a note on your screen: “This app broke after last night’s update. I staged a rollback. Approve?”
That is not a smarter chatbot. That is an operating system that noticed something without being asked.
I do not have this yet. I poke the agent. The agent does not poke me.
An undo button that works without me
If an agent can act on its own, it will eventually act wrong. Not because it is evil. Because it is probabilistic software with write access, and probabilistic software invents paths. Classic OS permissions (normal user vs full administrator) are a blunt instrument for that. Too much trust or too little.
So the next piece, in my sketch, is boring safety infrastructure, the kind nobody demos on stage.
First, a blast radius. The agent should not roam your whole computer like a houseguest with a master key. It works in a sandbox: a temporary enclosure where the damage, if any, stays local.
Second, real undo. Before the agent rewrites an important setting, the system photographs the state. The agent applies the change, a health check runs, and if the machine looks sick the snapshot comes back.
Self-healing only counts if healing can reverse itself. Otherwise you just automated the outage.
I already have snapshot tools on my main drive. The muscle is there. Wiring agents to use them before they touch anything sacred is the missing habit, not the missing technology.
The right brain for the job
Your computer already decides how to share processor time and memory across open apps. An agentic OS, as I mean it, needs a second kind of judgment: which AI model gets this job?
I wrote about this earlier with a sillier metaphor. You do not fire up the Death Star to make toast. A tiny local model is enough to summarize a short error message or decide whether something is urgent. The heavy model (local and large, or cloud) wakes up when the problem is actually hard.
I already do a crude version of this by hand. Small jobs stay on the machine. Big one-shot work still goes to the cloud. The interesting future is when the OS does that routing for you, quietly, based on how hard the task looks and how busy the machine is.
That is the fifth piece. Not “more AI.” The right AI, at the right moment, at the right cost.
From tinkering to using
Anyone who has spent a weekend fighting updates, drivers, or a machine that “just needs one more tweak” knows the old joke: you spend most of your energy maintaining the system so you can actually enjoy using it. I love that world more than I should, and I still recognize the tax.
The future I want flips the ratio. The agent plays caretaker. You play executive. Updates get handled, bottlenecks get noticed, broken software gets a staged fix waiting for a yes/no. You spend less time tinkering, and more time doing the work you opened the laptop for.
That is also the bar I hold the current wave against. A beautiful default desktop and a one-key agent launch are genuinely useful. They are still not the whole job if “agentic OS” is supposed to mean the machine can maintain itself. The product, in my book, is less maintenance friction. If the maintenance load stays the same and you mostly gained a prettier place to ask questions, you have a strong start, not five pieces.
I should not sell this as next Thursday. Listening to the whole machine costs compute. Until small background models get cheaper and cloud setups get dull enough to trust with system health, most of us will keep a human in the loop for anything that can ruin a Monday morning. Two pieces on the floor. Three still in the workshop.
Two futures, same calendar
While we wait, the business model is already visible, and I do not love it, which is usually a sign it will ship.
Imagine the OS comes with a preconfigured agent and a monthly bucket of “maintenance tokens.” Those tokens buy cloud AI calls the system spends on keeping itself healthy. Not your ChatGPT plan. Their vendor, their meter, bundled into the seat license. For enterprise IT, that pitch writes itself: fewer helpdesk tickets. For normal people, it is the appliance dream. The computer that says “I spent two tokens fixing your driver” and then just works.
As a power user, that sounds slightly dystopian. Your memory, your automations, and your system’s stability all tied to one company’s intelligence. Switching means leaving the concierge who knows the house.
As a business pitch, it is excellent. Most people do not want a general-purpose computer. They want a fridge that keeps things cold. They will rent the concierge.
So I think computing splits into two tiers.
Managed: closed, subscription, the OS maintains itself with a vendor’s brain. You rent a digital caretaker.
Sovereign: your vault, your local models, your choice of APIs. Modular on purpose. Harder. Slower to assemble. Entirely yours. It looks a lot like what daily-drive Linux people are already cobbling together in spare evenings, myself included.
Neither is morally superior. They are different tolerances for control. The question is just which one you find yourself sliding toward.