Why an AI Agent Should Tell You What It Is Doing, Every 45 Seconds

Here is a complaint we got about our own product, from the person who runs it: "When the designer is working, it feels like the system is stuck."

It was not stuck. The design phase — where an AI agent writes a design system and mocks up every key screen of a new product — takes about five minutes. We know exactly how long, because we measured it across eighty-four production runs: a median of 4.9 minutes, a slow one at 6.3, the slowest at 7.4. During that time the screen showed a spinner and one sentence: "Designing your app… This takes a few minutes." The sentence was true. It was also identical at second five and at minute seven, and nothing else on the page moved.

That is what "stuck" looks like from the outside. Not an error — an absence of change.

The agent was already talking. Nobody was listening.

The part that stung was that the agent narrated the whole thing. As it worked it emitted a line per screen — "Sketching the Checkout screen", "Sketching the Settings screen" — and those lines were faithfully written to a database. A median of eight of them per run, roughly forty-five seconds apart. And then never read back for that phase of the product. We had built the instrument and forgotten to connect the dial.

Connecting it took an afternoon. The panel now shows the agent's own words as they arrive, a count ("screen 3 of 7") once the agent has said how many there will be, a clock, and the last few lines stacking up underneath. Past the point where a run is slower than nine out of ten, the copy changes to say so plainly rather than continuing to imply it is nearly done.

The rule we build to now

It comes down to one principle, and it is stricter than "show a progress bar":

Nothing on the screen may claim progress that is not happening — and nothing that is happening may be hidden.

Both halves matter, and they pull in opposite directions from the easy fix.

The easy fix for a long wait is a progress bar on a timer: it fills over five minutes whether or not anything is going on. We refuse to build those. A bar that keeps moving while the underlying task has genuinely hung is worse than a frozen spinner, because now the screen is lying, and the moment a user catches it lying they stop believing anything it says. Every line on our panel is something the agent actually reported. When the agent has said nothing, the panel says nothing new.

The other half is the one we had failed. If the agent is doing something, the user is entitled to know. An AI that works in silence for five minutes is asking for a kind of trust that nothing about the experience has earned. An AI that says "Sketching the Checkout screen" has told you three things at once: that it is alive, what it is doing, and roughly how far along it is. That is not decoration. That is the difference between a founder waiting and a founder reloading the page.

What "narrate" actually requires

A few practical things fell out of doing this properly, and they generalise to any agent that runs for more than a minute:

• Emit at the seams, not on a schedule. The lines come from real stage boundaries in the agent's work — before the brief, after it (with the screen count, which is the denominator the UI needs), per screen, and before the save. A line on a timer is just a slower lie.
• Cover the tail. Our worst silence was not in the middle; it was the last eighty seconds, after the final "Sketching" line, while the last mockup finished and uploaded. That is minute five, exactly when a wait tips into "this is broken". One more line — "Saving your mockups" — closed it.
• Anchor the clock to the server. An elapsed timer that restarts when the page reloads tells the user the wait just began. It did not. The dispatch time lives on the server and the clock counts from there.
• Say when it is late, in words. We know the distribution. Past the 90th percentile the panel stops saying "usually five to seven minutes" and says "taking longer than usual — it is still running, nothing is lost". Honest copy at the right moment is worth more than a faster model.

The same panel now narrates the repository scanner too — the agent that reads an existing codebase — with its own nine stages and "step 4 of 9". Once the mechanism exists, every long-running agent gets it for free, which is the real argument for building it properly the first time.

Why this is a trust problem, not a polish problem

It is tempting to file "the spinner felt stuck" under UI polish. We think that undersells it. An AI agent that acts on your behalf — writes your requirements, designs your screens, edits your code — is asking you to hand over judgement for a while. The only thing that makes that handover reasonable is that you can see what it is doing and could step in. Silence withdraws that. Fabricated progress abuses it.

So the standard is simple, and it applies to every agent we run: tell the truth about what you are doing, tell it often enough that a person never has to wonder, and never, ever move the bar on a timer.