Most AI interfaces feel like filing cabinets. You put something in, something comes back out, and the whole thing sits there waiting, inert, patient in the worst way. Chat boxes are fine for customer support scripts and Q&A demos. They are not fine for agentic work — for systems that plan, loop, observe, and act. The metaphor is just wrong.
I’ve been building agentic apps for long enough to have strong opinions about this, and the central one is: the UI is not a wrapper around the agent, it is part of the agent’s communication surface. If the interface doesn’t convey what the system is doing, the user has no model of the system. No model means no trust. No trust means abandon.
What “alive” actually means
Alive doesn’t mean animated. It means reactive, contextual, and occasionally surprising in ways that feel earned rather than random.
Reactive means the interface responds at the right granularity. Not just “here’s the final answer” but “here’s what I’m doing right now.” This is why streaming matters — not for performance, but for legibility. Watching text appear word-by-word communicates that something is actively being constructed. It’s not a trick. It’s honest.
Contextual means the UI knows where it is in the task. An agent planning a research sweep should look different from one that’s executing tool calls, which should look different from one that’s synthesizing results. Showing the same chat bubble for all three states collapses information the user needs.
Surprising means the interface occasionally reveals something unexpected — a result the user didn’t ask for directly, a subgraph the agent surfaced on its own, a connection between two things that weren’t obviously related. This is the hardest part to build deliberately, because surprise has to feel discovered, not manufactured.
Streaming + progressive disclosure
The most concrete technique I’ve landed on is pairing streaming output with progressive disclosure of intermediate state. The idea is simple: stream the primary output, but keep a collapsible sidebar or drawer that accumulates the agent’s reasoning trace, tool calls, and sub-results as they arrive.
This gives you two audiences simultaneously. The user who wants the answer gets it streamed directly. The user who wants to understand what the agent did can open the trace and read backward. Neither audience has to wait, and neither has to wade through the other’s content.
The implementation detail that matters: don’t batch the trace. If you wait until tool calls complete before showing them, you’ve already lost the feeling of liveness. Update the trace incrementally, even if individual entries look incomplete. The incompleteness is honest — it’s the system mid-work, not a polished artifact.
This site as an example
The background grid on this site — the pixel field that pulses and responds to audio — is a small example of what I mean by alive. It’s not decorative in the passive sense. It’s a read-out of system state: the drone engine, the beat, the current palette. The grid is doing something even when you’re not interacting with it, and that ambient activity communicates that there’s a live process underneath.
That’s the instinct I try to carry into agent UIs. The interface should feel like it’s running, not waiting. The difference between a sleeping computer and a working one isn’t capability — it’s visibility of process. Make the process visible, and the whole thing comes alive.