Agent Interface
Framework
A best-practice framework for taking your AI app
from chatbot to agentic software.
The interface is the unsolved half of agentic software
For decades, software was built to be navigated. Product teams defined features, organized them into fixed screens, and expected users to learn the map.
Agentic software changes that. It begins with intent, acts on the user’s behalf, and needs interfaces that can show progress, ask for input, handle uncertainty, and preserve results.
Chat is a great door and a terrible house.
It is a powerful way to express intent, but it is not a complete interface.
This framework proposes eight primitives for building the workspace agentic software needs, giving product owners, designers, and developers a shared foundation for keeping users informed and in control.
The eight primitives
The eight primitives are the building blocks of an agentic interface. Each one names a category of concrete, proven patterns — from expressing intent to recovering from failure. Applied together, they produce a product where people can direct the agent, watch it work, trust its results, and keep what it makes: an interface, not just a chat box. Open a primitive to see its patterns.
1
Guide intent
Help people understand what is possible and express what they want.
The empty prompt is a tax on the user, and most people pay it badly. An interface that starts from a blank line assumes the person already knows the system’s range and how to phrase a request to reach it. A good agentic interface does the opposite: it teaches its own capabilities in the act of being used, and it makes precise expression easy when precision matters. Expressing intent well is a shared task between the person and the surface, not a test the person has to pass alone.
Zero state
An opening that shows what the system can do through suggested workflows, pre-rendered widgets, recent context, and recommended tasks, instead of a void.
Composer
One clear, multimodal place to say what you want, in words, voice, or files.
Next-action suggestions
Surfaced follow-ups that move the work forward rather than leaving the user to guess.
Structured inputs
Forms, fields, files, and parameters offered when precision matters more than open text.
2
Reveal progress
Make the agent’s work visible while it happens.
When software acts on its own over seconds, minutes, or hours, a silent gap is corrosive. The user is left asking whether anything is happening, whether it is the right thing, and whether they should wait or intervene. Showing the work turns waiting into monitoring and lets people catch a wrong turn early. The discipline is to show enough to build confidence without burying the person in every internal step, and to let detail expand on demand rather than by default.
Execution states
Legible signals for planning, searching, generating, acting, waiting, and done.
Streaming
Responses, tool calls, and sub-agent runs that appear as they occur, not after a long silence.
Thinking summaries
Short, synthesized notes on what the agent is concluding, not just that it is busy.
Milestones
Clear markers when the work crosses a meaningful threshold.
Cost & effort transparency
Honest signals about what a task is consuming and how long it will take.
Async & background work
Long-running and ambient tasks surfaced through an inbox or notification pattern, so attention is spent only when it is needed.
3
Show, don’t tell
Turn responses into usable interfaces, not just text.
A paragraph describing five options is worse than five buttons. When an agent produces a result, the highest-value form of that result is often something you can see and manipulate, not prose you have to parse and then act on elsewhere. Generated interface closes the gap between the answer and the next action. The layout should serve the task rather than forcing every kind of work through the same scrolling column of text.
Generative UI
Charts, tables, forms, dashboards, maps, timelines, controls, and small apps produced to fit the response.
Interactive controls
Filters, sliders, inline edits, and drill-downs that let people work the result.
Contextual layouts
An arrangement that adapts to the task instead of defaulting to chat.
Accessible generated UI
Interfaces assembled at runtime must be as accessible as interfaces built by hand. Anything less trades one group’s convenience for another group’s exclusion.
4
Keep control
Let agents act while people stay informed and in command, during the work rather than only after it.
Autonomy without control is not a feature, it is a liability. As agents do more, the interface has to keep the human able to steer, and to place that steering inside the flow of execution instead of presenting a finished result to accept or reject. Control is not a wall at the end of the process; it is a set of handholds along the way. The bar rises with the stakes: the more sensitive, expensive, or irreversible an action, the more explicit the human’s say-so must be.
Approvals
An explicit go-ahead before sensitive, expensive, destructive, or irreversible actions.
Confirmations
Lightweight checks for lower-stakes steps.
Clarifying questions
Resolving ambiguity is a control act. When intent is unclear, the interface should ask rather than guess.
Permissions
Legible scope for what the agent can and cannot touch.
Interrupt, redirect, rerun
The ability to stop, change course, or try again mid-task.
Respectful surfacing
The agent may ask, notify, or wait, and it should choose the least intrusive option that still keeps the person in command.
5
Earn trust
The interface must earn belief rather than assume it.
Trust is not a tone of voice, and confident prose is not evidence. An agent that sounds sure while being wrong is more dangerous than one that is transparent about what it knows and how it knows it. The interface is where trust is calibrated, up when the system deserves it and down when it does not. That calibration depends on the surface telling the truth about its own certainty, its sources, and its memory.
Disclosure & AI labeling
People should know when they are talking to or reading from an agent.
Provenance & citations
Claims should carry where they came from.
Source attribution
Generated content should point back to what it drew on.
Honest confidence
Uncertainty communicated plainly, without either false precision or a blanket disclaimer that hedges everything equally.
Memory transparency
What the agent remembers should be viewable, editable, and deletable.
Agent identity
How the agent presents itself should be consistent and not misleading.
6
Expect failure
Assume the agent will fail, and make failure survivable.
Agentic systems are probabilistic, which means they will be wrong, blocked, or interrupted, and the only question is whether the interface was designed for that or caught off guard by it. Most trust is lost not at the first error but at the first error that could not be understood, corrected, or undone. A surface that plans for failure keeps a bad step from becoming a dead end. Recovery is a first-class part of the design, not an edge case bolted on later.
Honest error states
Say what went wrong in terms the person can act on.
Graceful degradation
When the agent is uncertain or unavailable, the user should lose speed, not agency.
Correction
Make it easy to fix the agent when it is wrong.
Undo & rollback
Undo reverses a user’s own action; rollback recovers from a bad action the agent took. Both matter, and conflating them leaves gaps.
Refusal surfaces
When the agent will not or cannot act, it should say so and say why.
7
Make artifacts
Work should produce durable outputs, not evaporate into a transcript.
The thinking can happen in the conversation, but the product of the work should live somewhere stable. When results exist only as messages scrolled past, the work is effectively lost the moment the session ends. Artifacts are not only an endpoint: they accumulate, get revised, and are handed off, so the interface should treat them as living objects from the start. The test is simple: if the conversation disappeared, would the work still be there.
Live artifacts
Dashboards, apps, and tools that keep working after they are made.
Static artifacts
Reports, slides, documents, and plans that stand on their own.
Iterative updates
Change one part without regenerating the whole.
Version awareness
Know what changed, when, and from what.
Portability
Exports, links, and embeds, so artifacts outlive the conversation that produced them.
8
Build a home
Give agentic work a persistent, coherent place that fits the product it lives in.
A single task is not a product. As agentic work accumulates across sessions, threads, and outputs, it needs somewhere to live that holds together and belongs to its surroundings. An agent grafted onto a product as a floating box in the corner will always feel like a guest. The interface should give the work continuity over time and coherence with the brand, domain, and surfaces around it, and it should learn from how the person corrects and steers it.
Navigation
Movement across tasks, threads, artifacts, and workspaces.
Output browsers
A way to find and revisit what the agent has made.
Threads & context panels
Structure for ongoing work and the material it draws on.
Memory & continuity
Context carried across sessions so the person does not start over each time.
Brand & domain fit
An experience that looks and behaves like the product it belongs to, in the language of its field.
Adaptive layouts
Coherence across desktop, mobile, and embedded surfaces.
Feedback & steering
Corrections and preferences that teach the agent, surfaced as interface rather than buried in settings.
Written by practitioners
Engineers, designers, and product leaders who build agentic software and have watched the same problems recur across very different products.
- Parikshit
- Rabi
- Abhishek
- Aditya
- Prakhar
- Zahle
This is a starting point, not a finished specification. If these primitives describe what you have already learned, sign on. If they miss something, say what, and show the pattern.
To contribute, write to us at hello@thesys.dev.