Silence Reads as Slowness

We released Exponential three days ago into the wild. The user feedback was surprising: “xpo drive is slow”. How could that be? A story that would take twenty minutes of manual prompting, reviewing, course-correcting, the drive loop completes in under five.

I timed a typical run. The supervisor evaluates the spec: twelve seconds. The coder implements and runs tests: sixty to ninety seconds. The supervisor reviews the diff: another twelve.

But between those phases? Nothing. A blank line. A cursor blinking in the dark. No hint that the agent is doing real work: reading files, reasoning through the spec, writing code. From the user’s perspective, the tool has frozen.

The conference connection

I was at WeAreDevelopers World Congress in Berlin this week. During one of the talks, the speaker was telling a war story about adoption of his AI agent in production. And guess what? He had hit exactly the same issue. His story landed differently sitting in that audience, because I’d just been reading feedback from people who thought my tool was broken when it was actually working fine.

The connection clicked: xpo drive has the same trust problem. When an agent works silently, users fill the silence with doubt. Is it stuck? Did it crash? Should I restart it? The silence doesn’t just feel slow. It erodes confidence in the tool itself. Every second of no output is a second where the user is deciding whether to interrupt.

Perceived performance

This is a well-understood problem in UX. Perceived performance often matters more than actual performance. A progress bar that moves makes a three-second wait feel shorter than a blank screen for two seconds. Spinners, status messages, streaming output: they don’t make anything faster. They make waiting tolerable.

But when I built xpo drive, I was focused on correctness. Does the loop converge? Does the supervisor catch real issues? Does the coder produce clean code? The output was a final summary: story completed, story blocked. Everything between “starting” and “done” was a black box.

And that black box was the problem.

Making the work audible

I started work on the train back from Berlin. The core idea: stream the agent’s reasoning as it happens. Not the raw model output, that’s too noisy. But structured status updates that tell you what phase the loop is in and what the agent is currently thinking about. What tools they are calling. What files they are reading or writing.

The implementation landed in a few distinct pieces.

Phase indicators. The orchestrator now emits status lines at each transition: “Evaluating spec,” “Building implementation,” “Running tests,” “Reviewing diff.” These are the coarse-grained beats. You always know which phase you’re in.

Reasoning summaries. The supervisor and coder agents stream short reasoning fragments as they work. When the supervisor is reading a file, you see which file. When the coder is deciding between two approaches, you see the trade-off it’s weighing. These aren’t the full chain-of-thought. They’re curated signals: enough to show progress, not enough to drown you in output.

Progress indicators. Completed phases get checked off. Larger phases split into steps, each one ticked as the agent works through it.

What changed

The total execution time didn’t change at all. The same stories take the same number of seconds. But the experience is completely different. The difference is that the silence is gone.

Watching xpo drive now feels like watching a colleague work. You see them read files, pause to think, make changes, run the tests, frown at a failure, try again. You’re not doing the work yourself, but you can see that work is happening. You can tell when things are going well and when they’re not.

The deeper lesson

I keep learning the same thing from different angles: making agent work visible is not a nice-to-have, it’s structural. The agent identity system solved attribution: who did what. The timeline solved history: what happened while you were away. Streaming progress solves the present tense: what’s happening right now.

I knew what the agent was doing because I built the system. But the moment someone else sits in front of it, every gap in visibility becomes a trust gap. And trust gaps compound. A user who thinks the tool is slow will use it less. A user who uses it less won’t discover that it actually works well. The perception becomes self-fulfilling.

The fix for “it’s slow” required no performance tuning. It was entirely about communicating and exposing the work that was being done behind the scenes. The tool needed to narrate its own work, not for the agent’s benefit, but for the human’s.