Coming from the world of HCI, I am looking forward making the shift into Agentic UIs. Whether it’s an evolutionary step or just another branch of HCI. There are fundamentals that drastically change and then there are certain design rules that still apply. Let’s dissect how Human-Agentic Design distinguishes from the old school HCI.
Does Autonomous Systems Need a New Interface Paradigm?
I am only asking questions here. We are entering a phase where software no longer waits for user input. It plans, reasons, delegates, retries, and acts—sometimes for minutes, sometimes continuously. Many things we used to do on classic UIs do not apply anymore. Click to CRUD. Agentic systems violate that assumption entirely. That is the good news.
In other news: We face completely new challenges.
Agentic response is hard to predict. Guardrails help to tighten the range of response behavior. But still, how do cope with uncertainty when:
- behavior is probabilistic
- outcomes emerge from context
- the same input may lead to different execution paths
- failure modes are often novel, not repeatable
I think the answer is rather simple.
We go from interfaces to relationships
An agentic system is not a feature. It is not a chatbot with better prompts.
It is a long-running, autonomous actor that:
- operates across tools and data sources
- changes state over time
- may succeed partially, fail, or adapt its plan mid-execution
- sometimes needs human intervention, sometimes not
Designing for this means we’re no longer designing screens.
We’re designing relationships between humans and autonomous systems.
Again, looking at the users, we define new goals. Goals that more apply to the ever changing states of a screen. To the never-ending stream of information.
Users need to understand:
- what the system is doing right now
- why it chose this path
- what assumptions it made
- when and how they can intervene
- whether the system can be trusted
Designing for State, Not Screens
Agentic UI design is fundamentally about state orchestration.
Instead of pages, we design:
- timelines
- activity streams
- execution graphs
- checkpoints and approvals
- system health indicators
- uncertainty surfaces
While writing I am constantly thinking about the CLI. To me this interface is far from perfect. But what it does perfectly is the how people consume information and interact, if necessary. The dialog interaction has made a comeback with ChatGPT and the like. The OG command line is stripped down to the most simple interface element: typography. Here and there some lines or ASCII code. If you’re (like me) old - you might remember Teletext? Same thing but different. Anyways I dig this old school cool UI stuff so I of course very excited to get rabbit hole deep into the overall design of such interfaces, to really understand why a dialog interaction has been