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.

Test your Agent

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.