We built a UI for a platform that’s supposed to be run by agents. If the agent stands up the pipeline, runs the job, and pulls the result, who is the screen for?
It’s for the human who doesn’t trust the agent yet. That’s a real job. It just isn’t the job UIs used to do.
The screen stopped being a control surface
For thirty years the data UI was where the work happened. You opened the form because the form was how you made the thing. You read the job list because that was how you knew the job ran. Take the screen away and the work couldn’t get done.
On an agent-native platform that’s gone. The agent creates the pipeline with the same call the button would have fired. It runs the job and polls it to done with nobody watching the spinner. Every click a person used to make, the agent makes as a call. The work left the screen.
So what’s still on it? Not the controls. The explanation. The panels we kept answer a different question. Not how do I do this, but what did it just do and should I believe it. The live feed of the agent’s MCP calls. The pipeline status reading 84,000 rows in, 2,310 held back. The plain-English cleanup plan it floated before it touched a thing. None of that runs the job. All of it tells you whether the job ran right.
The UI changed jobs. It used to be the cockpit. Now it’s the window.
Explanation is a trust loan
The strange part is that this UI is built to lose its value.
The first time you let an agent take a new broker feed from prompt to answer, you watch everything. You open the monitor and read the connector as it writes it. You go through the proposed transform line by line. You check the held-back count against your gut. You’re supervising a new hire.
By the tenth run you skim the summary. By the hundredth you glance at the final number and move on. By the thousandth you don’t open the screen at all unless something pages you. The work didn’t shrink. Your need to watch it did. Every clean run pays down the trust you extended, and the explanation UI is the repayment schedule.
That’s the part people miss. We’re used to UIs that matter more the longer you use them. The muscle memory deepens. The dashboard becomes home. This one runs the other way. The more it works, the less you reach for it. A panel you check obsessively in week one and ignore by week six didn’t fail. That’s the panel doing its job.
So what is the developer’s job now?
It moves from building control to building legibility. The old skill was laying out a form so a person could drive the machine. The new one is making the machine readable: surfacing the single number that says the run is sound, writing the plan so a human can veto it in a sentence, putting the held-back rows on screen instead of in a log nobody opens.
The discipline that comes with it is restraint, and restraint does not come naturally to anyone who builds UIs for a living. The instinct is to add. One more panel, one more setting, one more view. On a system a human operates, that richness is a feature. On a system an agent operates and a human only supervises, every new panel is a bet that someone is looking. Most of the time, nobody is. A rich UI on an agent-run platform is usually a monument to supervision that stopped happening.
The better instinct is to build the explanation and make it ignorable. You’re building a window, not a home. It stays dark until there’s something worth seeing.
What survives is the exception
The UI doesn’t disappear. The “no interface at all” fantasy points the right direction and overshoots. What goes away is the steady-state UI, the screen you’d open every day to keep tabs. What stays, and matters more, is the exception surface: the thing that pulls you in exactly when judgment is needed and shuts up otherwise.
The agent runs the loop. It hits the row that won’t reconcile, the source that drifted overnight, the number that looks wrong for the month. That’s when the screen lights up, because that’s when thirty years of pattern recognition are worth interrupting you for. The rest of the time the window stays dark. A dark window means the system is working.
So we built a UI for a platform meant to be run by agents, and we held it to a strange standard: good enough that you’d stop needing it. Not by hiding anything. By earning enough trust that watching becomes optional. The screen that explains the agent well enough is the screen you leave closed. You’ll know it worked the day you forget it’s there.
Todd Fearn is the founder and CEO of Datris, an open-source, agent-native data platform. He has spent thirty years building production data infrastructure for financial institutions — Goldman Sachs, Bridgewater, Deutsche Bank, Freddie Mac — and has founded several venture-backed companies.