Zero UI Is the Wrong Answer to a Right Question

The pilot users we talk to keep telling us the same thing, and it surprised us at first.

We build for a buyer that has options. Some of those options are the clean version of the 0-UI pitch you can hear in every AI discourse thread on LinkedIn right now. Voice in, answers out, agent does the rest. Lives inside the email client so nobody has to learn anything. Innovative on paper, beautifully demoed, the kind of thing that gets written up as “the end of dashboards.”

Our pilot users prefer the boring UI. Not because the AI underneath is dramatically better. Because the field reps who actually use this stuff every day do not want to learn a new conversational habit. They want the same view, the same shape, the same numbers in the same place, with someone smarter than themselves having already done the work.

That is the data point I keep coming back to.

The thesis

The 0-UI thesis goes something like this. AI keeps getting better. Interfaces start to feel like overhead. The natural endpoint is no interface at all: agents do the work, humans get notifications and approve. Chat replaces the dashboard. The screen, as a thing, was a workaround for software that could not understand what you wanted.

The argument has a real piece in it. We did build a lot of bloated software, and the AI shift is going to delete some of it. But the conclusion (kill the screen) is the wrong answer to a right question.

Input method vs trust artifact

The mistake is treating UI as one thing. UI is two things and they do different jobs.

The first is input method. How does the user tell the software what they want? Click a button, fill a form, choose from a dropdown. Chat is a great input method for fuzzy intent. Anyone who has ever written a SQL query that should have been one sentence in English knows the chat version is a real upgrade. Approve-this, run-that, find-me-customers-who, summarise-the-account. Replacing those with chat is mostly fine and sometimes much better.

The second is trust artifact. The output that proves the work happened, in a form a human can scan and act on under pressure, and the control surface for when the AI gets something wrong. The thing the field rep looks at for thirty seconds in the parking lot before walking into a customer meeting. The page the manager opens for a Monday review. The screen the auditor takes a screenshot of because something looked off. And the field the user clicks into to override a date the agent picked badly.

Chat is terrible at this. The output is variable, ephemeral, hard to scan, hard to share, hard to defend if something later goes wrong. A conversation is a fine way to ask. It is a bad way to remember what was said, prove what you saw, or compare today’s answer to last week’s.

It is also a bad way to steer. Anyone who has tried to correct a long agent response by typing knows the pain: “no, keep the first three but change the date on the fourth and drop the second one.” The agent might get it right. It might not. Either way you are doing the cognitive work of pointing at things in prose, instead of just clicking on the wrong one and fixing it. UI artifacts are not just for looking at. They are the control panel for when the AI inevitably guesses wrong.

Chat replaces the input. It does not replace the artifact.

Why this lands harder in B2B

The dividing line is not exactly B2B versus consumer. It is low-stakes/simple versus high-stakes/complex. For a low-stakes consumer query (summarise this article, what’s a good recipe for the leeks in my fridge) the input/artifact distinction is mostly invisible. You ask, you act on the answer, you move on. The cost of a wrong answer is low. You self-correct in the next message.

The same person, doing a complex consumer task, runs into the same trust-artifact problem the B2B user has. Try planning a multi-city trip with hotels and trains by chat alone, or comparing three mortgages through a conversational agent, and watch how fast you reach for a spreadsheet. The dividing line is not “I am at work.” It is “this is complex enough that I cannot hold it in my head.”

In a real B2B workflow, that line is crossed daily. The cost of a wrong answer is somebody losing a customer, missing a renewal, or sending the auditor on a six-week scavenger hunt. The user cannot afford a conversational interaction that varies day to day. They need the same view, the same shape, the same numbers in the same place. They need to know that if they screenshot it and put it in front of their boss, the next person looking at the same screen will see the same thing.

A field rep in distribution is not a power user. They have a 90-account territory and a 45-minute drive between visits. The valuable thing the software does for them is reduce decisions, not add them. “Here are the three accounts to call today and the one talking point each” beats “ask me anything about your accounts” every time. The first is a tool. The second is a homework assignment.

The best case for zero UI

The strongest case for 0-UI is search. It is stateless, one-shot, and retrieval-based. You want an answer, not a workflow. Blue links were always a workaround for the fact that the engine could not give you the answer directly. Now Gemini can. Of course the interface collapses there. The job was retrieval and retrieval is exactly what an agent does best.

At I/O 2026 Google shipped the biggest redesign of the search box in 25 years. AI Mode now serves a billion users a month with conversational, follow-up search. Information Agents run in the background and ping you when something you care about changes. And Generative UI builds a one-shot custom interface per query: a small simulation, a comparison chart, a mini-app, generated on the fly for that one question.

Notice what Google did and did not do. They did not kill the UI. They built more of it, on demand, for each query. The thing they killed was the assumption that the interface had to be static and built ahead of time.

That is the move. Even in the cleanest case for 0-UI, the answer was not zero. It was situationally appropriate UI, generated on demand. The interface stays. It just stops being a fixed artifact that someone designed last quarter.

That is not the same job as preparing for a customer visit. A search query has no state, no history, no accountability, no follow-up four weeks later when something looked off. A decision-support workflow has all four. The UI you generate for one is not the UI you generate for the other. But in neither case is it zero.

