There are more tabs open on your computer than there were two years ago. More sessions. More partial tasks. More notifications from agents asking for approval, more stalled workflows waiting to be nudged, more things you forgot you started. The AI tools got capable. What they produced, for a significant number of people who use them seriously, is a new management layer — not freedom from management.
This is the central tension of AI in 2026: the capability problem is largely solved, and the attention problem is getting worse. We have agents that can write code, browse the web, draft emails, compare flights, summarize meetings, and run multi-step tasks across tools. We also have a near-billion people using chatbots and still having to remember to ask them things, and a growing population of technically sophisticated users who built elaborate agent setups and found themselves stressed project managers instead of liberated workers.
The engineers at OpenAI hit this wall themselves. They had fast coding agents — genuinely fast, genuinely capable. They were still opening sessions, assigning tasks, checking progress, nudging stalled work, keeping track of what was in flight. The agents were capable. The humans had become the bottleneck. Their response was Symphony: an open-source protocol that moves the management work out of your head and into something more like an issue tracker. The problem was real enough inside one of the world's leading AI companies that they built infrastructure to solve it — and then open-sourced it so everyone else could, too.
"I don't need another agent that says it can do anything and then sits there waiting for me to assign it work. And I definitely don't need my attention sucked into managing a fleet of agents. That's not what an assistant does. That's a new inbox."
Consumer AI analyst, 2026Why ChatGPT Worked and Agents Don't (Yet)
ChatGPT worked because it was a tiny behavioral shift. For twenty years, users had learned to type a query into a box. Google trained that behavior into hundreds of millions of people. ChatGPT kept the box. You had a question. You pressed it into words. You hit enter. Something came back. The capability jump was enormous. The behavioral jump was almost nothing.
Agents don't get that gift. There's no cheap UX trick available. Most people don't wake up thinking about which life-admin tasks to assign to an autonomous system. If you ask a normal person what they want an AI agent to do, many of them genuinely don't know. "What can it do?" is the most common first question after installing any agent. In China, there were lines to uninstall a popular agent product shortly after there were lines to install it. That's not a small UX problem. That's the ceiling.
The issue is structural. Chatbots are reactive tools you use when you need them. Agents are supposed to be proactive systems that surface the right action at the right moment — but most of them aren't. Most of them wait for you. You open them, tell them what you want, they try to do it. That sounds like agency. Sometimes it is. But the hardest cognitive job — figuring out that something needs to be done, deciding this is the moment, translating the need into an instruction — stays entirely on your shoulders.
Why Enterprise Solved It and Consumer Hasn't
Coding agents — the enterprise case — cracked proactivity first, and it's worth understanding why, because the reasons explain exactly what consumer agents are missing.
Code has a compiler. Either it runs or it doesn't. Tests pass or fail. The agent produces something and there's an objective way to verify whether it worked. That bounded, verifiable quality means you can actually trust the agent to act. You can set guardrails and let it go, because you'll know when it went wrong.
Consumer life has no compiler for taste. Did the agent book the right restaurant? "Right" depends on how tired you are, how loud the place is, whether your spouse likes the cuisine, how far it is from where you'll be coming from, and a dozen other factors that shift week to week. Did it write the right email? There's no test suite for tone. Did it summarize the meeting correctly? It might have gotten the words right and missed what actually mattered. Consumer tasks look simple on the outside — "book a trip," "handle the grocery order" — and turn out to have enormous amounts of personal context embedded in them that no agent currently holds.
Coding also has bounded scope. Fix this bug. The agent has a repo, an error, a task, and a target. Consumer tasks sprawl. A trip involves budget and timing and preferences and calendar constraints and tolerance for cancellation and what you'll do when you get there. Expedia exists, with thousands of developers, specifically because the trip-planning problem is hard enough to justify a company. "Book a trip" is not a simple prompt.
| Dimension | Enterprise / Coding Agents | Consumer Agents |
|---|---|---|
| Verification | Objective — code runs or it doesn't | Subjective — no compiler for taste or judgment |
| Scope | Bounded — a repo, a bug, a target | Unbounded — tasks sprawl across domains and people |
| Delegation model | Clear — "fix this bug in this file" | Fuzzy — "handle the grocery thing" encodes ten assumptions |
| Error cost | Low to medium — revert the change | High — wrong flight, wrong tone in a tense email, missed permission slip |
| Context required | Technical — the codebase, the test, the error | Personal — your taste, your relationships, your calendar reality |
| Behavioral shift | Small — developers already work this way | Large — most people don't naturally delegate to software |
The Anticipation Gap
The concept that describes what's missing is the anticipation gap — the distance between "you ask me to do X" and "this is the moment when X matters, do you want me to handle it?"
Consumer software has crossed narrower versions of this threshold before. Push notifications meant you didn't have to open the app to know someone texted you. Recommendation feeds meant you didn't have to know what you wanted to watch before options appeared. Autocomplete meant you didn't have to finish typing the query. Smart replies meant you didn't have to compose from scratch. In each case, the system moved from waiting to be invoked to surfacing the right thing at the right moment.
Those features worked because they were narrow, bounded, and reversible. You could ignore the notification. Scroll past the recommendation. Skip the autocomplete. Write your own reply. No one handed over their credit card and let the feed book a vacation.
Agents are attempting to do the same basic job — surface the right thing at the right time — but across many domains simultaneously, with real-world actions, and with much higher error costs. That's why the bar is so much higher. It's one thing for Gmail to suggest "sounds good, thanks." It's another for an agent to buy something, sign you up for a service, or send an email in your voice to someone who will read it as you.
What Real Proactivity Actually Looks Like
The breakthrough isn't the agent guessing everything and running your life. It's the agent noticing the right moment and asking a low-cost question at the right time.
The Anticipation Gap — Before & After
Before (reactive): Your flight is delayed. You check the app, search for alternatives, call the airline, lose 40 minutes.
After (anticipatory): "Your flight to Chicago is delayed 90 minutes. There's a 4:15 that still gets you there before dinner. Want me to switch?"
Before: School sends an email about a field trip permission slip. It sits unread. Friday arrives.
After: "There's a permission slip due Friday for the field trip. I pulled it up. Sign here?"
Before: A work email thread gets tense. You draft a reply under stress. You send it and wince.
After: "This thread looks like it could use a careful reply. I drafted one with a neutral, de-escalating tone. Want to review it?"
Notice what changed in each scenario. The user didn't remember the agent existed. The user didn't invoke the agent. The situation called the agent into existence. That's the difference between a tool and an assistant. A tool waits for you to remember it. An assistant reduces the number of things you have to remember.
Where Things Stand
A few products are making real bets on how to close the anticipation gap. Clicky.so takes a visual approach — a small blue cursor that appears in the corner of your screen when an agent is working, simple enough that you can spin up multiple agents in thirty seconds in plain English. The experience is more approachable than anything built for developers. It's not proactive yet, but it's one of the better UX approaches to the management problem. Poke lives inside iMessage, SMS, and Telegram on the thesis that messaging has almost zero cognitive cost — if the agent lives where you already are, the behavioral shift shrinks toward zero.
Symphony, OpenAI's open-source protocol, is the closest thing to a real solution for the enterprise side. It moved agent coordination into an issue-tracker model rather than keeping it in your head. It works for developers. It doesn't work for your mom, who doesn't know what GitHub is and whose life doesn't have a clean linear board.
The consumer anticipation problem may not be solvable by the frontier labs directly. The right product architecture might come from a smaller builder who thinks carefully about a narrow slice of daily life — the kind of application that, once it gets one thing reliably right, earns the trust to do more. The coding agents got there by solving a bounded, verifiable problem first. Consumer agents that want to earn the same trust need their equivalent of "the code runs or it doesn't."
The demand is real. A billion people use chatbots. The capability is real. Agents can act across dozens of tools and APIs. The gap is not technical. It's behavioral, contextual, and about trust built one reliable moment at a time. The product that crosses it won't be the one with the most capable model. It'll be the one that shows up exactly when you needed it — before you thought to ask.