OpenAI shipped Codex. Anthropic shipped Agent Teams. Microsoft shipped Copilot Studio. Salesforce shipped Agentforce. Google shipped A2A.
In the same quarter, Apple shipped a slightly better Siri.
Onscreen awareness? Delayed. Personal context? Delayed. Actions across apps? Didn't work. Rebuild from scratch.
Developers got command centers. Enterprises got control planes. The rest of us got "in development."
The Mainframe Pattern
This is how new computing layers usually arrive, and it is almost never flattering.
Computers were powerful long before they were personal. Mainframes worked. Minicomputers worked. Specialists had serious tools -- command lines, programming languages, technical manuals -- and everyone else stood outside the room. If you could memorize the syntax and think like the machine, the power was yours. For everyone else, computing existed nearby but not obediently.
What the Macintosh changed in 1984 was not raw capability. It changed who could direct it. The mouse. The desktop metaphor. Windows, icons, menus, direct manipulation. Ordinary people could finally tell a computer what to do without first becoming programmers.
The point was not friendliness. The point was directability.
AI is at the same stage. The capability is here. The interface isn't.
The Wrong Relationship
Today's agent products already reveal the pattern. The developer version assumes terminal sessions, isolated worktrees, tool schemas, file diffs, manual supervision, and enough literacy to tell whether the system is doing something clever or simply getting lost. For engineers, this is a threshold moment. The leverage is real.
For everyone else, it is the wrong relationship to software entirely.
Marketing director
"I just want the competitor analysis done." Doesn't know what tmux is. Shouldn't need to.
Researcher
"I want 50 papers synthesized into something coherent." Doesn't care about token costs. Has actual deadlines — the kind of brief a research agent exists to handle.
Executive
"I want my inbox triaged and my briefings ready." Not going to learn terminal commands. Ever. This is Inbox Zero via an agent, not a new workflow to supervise.
Founder
"I need all of the above, yesterday." Wearing five hats. Zero bandwidth to configure agent pipelines.
The problem is not that these people need a simpler terminal. The problem is they should never have been put in a terminal-shaped relationship to begin with. The current tools are not too advanced for ordinary workers. They are aimed at a different job entirely.
The Supervision Tax
This is the hard part, and it is where most agent products quietly fall apart.
Current systems work only if the user behaves like a manager. Choose the right tool. Decide when to delegate. Watch the steps. Check the output. Retry when it drifts. Verify what happened. Keep supervising.
That is not delegation. That is software middle management.
They have been promised an assistant and handed a new job: supervising one.
Developers tolerate this because the machinery is legible to them. They can read the trace, inspect the diff, notice when the model has gone off the rails. The supervision overhead is annoying, but the leverage is still worth it.
Everyone else experiences the same structure as a tax.
The product that reaches the rest of us cannot be built on this assumption. It cannot require the user to become the QA department for every output. But it also cannot hide everything behind cheerful magic and hope for the best. Real work has stakes. Emails get sent. Numbers get used in meetings. Research informs decisions.
So the design problem is not "how do we make agents autonomous?" It's subtler: how do you remove supervision without removing control?
Some moments should feel immediate -- approve this, edit that, schedule Friday, send the second draft. No reasoning ceremony. No spinner theater.
Some moments do need intelligence -- reconcile the contradictory numbers, draft the reply that is firm but not hostile, synthesize the market shift across a dozen weak signals. That is where the model earns its place.
And some moments should be checked by systems, not by the user. Specialists verify specialists. The person using the product should not need to understand how the machine arrived at an answer to trust the result.
The real craft of building agents for ordinary people is not more autonomy. Not more chat. Better delegation.
The Gap
The developer stack exists. The enterprise platform exists. The consumer agent operating system doesn't.
The missing product is not "Codex, but easier." It is not a terminal with rounded corners. It is not a chatbot with more tools attached. It is software built around a different default: the user describes the outcome, and the system disappears below the floorboards. The interface matches the task. The right controls appear when control belongs with the user. The work happens in the background when the system should carry it. Verification is built into the product, not outsourced to the person trying to get through the day.
That is not a better chatbot. That is an operating system.
The Rest of Us Is the Point
One way to misunderstand this moment is to treat the consumer layer as the watered-down version -- the one that arrives after the serious work is done for developers and enterprises.
History says the opposite.
When a technology becomes directable by ordinary people, that is not the cheap seats. That is the moment the medium itself changes.
The Macintosh was not a nicer mainframe. It was the moment computing crossed from specialist instrument to personal medium.
The iPhone was not a smaller laptop. It was the moment the internet became something you carried.
The same boundary exists here. AI already has remarkable capability. What it still lacks is a form that ordinary people can actually hand work to -- and trust.
That will not arrive when agents get slightly smarter. It will arrive when someone builds the system that makes delegation as natural as pointing and clicking was in 1984.
Forty-two years later, the rest of us are still waiting.
