One reason AI product design keeps feeling shallow is that too many teams still think they are designing a better prompt box.

They are not.

If the previous phase was “add a chat rail,” the next phase will be “realize the rail needs to carry much more than chat.”

Because the core object in an agentic application is not the prompt.

It is the supervised run.

That run may begin in natural language. But almost immediately it accumulates structure:

• a goal
• constraints
• tools
• memory
• assumptions
• branch points
• evidence
• approvals
• diffs
• reversions

At that point, the interface is no longer a conversation transcript. It is an execution surface.

And that means a serious agent-first product needs to show more than a scrolling chat log and a regenerate button.

It needs to show:

• what the agent thinks it is doing
• what tools and data it is using
• what assumptions it made
• what changed
• where the human can interrupt
• what the alternative branches are
• how one branch compares with another

This is why I think branching, or something very close to it, could become a mainstream UX primitive outside software engineering.

Traditional apps were built around a single-path assumption. The user picks one path, the system executes that path, and history appears later as audit logs or undo.

Agentic systems break that assumption.

If an agent can cheaply explore multiple viable plans, then “show me three approaches” stops being an exotic request and starts becoming a normal one.

So what looks like an implementation detail today will become ordinary product behavior tomorrow:

• parallel exploration
• side-by-side comparison
• selective merge
• rollback to an earlier decision point
• rerun from a fork under tighter constraints

Software people already recognize this pattern because Git made us fluent in it. The interesting shift is that branching escapes engineering and enters mainstream app UX. A procurement user may compare sourcing branches. A BI user may compare forecast branches. An operations lead may compare staffing branches.

They may not call them branches.

But that is what they are.

So the short version is this:

The future of serious agent UX is not “a larger composer.”

It is much closer to a workspace for supervising runs.

And once you see that, a lot of current AI product design starts to look under-specified.

The last question is the one enthusiasts usually skip: should every app move in this direction? I do not think so.

---

Previous: When the chat rail becomes the app

Related: Accessibility gets more important in the age of agents

Next: Not every app should become an agent

Sources and grounding: WCAG 2.2, the WAI-ARIA Authoring Practices Guide, and current OpenAI and Anthropic product descriptions for agentic tools and workflows.