Where the discourse goes wrong

The 0-UI argument tends to start from the right observation (a lot of software is a frustrating maze of screens that should not exist) and end in the wrong place (so we should replace screens with chat).

The actual conclusion is more boring. Replace the analysis layer. Keep the interface.

A workflow with real stakes has three layers, and “what AI replaces” is the only thing that really differs between the three answers people are giving right now.

Old SaaS

Interface
Analysis: human
Data

0-UI / Agent-first

Agent replaces UI
Analysis: AI
Data

UI on top, AI underneath

Interface
Analysis: AI
Data

In the old version, the human was the intelligence layer. They opened three reports, compared quarters, spotted the anomaly, decided who to call. The software showed the data.

The 0-UI version replaces two layers (interface and analysis) with an agent. Just type at it.

The version that has worked for us, and that I keep seeing work elsewhere, replaces only the analysis layer. The human stops being the analyst. The AI does the pattern recognition, the ranking, the anomaly detection. The interface stays, often barely changed, because the interface was not the problem. The cognitive load of doing the analysis was the problem.

People adopt new results, not new interactions. The rep does not want a new way to work. They want to walk into the meeting better prepared. You can deliver that without making them learn anything.

When zero UI is actually right

I do not want to swing too hard. There are cases where 0 UI is the correct call.

Pure automation, no decision: invoice arrives, gets categorised, posted, ledger updated, you get a notification if something went wrong. There is no analyst here. There is no artifact to scan. The work is fully invisible by design.

Pure exploration, low stakes: “summarise this thread for me,” “what did we say about Acme last quarter,” ad-hoc questions a human would otherwise hand-build a report for. Chat is great. The artifact is the next decision, not the answer itself.

Augmented input on top of a structured UI: voice-to-fill on a form, natural-language search inside an existing list, an AI suggestion in a sidebar. Almost always wins. This is chat as input method without the artifact regression.

The case it does not work, and the case the 0-UI evangelists keep skipping, is the one in the middle. Daily professional workflows with real stakes, repeated by the same person, where consistency and scannability matter more than flexibility. Field sales, clinical decision support, ops dashboards, financial review. The places where dashboards exist for a reason.

I might be wrong

I should be honest that my position has a half-life.

The argument rests on two assumptions about today’s reality. The first is that conversational answers are still variable enough, slow enough, and hard enough to share that they fail the trust-artifact test in a way scannable dashboards do not. The second is that the users I care about (field reps, ops people, anyone with a tight budget of attention and a high cost of being wrong) are not going to retrain themselves around a new interaction model on someone else’s timeline.

Both assumptions are eroding. Models get more consistent. Tooling gets better at producing structured, comparable output instead of variable prose. A generation of users who grew up talking to assistants is entering professional roles where their boss did not. If any of those curves move faster than I expect, the trust-artifact argument shrinks. The “boring UI” that wins pilots today wins fewer of them in three years.

So I would not bet against the shift happening. I would bet against it happening as cleanly and as soon as the loudest version of the 0-UI argument predicts. The transition is going to look like augmented UIs slowly absorbing more chat affordances, not chat replacing UIs in one move. And the products that survive the middle of that transition are the ones that keep the artifact intact while the analysis layer underneath quietly turns into an agent.

If I am wrong, I am wrong on the timeline, not the direction.

The middle ground

The interesting framing, the one worth stealing from this whole discourse, is not “kill the dashboard.” It is zero manual work, not zero UI. The interface stays. The labour underneath disappears.

Google’s I/O move is a hint of where this is heading. So is the agent-emits-UI pattern that has quietly become the way interactive agents ship in production. Instead of the agent answering with text, the agent calls a tool that returns a structured component, a chart, a table, a form, that the user sees and interacts with in the same turn. The artifact is still an artifact (visible, scannable, shareable) but it gets built per moment instead of designed once and reused for years. Generative UI.

Databricks’ Genie is the same idea on the enterprise side. The user asks a natural-language question, the system generates a chart, a SQL query, a structured answer, and (the part that does the trust-artifact work) a “thinking steps” panel that shows how the question was interpreted and which tables were touched. That panel exists because explanation is the price of being trusted twice.

That is the bet I would defend. Not chat instead of UI, but agents underneath a UI that can rebuild itself when the job changes. The interface stops being a fixed monument and becomes another thing the AI does.

The boring static UI wins today. The dynamic, generated, AI-shaped UI wins tomorrow. The chatbox in the middle is a distraction.

The field reps using the boring UI have already voted, though. They will keep voting that way for a while.

The SaaSpocalypse Has Begun (heise.de, in German). The mainstream version of the 0-UI argument I’m pushing back on.
Generative User Interfaces (Vercel AI SDK). Practitioner docs for the agent-emits-UI pattern.
DynaVis (CHI 2024 Best Paper). Academic anchor: natural-language input synthesises persistent GUI widgets.
AI/BI Genie is now Generally Available (Databricks, 2025). The “thinking steps” panel as a trust-artifact pattern.
The Agent Doesn’t Know Your Stack. My previous post. Same underlying thesis (AI replaces the analysis layer, not the interface) applied to coding agents instead of dashboards.