For decades, software has been designed around a simple loop: the user clicks, the product responds. AI agents break that loop. The user states a goal, and the product goes off to do the work. Designing for that moment, handing over a task and getting it back, is a different problem from designing screens.
An agent is a system that takes several steps on a user's behalf without needing input at every one. A travel assistant that rebooks a flight, a finance tool that sorts and pays recurring bills, an internal assistant that prepares a weekly report. In each case the interface stops being the place where work happens and becomes the place where work is briefed, watched and approved. This article covers what changes in that shift and how to design for it.
From Doing to Delegating
When users do the work themselves, every step is visible and every mistake is immediate. When they delegate, they give up that visibility in exchange for time. The design has to give back just enough of it to keep them comfortable.
Three questions sit behind almost every decision:
- Did the agent understand me? The user needs to know the task was interpreted correctly before work begins.
- What is it doing right now? Silence during a long task reads as failure.
- Can I stop or undo it? Delegation only feels safe when it can be reversed.
1. Make the Brief Clear
A delegated task starts with a request, and vague requests produce vague results. The interface can do a lot to improve the brief without turning it into a long form.
- Offer structured starting points for common tasks instead of an empty text box.
- Repeat the task back in plain language before starting: "I'll pay these three bills on Friday from your main account."
- Ask a clarifying question only when the answer changes the outcome. Every extra question costs trust and time.
2. Show Progress Without Showing Everything
Nielsen Norman Group's first usability heuristic, visibility of system status, says the design should always keep users informed about what is going on. For agents this matters more than for any other kind of product, because the user is not watching the work happen.
The aim is to be informative, not exhaustive. A log of every internal step overwhelms people. A short, readable status is usually enough:
- A clear state: working, waiting for you, done, or stopped.
- The current step in plain language, such as "Comparing three vendors."
- An optional, expandable detail view for users who want to inspect the work.
Users don't need to see every step. They need to know the agent is working, what it is working on and when it will need them.
3. Put Approval Where the Risk Is
Asking for confirmation at every step defeats the purpose of an agent. Asking for none makes delegation feel reckless. The solution is to match the amount of oversight to the cost of a mistake.
| Risk level | Example | Design response |
|---|---|---|
| Low | Sorting emails, drafting a summary | Act automatically, show the result afterwards |
| Medium | Rescheduling meetings, changing settings | Show a preview and let the user accept in one tap |
| High | Moving money, deleting data, contacting customers | Require explicit confirmation with a clear summary |
Let users adjust these levels over time. A user who has watched an agent get things right for a month may be happy to give it more freedom.
4. Make Actions Reversible
Another of NN/g's heuristics, user control and freedom, points out that users need a clearly marked "emergency exit" to leave an unwanted action. With agents, that exit has to cover a whole chain of steps rather than a single click.
- Offer a visible stop control while the agent is working.
- Keep a history of what the agent did, in order, with the ability to undo each step where possible.
- Be honest about what cannot be undone, and ask for confirmation before those actions.
5. Plan for Failure and Handoff
Agents will misunderstand tasks, hit missing information and run into things they cannot do. The experience at that moment decides whether users keep delegating.
"Task failed. Please try again."
"I couldn't pay the electricity bill because the account number is missing. Add it and I'll finish the rest."
- Say what was done, what was not done and what is needed to continue.
- Let the user take over from exactly where the agent stopped, without starting again.
- Never leave a half-finished task in an unclear state.
What the User Needs at Each Stage
| Stage | User's question | What to design |
|---|---|---|
| Brief | Does it understand what I want? | Structured input and a plain-language restatement |
| Working | Is it doing something? | A readable status and expandable detail |
| Approval | Should I let this happen? | Previews and confirmations sized to the risk |
| Result | Is this right? | A summary with the means to review and correct |
| Problem | What now? | A clear explanation and an easy way to take over |
Agent Design Checklist
- Does the product restate the task before starting?
- Can users see, at any moment, whether the agent is working, waiting or finished?
- Is the level of approval matched to the risk of each action?
- Is there a visible way to stop the agent?
- Can the user review what was done and undo it where possible?
- Are irreversible actions clearly marked and confirmed?
- Do failure messages explain what happened and what the user can do next?
- Can users adjust how much freedom the agent has?
Conclusion
Designing for agents is less about the screens users see and more about the relationship the product builds with them. Delegation works when people can trust what happens while they aren't looking. To summarize:
- Help users brief the agent clearly, and confirm it understood.
- Keep progress visible without flooding people with detail.
- Match approval to risk, and make actions reversible.
- Treat failure and handoff as core parts of the experience.
If you are adding an agent or an AI assistant to your product, our Product Strategy & MVP and UX Audit & Optimization services help you decide what to hand over to the system, and how to keep your users in control.
