Agent UX Is an Interface Contract, Not a Chat Window

The short answer

The most dangerous UI pattern in AI products today is the blank text input with a sparkle icon next to it. Every conference this summer—AI Engineer World's Fair, The AI Conference, Ai4—is running demos of agents that book meetings, query databases, and edit design files. The demos look magical. The production versions fail because the interface contract is broken: the UI promises unbounded capability, but the backend can only deliver bounded, probabilistic results.

An agent UI is a contract. The surface communicates what the agent can do, how certain it is, and when the user needs to step in. If the contract is implicit ("ask me anything"), the user forms expectations the product cannot meet. The result is frustration, low retention, and support tickets that blame the AI for being wrong when the real culprit is the interface lying about its competence.

Framer 3.0's integration of AI agents directly into a visual design canvas offers a glimpse of the better pattern. Instead of a chat sidebar divorced from the work, the agent operates on the actual DOM—selecting layers, adjusting properties, showing diffs before applying. The interface makes the agent's reasoning legible. That's the standard we should hold all agent UIs to.

Key takeaways

• Never ship a blank chat. Every agent UI should start with suggested actions, capability cards, or a structured prompt that frames what the agent can do. Guide the initial query to stay within the reliability envelope.
• Instrument agent confidence as an interface primitive. Show a confidence bar, a reasoning trace, or a "sources checked" indicator before the agent takes an action. Users who see uncertainty handle errors better.
• Inline citations or nothing. A citation at the bottom of a long answer is hiding the evidence. Place references next to the specific claim, and make them actionable (click to open source, hover to preview).
• Design the handoff before the happy path. Map the exact UI state when the agent needs human review, when it hits a confidence floor, and when the user asks for a human. Every handoff should include conversation context, tool results, and the current product state serialized in a way the human can pick up immediately.
• Treat latency as a UX signal, not a bug. Streaming responses are table stakes. But streaming without intermediate state indicators (thinking, searching, reading) is still a black box. Show the agent's internal steps as they happen.
• Audit trails are a product feature. The ability to review, undo, or rerun an agent action is not a logging concern—it's how you build trust. Expose an activity feed with before/after states.

What most teams miss: the prompt/UI contract

Every agent has a prompt or system instruction that defines its behavior boundaries. That prompt is a backend artifact. The UI, however, makes implicit promises about what the agent understands. The most common failure mode in shipped agents is a mismatch between the prompt's scope and the UI's surface area.

Say your agent can query a sales database for account details and recent orders. The prompt restricts it to select-only actions. But the UI is a generic "Ask anything about your pipeline" input. Users will type "Close the deal with Acme Corp" or "Change the stage to won." The agent can't do that, but the UI gave no signal that it can't. The result is a failure that feels like the AI is dumb, when really the interface misled the user.

The fix: expose capability cards, action buttons, or structured input options that make the scope visible. One of the strongest patterns I've seen among engineering-led teams deploying agents (Retell, Rasa) is the "capability badge" at the top of the chat—a row of labeled buttons that each expand to a short prompt template. The user clicks "Look up an account," and the input pre-fills with a structured query format. The contract is explicit.

Citation placement as a product quality signal

Every AI-generated answer should pass the "citation proximity test." A user should be able to glance at a sentence, see a reference marker within the same line, and click it to view the source. Three-line paragraphs with a single citation at the end fail this test—the user has to guess which claim the citation supports.

In voice agents, citation is harder. The best pattern I've seen in production voice deployments delays the synthetic voice output until a full grounding pass completes, then inserts short attribution markers in the spoken text ("as of June's financial report..."). The companion UI shows a scrolling transcript with live source highlights. For fast-turnaround queries, that delay is worth the trust it builds.

Empty states and the "don't know" line

The most honest UX an agent can deliver is a well-designed "I don't know." When retrieval returns no results or confidence is too low to act, the UI should show that explicitly, with what the agent checked. An empty agent response or a generic "Something went wrong" erodes trust faster than a wrong answer.

I prefer a pattern where the agent responds: "I couldn't find a match in [these sources]. Here's what I looked at:" followed by a compact list of queries or indices searched, each with a short status indicator. The user can then refine or ask a human. This changes the failure from a black box to a transparent diagnostic.

What to evaluate in an agent UI

When you're reviewing an agent UX as a product engineer, there are only four things that matter: (1) does the user know what the agent can do before they type anything? (2) can the user see what the agent is doing while it works? (3) can the user verify a claim back to its source in one click? (4) when the agent fails, does it say why in terms the user can act on?

Every other concern—model choice, latency optimization, RAG chunk size—is secondary. Get the contract right first. The conferences this summer are full of impressive agent demos. Few of those demos will survive first contact with real users unless the interface stops pretending the agent is magic and starts proving it's useful.