A voyage over a chat thread

The first generation of AI chat looks like a terminal transcript. I want to help lead what comes next for brand and design work: a rich, step-by-step thread that still lets you retrace the whole journey.

Most of the AI tools we use today feel like one of two things: a terminal window or a chat thread. I think that is unavoidable for a while, and not entirely bad. However, we need an optimum way to go back, retrace our steps, and understand which forks in a conversation served which purpose.

But the first-generation chat pattern, a composer box at the bottom and a growing wall of text above it, is not where this ends. I believe the interface challenge of the next few years is turning that chat thread UI into something richer and more guided without losing what makes it work. I expect many solutions to show up across the market. I want to be one of the people leading that new mental model, especially for brand and design work.

Others are already moving

You can see the shift starting in tools like Cursor, v0, Lovable, Replit Agent, and Devin. Each moves away from pure chat toward structured, step-by-step flows with cards, previews, and inline actions. If you design AI products, they are worth studying side by side. I also believe the audacity to declare a step-by-step flow is provocative but critical. And it demands a point of view for championing consistency in the elusive layer beneath the ever-changing tools.

What they share is a direction: the conversation should feel like a guided journey, not a raw transcript. Most of them start from code. I am interested in what that this UX journey looks like when the work is about defining a brand, a campaign, or a design system.

Google’s A2UI 1.0 release points in the same direction from a different angle. It is an open protocol that lets agents answer with interactive screens (forms, choice pickers, charts, decision cards) rather than walls of text. The agent describes the interface as data; the host app renders it with its own native components and design system (using your own design system as reference). The result is low-latency, brand-faithful UI that can appear inside an app or inside third-party assistants. For brand and design work, that separation matters: the agent can propose structure and options without ever taking ownership of how the brand actually looks and feels.

The decision: one long vertical thread

Early on in designing Brand Builder, I had to make a call about the canvas. Would it be a tight form flow, one question per screen, dot by dot? Or one long, vertically scrolling thread?

I chose the thread. You answer a question, scroll down, and the whole session becomes one continuous trace. The advantages are real: natural flow, easy review of past decisions, and better context. The cost is real too. A long thread can lose focus and feel less guided.

So the thread needs structure inside it. Three pieces matter most to me:

  • Step markers. Each question is a clear beat in the thread, not just another message.

  • Position locks. When you scroll back up to an earlier step, the interface pins it and reminds you exactly which step you are looking at, so you do not get lost in your own history.

  • Decision cards. Forks and commitments are called out visually and locked, so you can see later where the work turned and why.

That is what I mean by a voyage over a chat thread. It keeps the familiar scroll, and it adds the wayfinding a real project needs. Protocols like A2UI make the decision-card part portable: the same interactive surface can be emitted by an agent, rendered natively in the brand’s own components, and still sit inside the continuous thread instead of jumping you into a separate form or modal.

Take a concrete moment: choosing the primary personality for a new brand. In a raw chat transcript this usually dissolves into a long exchange of “more bold,” “a bit warmer,” “try again,” with the actual commitment buried somewhere in the middle. In the structured thread it is a marked step. The relevant agent surfaces three directions with short rationales. If the choice would lock expensive downstream work (a LoRA, a visual system, design tokens), the Arbiter pauses with a decision card that states what is at stake and what changes with each option. You pick. The choice is written into the brief and decision log, and later you can scroll back, see the pinned step, and understand exactly why the brand sounds the way it does.

Where the agents live

Once you add helpful agents, the next question is where they appear. In a sidebar? In a box under each question? Both?

Both. A companion panel on the side shows the overall status of the agents and which ones are active. Each question on the canvas gets its own compact reasoning trace directly beneath it, so the agent’s thinking stays next to the task it is about.

The default set I have defined is small: four specialists, for product, engineering, marketing, and design, plus one coordinator I call the Decision Arbiter. A participant can run fewer of them, skip agents entirely, or add more later.

They work on a shared object, not in separate chats. All four write to the same brief, decision log, and deliverable package. That keeps the founder’s canvas as one thread instead of four competing ones.

Facilitators, not finishers

The mode I like best is what I call facilitator mode. The agents are on by default, but they do not finish the work for you. They set the table, then wait.

You land on a question. Before you type, the relevant agent has pulled a few options, shown why those options exist, and asked one sharp question back. You pick, reject, tweak, or ignore them, and the answer is written into the brief. Two small controls sit by each step: one to have the agents draft an answer you then edit, and one to do the step yourself.

The risk is noise. If every question gets a four-agent monologue, the canvas dies. So one agent leads each step, and the others chime in only when they have a real conflict or constraint.

The Arbiter spends your attention carefully

The Arbiter does not do the work. It decides whether the agents may continue or must stop for you. It asks a few questions in order. Is this a taste or relationship call, like voice or audience promise? Would continuing lock something expensive, like a LoRA training set, a visual system, or design tokens? Do two specialists disagree in a way that changes the deliverable? If any answer is yes, it pauses.

A pause is not a chat message. It is a card: the decision, two to four options, what is at stake, what changes with each choice, and who disagreed and why. You pick. That choice goes into the decision log, and the agents resume from that lock without quietly reopening it.

The rule I keep coming back to is short. Pause when the next action spends creative capital. Stay quiet when it only explores. Specialists produce options and critiques, the Arbiter makes the work legible, and the person makes it real. Open generative-UI protocols give that pause card a concrete implementation path: the Arbiter can emit a structured, interactive surface that the brand system renders, so the human gate stays visible, native, and traceable inside the same thread.

Why this matters for design work

Brand and design decisions are taste decisions. They are hard to reverse once a system, a campaign, or a style is trained on them. A raw chat transcript buries those moments. A form flow hides the context around them. A structured thread can show both: the journey and the forks.

When agents can also emit brand-native interactive surfaces instead of only text, those forks become easier to find, easier to revisit, and harder to quietly override. Protocols like A2UI are useful exactly because they keep the brand system in control of rendering. They do not, by themselves, solve the harder problem: knowing when a choice spends creative capital and must stop for a person. That timing and judgment still belong to the governed memory and the human gate.

Closing

I do not think the chat thread goes away. I think it grows up. It becomes rich media, step by step, with decisions you can find again and agents that know when to step back. The recent arrival of open protocols for agent-generated native UI is one more signal that the industry is moving in this direction. Even then, the leftover human job is the same: timed brand language and the irreversible taste calls that should not be made quietly. I am building that for brand and design work now, and I want to help lead that shift with a team that cares about getting it right.