For years the deliverable was a screen. You mapped a flow, you argued about navigation, you shipped a destination app, then you ran a product tour so people could find the buttons. That work is ending. Not because design stopped mattering, because the work moved.
When knowledge work happens inside an agent, the person is not clicking through your flow anymore. They hand off a task and wait, then they look at what came back. The screen is no longer where the work lives. So the craft of UX picks up and moves to where the work actually is, which is the short, high-stakes moments around the agent.
I have been watching this happen in the tools my teams build and in a rollout of coding agents past 500 active users. The interesting design questions stopped being about screens. They became about the handoff and the check-in. This essay is about that move.
What dies
The twenty-screen flow dies first. When an agent does the middle steps, you do not need to design the middle steps, you design the two ends.
The navigation debate dies with it. Nobody is hunting through your information architecture when they are asking an agent for something in plain language. The map matters less when you can just ask.
Adoption by product tour dies too. You taught people where things were because things were hidden inside a screen. When the interface is a conversation and a review, there is far less to tour.
The destination app as the default deliverable dies last. The app used to be the thing you shipped. Now the thing you ship might be a good handoff and a good checkpoint bolted onto work that happens somewhere else.
What gets born
Four design objects show up to replace all of that, and they are worth naming.
1/ the handoff. This is how a person gives work to an agent and sets the bounds. What is in scope, what is off limits, how far it can run, what does done look like. Get this wrong and the agent does the wrong thing fast.
2/ the checkpoint. This is what a person sees when the work comes back, and how they correct it. It is the most important surface in the whole system, and most teams give it the least thought.
3/ interruption design. This is when an agent is allowed to break into a person's attention, and how much context it carries when it does. Interrupt too much and people stop reading. Interrupt too little and they stop trusting.
4/ on-demand UI. This is an interface generated for one moment and then thrown away. Not a permanent screen, a temporary view built to answer one question and then gone.
Notice that most of these are about attention, not layout. The scarce surface is no longer screen real estate. It is the moment a person actually looks up and pays attention, which is when the agent checks in.
Trust is the thing you are designing
The quality bar moved, and this is the part I want design leaders to sit with. The old bar was, can the user find it. The new bar is, does the user trust what came back.
Trust is now the designed object, and it is mostly designed at the checkpoint. If the checkpoint shows the output as a wall of confident text, with no way to see what the agent did or where it might be wrong, people either rubber-stamp it or throw the whole thing out. Both are failures. A good checkpoint shows the work in a way a person can actually judge, and it makes correcting it cheap.
This is common sense once you say it out loud. People do not trust a black box that hands them an answer. They trust something they can inspect and push back on. That inspection surface is the design work now.
The review moment is the product
Here is the operating observation from building annotation and QA platforms, where a human reviewing machine output is the entire workflow. The review moment is the product. Everything else is plumbing.
We spend most of our design effort on one question. How do you present a piece of machine output so a person can judge it fast and correct it cheaply. What to surface first, what to hide, how to show the model where it is unsure, how to make a fix take one action instead of ten. That is the whole game on those platforms.
What is new is that this used to be a niche problem for data teams. Agentic work turns every knowledge worker into a reviewer. The lawyer reading a drafted clause, the analyst checking a generated query, the support lead scanning an auto-written reply, the manager reviewing a summary of their own team's week. They are all annotators now. So the whole industry just inherited the annotation problem, and most product teams have never had to solve it before.
Where I would put the effort
If I ran a design team right now, in order.
1/ Staff the checkpoint like it is the main screen, because it is. Give your best designer the review surface, not the marketing page.
2/ Write down your interruption rules. Decide when an agent may break in and what it must carry when it does. Treat it as a real spec, not a default someone happened to pick.
3/ Design the handoff as its own object. Setting bounds is a UI problem, not a prompt someone types into a void.
4/ Instrument trust, not task completion. Track whether people correct the output or accept it blindly. Blind acceptance is a warning sign, not a win.
5/ Get comfortable shipping interfaces that live for one moment. Stop assuming the deliverable is a permanent screen.
None of this is a downgrade for design. It is harder than laying out a form. You are designing the exact moment a person and a machine hand off to each other, and you are designing whether that person can trust what they get back.
That is the whole series in one line. A thoughtful interface knows when a human should be interrupted and what they need to see in that moment. Build for that moment and the rest follows.
This is post 7 of 9 in my Thoughtful interfaces series. The rest lives at hagestedt.com/writing.