The graphical interface — screens, navigation trees, structured flows — was built to compensate for a simple limitation: systems couldn't understand intent. Users clicked because machines couldn't interpret the meaning. If you wanted something done, you had to follow the path the interface allowed.In AI-native products, that premise no longer holds. And we've seen this shift first-hand.
What is agentic UI?
Agentic UI is the interface of a product that acts on goals rather than commands: the user states an intent, and an AI agent plans and carries out the steps across tools and services. The interface stops being the place where work happens and becomes the place where people set the goal, check what the agent did, and step in when needed.
Instead of waiting for users to trigger every step manually, these systems can interpret intent, coordinate across services, and execute multi-step processes autonomously. A task that previously required several screens and manual steps can now begin with a single expression of intent.
This shift is already visible in how leading thinkers describe the future of interaction. Jakob Nielsen, for example, argues that autonomous agents will increasingly act on behalf of users, to the point where users may stop interacting with interfaces directly and instead rely on agents to browse, decide, and execute tasks for them.
In practice, this doesn’t eliminate interfaces — but it does change their role. People stop operating software step by step and start supervising outcomes.
That shift also changes what we design. Product teams spend less time structuring flows and more time defining behavioural architecture — the rules that govern how a system should reason, act, and escalate decisions.
AI-native products don’t start with screens
In AI-native startup collaborations, this shift becomes obvious very early. Founders rarely begin with, “What will the dashboard look like?” Instead, they ask: “How will the system decide?” That question reframes the entire design process.
Conversations focus on reasoning frameworks, confidence thresholds, autonomy limits, and human override mechanisms. Screens are discussed later, often as a consequence of system behaviour rather than the starting point of the product.
In these products, the interface becomes the visible edge of a much larger behavioural system. If the reasoning layer is weak, no amount of interface polish can compensate for it.
Interfaces become contextual
As AI absorbs operational complexity, interfaces themselves begin to change. Instead of static menus and universal layouts, systems dynamically surface what matters in the moment: what requires attention, what can be automated, and what needs human confirmation. This means the same product can appear different depending on the context of use.
A beginner might see structured guidance and explanations. An experienced user might see a compressed interface focused only on key signals. A manager might receive summarised insights instead of operational controls. In some cases, an AI agent might operate in the background without requiring interface interaction at all.
We saw a similar pattern when working on Norvana, an AI-native health platform designed to help users understand and manage their wellbeing over time. Health data on its own is overwhelming — dozens of indicators, test results, and lifestyle metrics.
Instead of exposing raw dashboards, the system surfaces insights contextually: highlighting patterns, suggesting follow-ups, and connecting signals across sleep, stress, activity, and medical indicators.
"The interface adapts to what matters in that moment, rather than exposing the entire structure of the system. This is not just personalisation. It is a structural adaptation."
The interface is no longer fixed. It is generated by context. In some products this is literal: with generative UI, the model assembles the interface at runtime from components the team has designed, so the design system sets the limits of what it can build.
Multimodal interaction expands the surface
At the same time, screens are no longer the only interface surface. Voice interfaces, background agents, system-level assistants, and API-driven integrations reduce dependence on traditional visual UI.
In enterprise environments, for example, a procurement manager may not open a dashboard at all. Instead, they might receive a summarised recommendation from an AI agent that has already analysed vendors, flagged risks and proposed the optimal choice.
In these cases, the interface is not the tool. It is the explanation. The centre of gravity shifts from interaction mechanics to outcome clarity.
Agentic UI vs conversational UI vs zero UI
The three terms are often used interchangeably, but they describe different things. Conversational UI is about the channel: people type or speak instead of clicking. Zero UI is about the surface: no screen at all, a term coined by Andy Goodman at Fjord for experiences driven by voice, movement, and ambient signals. Agentic UI is about who does the work: the system acts, and the person supervises.
Conversational UI
- 𐩒What changes: the input channel.
- 𐩒How it works: natural language, typed or spoken, turn by turn.
- 𐩒User's role: asks and answers.
- 𐩒Role of the screen: a chat window.
- 𐩒Typical examples: chat assistants, support bots, voice assistants.
- 𐩒Main design challenge: clarifying intent, turn-taking, tone.
Zero UI
- 𐩒What changes: the surface.
- 𐩒How it works: voice, gesture, sensors, ambient context.
- 𐩒User's role: speaks, moves, or is simply present.
- 𐩒Role of the screen: none or minimal.
- 𐩒Typical examples: smart speakers, learning thermostats, wearables.
- 𐩒Main design challenge: feedback and discoverability without visuals.
Agentic UI
- 𐩒What changes: who does the work.
- 𐩒How it works: the system pursues a goal and carries out the steps itself.
- 𐩒User's role: sets the goal, reviews, approves, or overrides.
- 𐩒Role of the screen: a trust surface for status, reasoning, and confirmations.
- 𐩒Typical examples: agents that compare vendors, book travel, or reconcile accounts.
- 𐩒Main design challenge: autonomy limits, confidence, override, and recovery.
The categories overlap. A voice assistant that books a trip on its own is conversational, screenless, and agentic at once. In most AI-native products, conversation is how intent comes in, and the screen, where there is one, is where the agent's work becomes visible and governable. That last part is where agentic UI design concentrates, and where interaction design starts to break if it is still built around step-by-step flows.
Friction does not disappear
It is tempting to imagine AI eliminating friction entirely. In reality, friction simply changes form.
Users still need transparency, control, and visibility into how a system reached its decision. They need to understand what data was used, how confident the model is, and how they can intervene if something looks wrong.
This is where UI remains critical. But its role changes.
Instead of guiding users step by step through tasks, the interface becomes a trust surface — a layer that explains what the system did, communicates confidence levels, and allows users to review, correct or override automated decisions. Design becomes less about guiding actions and more about governing automated behaviour.
Some friction is worth keeping. When Airbnb rolled out its AI search this autumn, Brian Chesky drew the line in an interview with TechCrunch: booking a flight is a chore people happily hand over, but choosing a place to stay is not. People get more pleasure from planning and anticipating a trip than from the trip itself, so an agent that picks the perfect cabin in four seconds would take away the part they came for. Airbnb kept the browsing and built the AI around it. The design question is not only where the agent takes over, but where the human moment is the product.
What is actually dying
From our experience, what’s fading is not the design itself. What’s fading is the interaction model that defined software for decades.
Static flows. Universal layouts. Multi-step click processes that expose every layer of system complexity to the user.
AI-native systems absorb operational complexity internally. As a result, there are fewer required interactions, fewer visible steps, and fewer explicit commands. Users increasingly supervise outcomes instead of operating tools, and that changes what matters.
The strategic shift for product teams
In enterprise and AI-driven environments today, product discussions rarely revolve around button hierarchies or dashboard density.
Instead, teams focus on questions like: How does the AI reason? What data can it access? What actions are allowed to automate? When must it ask for confirmation? How should confidence and uncertainty be communicated?
The competitive layer is no longer primarily the interface; it is the behavioural architecture behind it.
UI still exists, but its role changes. It becomes a transparency layer, a trust mechanism, and a governance surface that helps users understand and control system behaviour.
Why this matters for enterprise leaders
For enterprise organisations, this shift is not just a design trend. It fundamentally changes how digital products should be built and evaluated.
For years, enterprise software competed on interface quality: better dashboards, clearer reporting layers, and improved navigation. But when AI systems begin to interpret data, generate insights, and execute actions autonomously, the interface stops being the primary value layer. The real differentiator becomes the system’s ability to reason.
Enterprise products increasingly compete on how well they interpret intent, how reliably they automate decisions, how transparently they explain system reasoning, and how safely they balance autonomy and human control.
For leaders building AI-native products, the key question is no longer: “How should the interface work?” It is increasingly: “How should the system behave?”
So is UI dead?
Not exactly. But in the classical sense — fixed screens controlling deterministic flows — UI is losing strategic centrality in AI-native systems.
The interface doesn’t disappear; it transforms.
Complexity moves from the screen to the system. From visible controls to invisible reasoning. From navigation mechanics to behavioural design. And this shift is not speculative.
We are already designing products where the most important decisions happen before the user sees anything at all. The most valuable digital products of the next decade will not be the ones with the most polished dashboards. They will be the ones whose systems think clearly, act responsibly, and make their reasoning visible to humans.
What does this mean for your product?
Discuss with your AI.
Denys is a Founding Partner & CEO at The Gradient. He leads our collaborations with enterprise clients — helping large organisations move fast, think like startups, and design products that stay relevant in a world being reshaped by AI.
