UX for agents: first design consensus
Actualizado: 2026-05-03
A year ago I wrote that interface design for LLM agents was starting to leave chat monoculture, that native patterns were emerging, and that some were passing fashion. Eighteen months later, with millions of users using agents daily in Copilot, ChatGPT, Claude, Gemini, Cursor, and a long list of less visible products, the landscape has settled. It’s no longer reasonable to say “everything is still to be decided”; there’s a formed design consensus, with patterns any new product can take as starting point.
Key takeaways
- Five operating principles that cover 90% of design decisions in agent products: chat for exploratory tasks, background mode with progress panel for long tasks, structured controls when decision space is finite, parallel threads by context, and explicit human confirmation on irreversible actions.
- The background agent pattern (GitHub Copilot Workspace, Devin, Cursor in agent mode) has clearly won the battle for long tasks.
- Animated avatars and voice as desktop chat substitute haven’t stuck; they survive in very specific niches.
- The next unstabilized frontier: coordination between multiple agents, reusable long-term memory across sessions, and live-document collaboration.
Chat is still the base, but not the whole
The starting point, debated two years ago, is now obvious: chat with history and bubble area remains the primary interface when the task is exploratory, when the user doesn’t know exactly what to ask, or when the interaction is conversational by nature. Nothing has displaced it there. What has changed is acceptance that it isn’t the only valid interface and that forcing it on tasks where it doesn’t fit produces worse experience.
Chat works because it has minimum friction for free input, lets the user avoid structuring their thinking before speaking, and lets the agent handle ambiguity. Where it stops working is when the task is structured, when the user already knows exactly what they want, or when the result needs presentation the linear thread can’t give. Identifying when chat stops being adequate is the first design decision in agent products.
The background-agent pattern has won
The pattern that most clearly won through 2025 is the agent executing tasks in the background with explicit progress panel. GitHub Copilot Workspace, Devin, Cursor in agent mode, and several similar products have converged on the same idea: the user asks for a complex task, the agent starts working showing steps in a side column or dedicated panel, and the user can keep doing other things. The agent alerts when done or when it needs a decision.
This pattern works because it aligns the user’s mental model with what the agent actually does. When a task takes several minutes, the user doesn’t want to stare at a bubble; they want to do something else and have the work delivered when ready. Progress visibility prevents the user suspecting the system has hung, and interrupt or redirect capability keeps human control without overloading the interface.
The emerging rule: if a task will take more than thirty seconds, the agent should operate in background with visible progress, not block the conversation. This requires architecture separating the execution session from the chat session, something that was hard two years ago but is solved in every serious agent framework today.
Structured inputs when the user knows what they want
The second consolidated pattern is the return of forms and structured interfaces when the task fits. During 2024 there was a period of aesthetic rejection of forms, pushed by chat enthusiasm, leading to products that forced natural-language description of things the user already knew how to express as parameters. The result was unnecessary friction.
A canonical example is any image-generation tool. The winning interface isn’t just free prompt; it’s free prompt plus explicit controls for dimensions, style, aspect, references. The user who doesn’t know what they want uses the free prompt; the one who knows adjusts parameters without having to beg the agent with natural language for exactly the same thing.
The generalization: when the user’s decision space is finite and known, give them explicit controls. When open, give them conversation. Most real tasks are a mix, and the winning interface reflects that mix.
The work-threads room
Third consolidated pattern: products that handle multiple simultaneous tasks from the same user use a side list of work threads, each with its own state, progress, and result. ChatGPT with separate chats, Claude with projects, Cursor with chats per repository, and a long list have converged on this model. The user doesn’t have one thread with everything; they have many parallel threads organized by context.
This pattern avoids the never-ending-chat nightmare where all historical work stacks up in a single conversation. It allows archiving, resuming, comparing, and sharing specific threads. And it aligns well with how real work works: rarely a single continuous task; often many parallel things with different maturity states.
The enterprise variant groups threads into projects or workspaces, with shared permissions and common context. Claude Projects is one of the cleanest examples, but Microsoft Copilot Studio, Notion AI, and several vertical products reached equivalent patterns with different names.
Explicit human control in the loop
A pattern that took effort to impose but is now settled is that irreversible or critical actions must require explicit human confirmation, even when the agent has technical ability to execute them. Sending email, committing code to main branch, executing a payment, deleting data: in 2026 no serious product lets the agent complete these without at least a human confirmation clearly summarizing what’s about to happen.
The specific design varies, from explicit buttons to structured summaries, but the principle is firm. Products that experimented with fully autonomous agents suffered incidents serious enough during 2024 and 2025 for the industry to learn. Even when the agent carries ninety-five percent of the cognitive load, the final five percent of human confirmation is what distinguishes a mature product from one waiting for disaster.
The more elaborate variant is dry-run mode, where the agent describes exactly what it will do before doing it, with technical detail sufficient for the human to validate or correct. This has become standard in code agents, where seeing the diff before applying it prevents catastrophic surprises.
The fashions that didn’t stick
Not all patterns tried through 2025 have survived:
- Animated avatars with faces expressing emotion while they answer — they add visual friction without conveying information and most users disable them. They survive in very specific products where the animated persona has cultural meaning; for general productivity they’re distraction.
- Voice interface as desktop chat substitute — has stayed confined to concrete cases: hands-free, accessibility, specific mobile environments. For everyday desktop use, written chat is still faster and more precise.
- Virtual reality for agent interface — never took off outside isolated experiments. The reasons are the same that sank the metaverse: hardware friction, lack of use case justifying the device, visual fatigue.
Conclusion
The UX design consensus for agents can be summarized in five operating principles:
- Chat as base when the task is exploratory or conversational, not as single response.
- Background agent with progress panel for long tasks.
- Structured controls when the decision space is finite and known.
- Parallel work threads with organization by context or project.
- Explicit human confirmation on irreversible or critical actions.
These five principles probably cover ninety percent of the design decisions an agent product must make today. They’re not anyone’s particular invention; they’re independent convergence of many teams working on the same problems for two years. The benefit for anyone starting agent design is being able to start here without reinventing, saving the year it cost the first teams to discover them.
The next frontier, where patterns are still to stabilize, is coordination among multiple agents acting on the same task, reusable long-term memory across sessions, and real-time agent-human collaboration in live documents. There’s room to invent there. In the rest, the patterns are already here and the job is applying them carefully and without over-engineering.
