I've spent the last few months digging into AI agents and what they actually mean for interface design. That research kept circling back to one question: which of these tools are really agents, and which are just software with some AI bolted on? The distinction turns out to matter a lot for how you design them.
Agents versus AI features
Alex Klein's framing in The Agentic Era of UX gets at something I keep coming back to: an agent is supposed to carry out the work on your behalf, not just assist you with it. That means the system should need less hand-holding over time as it learns from how you've corrected it before.
For that learning loop to work, the person using the software needs a real way to push back, explain why an output was wrong, or add context the agent didn't have. Whether that happens through conversation or some other interaction pattern is a design decision, but the feedback path itself isn't optional.
Reapplying heuristic evaluation to agents
Heuristic evaluation is the usual toolkit designers reach for to judge an interface. AI agents complicate a few of those heuristics enough that they're worth revisiting individually.
Visibility of system status
Agents mostly work in the background, which means you often don't see what's actually happening. If an agent is compiling a report, what sources fed into it, and how confident should you be in the result? Tools like Parcha AI and Perplexity handle this by surfacing the sourcing and reasoning as the agent works, rather than presenting a finished answer with no trail behind it.
User control, freedom, and error prevention
Users often perform actions by mistake. They need a clearly marked 'emergency exit' to leave the unwanted action without having to go through an extended process. — NN Group
This principle shifts when the agent, not the user, is the one taking the action. Correction has to happen through new instructions rather than an undo click, and ideally the user can set guardrails upfront rather than only reacting after something goes wrong. Eve AI, built for plaintiff law firms, lets users set per-case instructions so the agent's output stays relevant to that specific matter. Orby AI takes a different approach: it watches for repetitive tasks and lets the user dial in exactly how much autonomy they want, flagging anything with a low confidence score for review instead of running it automatically.
Matching the system to the user's mental model
Agents can push personalization further than static software ever could, adapting layout and available actions to how a specific user actually thinks about the task. Eve AI's home screen changes based on the user's needs rather than showing everyone the same options. The same logic extends to error recovery: instead of a generic error message, an agent can tailor the explanation and next steps to the user's actual situation, which is exactly what Parcha AI does when something fails validation.
Help and documentation
Chat interfaces are good at answering the question in front of you, but that convenience has a cost: users tend to only explore what they already came looking for, and miss everything else the agent can do. Since most people are still new to what agents are capable of, visual cues pointing at underused features matter more here than in traditional software. Eve AI's skill library is a good example, surfacing relevant capabilities based on what the user is already doing rather than burying them in a separate docs page.
Where this breaks down in practice
Not every agent gets this right. Relevance AI, a platform offering multiple specialized agents for workforce tasks, is a useful cautionary example. Setting up even a simple task, like configuring an agent to send an email, requires working through several configuration steps with no in-context guidance. One user's public feedback captured it well: the sheer number of customization options disrupts the flow of getting anything done, which defeats the entire premise of using an agent to simplify the task in the first place.
Part of the problem is visibility of system status again: a control labeled 'Override Mode OFF' with no explanation forces the user to guess at what it does, and Relevance AI's actual audience, marketing and sales teams, has no particular reason to know the jargon. If an agent's target users aren't technical, the interface has to carry more of that explanatory weight, not less.
Where this leaves design
AI and AI agents are reshaping software fast enough that some people expect a chunk of traditional software to become obsolete outright. Whether or not that prediction holds, most products will need to incorporate agentic behavior in some form to stay competitive. That shift changes the job for designers: usability heuristics still apply, but several of them need a second look once the software is the one acting, not just responding.