For twenty years, enterprise software was a destination. You went to it. We built portals, dashboards, apps, and the training decks to teach people where to click inside them. Adoption was a travel problem. Get the user to the tool and keep them coming back.
That model is coming apart, and I watched it happen inside my own company.
What I watched in my own rollout
I selected and deployed Claude Code across a company of more than 3,000 people, and we got past 500 active users. Early on I tracked the usual things, logins and weekly actives and the rest. Those numbers were fine. They were also not the interesting signal.
The interesting signal was quieter. At some point people stopped opening the tool to do the work and started asking their agent to go do it for them.
Here is a concrete version. Someone on a delivery team needs a status rollup across a dozen tickets. The old way, they open the project tool, filter, export, paste it somewhere, clean it up. Fifteen minutes if they know the tool well, longer if they do not. The new way, they type one sentence to the agent they already have open, and the rollup comes back. They never opened the project tool. They may not even know which system the data came from.
Multiply that across a few hundred folks and adoption stops looking like logins. It starts looking like delegated work. The work still happens, the systems still get hit, but the human is not visiting a destination to make it happen.
Bring the work to the user
Here is the shift stated plainly. For two decades we brought the user to the work. Now we bring the work to the user.
The person already sits inside an AI tool most of the day. That tool becomes the surface where things get done, and every underlying system turns into something the agent calls on their behalf. Nobody travels to the report anymore. The report comes to them, assembled on demand, in the place they already are.
This sounds like a small thing. It is a big deal, it changes what a product even is.
What this quietly makes obsolete
A few things we used to treat as durable stop being durable. Three of them stand out.
1/ Adoption-by-training. If nobody has to learn a UI, the deck about where to click has nothing left to teach. You do not onboard people to a screen they never see.
2/ UI stickiness as a moat. We used to make screens hard to leave, familiar and full of saved state, so switching felt expensive. When the agent is the surface, there is no screen to get stuck on, and that moat drains.
3/ The destination app. If the work comes to the user, being the place people go stops being the point. For a lot of software, being the destination was the whole value proposition, and that proposition is expiring.
None of this happens overnight, and plenty of software will keep a real screen for good reasons. But the default is flipping, and building as if the destination is still the prize is how you get left behind.
What this makes valuable
The flip side is that a different set of things gets more valuable, and they are less fun to demo.
Capability contracts move to the center. When an agent calls your system, it does not care about your interface, it cares whether the thing does what it says. It needs to be callable without a human clicking anything, and it needs to fail in a way the agent can handle. That contract is the product now, the screen was just the old wrapper around it.
Data quality stops being a cleanup project you schedule for later. An agent assembling an answer on demand is only as good as what it reads. Bad data used to hide behind a person who knew to squint at a weird number before passing it on. The agent does not squint. It hands the weird number straight to your executive with full confidence.
Trust becomes the thing you are actually selling. People delegate work to an agent only when they believe the output enough to stop checking it by hand. That belief is earned slowly and lost fast. It is a core feature now, and most orgs are not funding it like one.
What I would actually do
If I were running product or AI strategy right now, here is where I would put my attention.
Stop optimizing the destination and start optimizing the contract. Ask a plain question about each of your surfaces: if an agent had to do this without the screen, could it. Wherever the answer is no, that is your roadmap.
Treat data quality as a shipping feature. The moment an agent reads your data on someone's behalf, every quiet inconsistency becomes a visible wrong answer in front of someone who matters. Fund the boring work before that happens.
Keep your adoption playbook product-agnostic on purpose. Mine is three phases and it does not depend on any one vendor, because the vendor will change and the shift underneath it will not. If your plan only works with today's tool, it will break the first time the tool does, and it will.
Measure the right thing. Logins told me almost nothing. Delegated work told me almost everything. Find the version of that signal in your own numbers and watch it instead.
Where this goes next
This is the first post in a series I am calling Thoughtful interfaces. Over the next few weeks I want to work through what this shift does downstream: to how enterprises buy software, how they deploy it, how the harness around the model gets built, how product teams execute, what happens to UX when there is less UI, and what it does to roles. The interface moving is the first domino. The rest is what falls after.
This is post 1 of 9 in my Thoughtful interfaces series. The rest lives at hagestedt.com/writing.