By Nick Babich
AI agent UI examples fall into three groups: chat, agent and copilot screens, and they differ mainly in how much control the user keeps.
This page shows eight of them as annotated, fictional screens, each with the decision it asks of the user and the way back if the AI gets it wrong. If you are weighing outside help for an AI product, UX design teams that list AI product work are collected on our AI list.
Key Takeaways
- Control decides the layout: a chat screen asks the user to read and verify, a copilot screen asks them to accept or discard, and an agent screen asks them to approve, steer or take over.
- Every screen asks one question: name the decision before you draw the screen, and the labels, buttons and defaults get easier to choose.
- Agents need a way in: I read the public docs of six agent products in November 2026, and all six describe at least one way to approve, steer or take over.
- Every AI output needs a way back: a discard button, a reject-all, a stop control or a restore point, placed where the user is already looking.
- Placement is a design choice: a side pane, a floating toolbar and ghost text solve different jobs, and a chat panel is the wrong answer for many of them.
What these eight screens are (and what this page is not)
These are eight fictional screens I drew for this article, each in its own product style, so you can compare the interaction and not a brand. None is a screenshot of a real product, and every one is captioned as an illustrative example.
The page covers screens only. It is not a roundup of AI design tools or UI generators, and it is not a template list. For the layer underneath, see the pattern layer behind these screens: expectations, input, trust and error handling. If you are choosing a partner to design screens like these, the reviewed UX design teams worth shortlisting for an AI product are a reasonable place to start.
The scale below places the eight screens from "AI suggests" on the left to "AI acts" on the right. Read it first, and the order of the examples will make sense.
How to read each screen
Every example is annotated the same way, so you can compare screens quickly. Each has three short notes, and the numbered callouts on the image match the points in the text.
- Role and question: who the user is and the one decision the screen asks them to make.
- What works: the choices on the screen that help the user make that decision.
- Note: the trade-off, plus what the public documentation of a real product says where it supports the point.
The real-product notes come from official documentation I read in November 2026. I have not used these products for this article, so I describe only what their own pages say.
Chat screens: read, check and apply
A chat screen hands the user an answer and asks them to judge it, so its job is to make that judgment easy. The two examples below differ in where the answer goes next.
Example 1: Chat answer with numbered sources and a sources panel
Role and question: the user is a reader who needs a fact they can rely on. The screen asks: is this answer backed by sources I can open?
What works: small numbered badges sit next to the claims they support (callout 1), a panel on the right lists each source with its title and domain (callout 2), and the source you opened is highlighted with the passage the answer relies on (callout 3). The answer and its evidence stay on one screen.
Note: this only works if the system can map a claim to a retrieved document. In the public help pages I read, Perplexity says each answer includes numbered citations linking to the original sources. The trade-off is clutter: a badge after every sentence makes a short answer hard to read.
Example 2: Chat with a work pane beside it
Role and question: the user is making something, not just asking. The screen asks: should this suggestion go into my document?
What works: the conversation stays in a narrow column (callout 1), and the document sits in its own pane where the user can type directly (callout 2). An "Apply to document" button sits under the suggestion, and a version control at the top of the pane shows the earlier state (callout 3). Long output never buries the conversation, and nobody copies text between tabs.
Note: two surfaces can drift apart, so the chat history and the document history need to agree on what changed. OpenAI's ChatGPT canvas post (October 3, 2024) describes a project that opens in a separate window, with direct editing and a back button for earlier versions. Anthropic's Claude artifacts help page says an artifact opens beside the conversation and can be edited and revisited.
Agent screens: approve, steer or take over
An agent screen shows work in progress and asks the user to stay in charge of it. Here is the one number I can give from my own reading: I read the public docs of six agent products in November 2026 (five of the six pages show no date). All six describe at least one way for the user to approve, steer or take over. Three of the six, ChatGPT agent, Devin and Manus, describe a live takeover of the agent's browser or IDE. The other three, Claude Code, GitHub Copilot cloud agent and Cursor, describe plan approval or a steering message, but no live takeover.
The three screens below are three ways to give that control: take over live, approve a plan, or steer a running log.
Example 3: Task view with live narration, pause, take over and a confirmation
Role and question: the user is a supervisor. The screen asks: should the agent go ahead with this step that cannot be undone?
What works: short narration says what the agent is doing right now (callout 1). Pause and Take over sit next to the preview, not in a menu (callout 2). Before the payment step, the agent stops and shows exactly what it is about to submit, with Confirm and Cancel (callout 3).
Note: handing control back and forth only feels smooth if the agent notices that the user is done. The ChatGPT agent post (July 17, 2025) describes on-screen narration, and says the user can interrupt, take control of the browser, pause or stop. It also says the agent asks permission before consequential actions such as a purchase.
Example 4: Plan shown for approval before any edit
Role and question: the user is a reviewer. The screen asks: is this sequence of steps correct and safe to run?
What works: the plan is a short numbered list in plain language (callout 1), the user can edit a step before approving (callout 2), and the buttons say what happens next, so "Approve and run" and "Keep planning" are different choices (callout 3). Nothing is changed until the user decides.
Note: the risk is approval fatigue: if every small action asks for a click, people stop reading. The Claude Code permission modes page, which I counted above, describes a plan mode where Claude researches and writes a plan without editing source, and, by default, edits stay blocked until you approve the plan. Cursor's plan mode page describes a reviewable plan you can edit before building.
Example 5: Session log with stop and steer
Role and question: the user is a manager watching several runs. The screen asks: does this run need to be redirected, or stopped?
What works: a session list shows which runs need attention (callout 1), the log shows each step with the tool it used (callout 2), and a prompt box and a Stop button live under the log (callout 3). The user can correct the course without killing the work.
Note: a steering message usually applies after the current step finishes, so the screen should say that. The docs for the GitHub Copilot cloud agent describe an agents panel, session logs, a prompt box for follow-up steering and a Stop session button that ends the run and keeps the commits already pushed.
Copilot and inline screens: accept, discard or try again
A copilot screen puts the AI inside the user's own work and asks for a small decision, many times a day. The key is that declining costs almost nothing.
Example 6: Inline ghost text with accept and dismiss
Role and question: the user is typing and does not want to stop. The screen asks: is this what I was about to write?
What works: the suggestion appears dimmed right at the cursor (callout 1), a small hint states the two keys (callout 2), and the cursor stays on the user's own line, so any other keystroke simply replaces the suggestion (callout 3). There is no dialog and no mouse movement.
Note: speed is the whole feature, because a suggestion that arrives late is noise. The VS Code documentation for AI-powered suggestions (page metadata shows November 18, 2026) describes ghost text as dimmed text at the cursor, accepted with Tab and dismissed with Escape, plus a hover toolbar to compare alternatives.
Example 7: Select and rewrite, with accept, discard or try again
Role and question: the user is an editor with a paragraph they want better. The screen asks: is the new version better than my original?
What works: the action is scoped to the selection (callout 1), the original and the rewrite sit one above the other (callout 2), and three buttons cover every outcome: accept, discard, try again (callout 3).
Note: a rewrite that silently replaces the original is the failure here, so always show both. Notion's guide describes highlighting text, choosing Edit with AI, and then accepting, discarding or asking for another try. The Microsoft Word page on rewriting with Copilot lists Replace, Insert below and Regenerate as the choices after a rewrite.
Example 8: Side panel suggestions with accept all and reject all
Role and question: the user is a final reviewer with several proposed changes. The screen asks: which of these do I want to keep?
What works: each suggestion is tied to a highlighted passage in the document (callout 1), each can be accepted on its own (callout 2), and Accept all and Reject all sit at the top of the panel for the user who wants a clean start or a fast finish (callout 3).
Note: batching keeps the page readable, but the panel must always show where each change lands. The Google Docs help page for Gemini describes suggestions shown directly in the document with controls to accept a suggestion, accept all or reject all. If your product is a SaaS app, the surrounding layout matters as much as the panel, and annotated SaaS product screens show how other screens in the same product can hold such a panel.
How the eight screens compare
The table sorts the eight screens by who holds control and what the way back looks like, which is the question to ask first when you design your own.
| Screen | Group | Who holds control | Way back |
|---|---|---|---|
| 1. Chat answer with sources | Chat | The user reads and verifies | Open a source, or ignore the answer |
| 2. Chat with work pane | Chat | The user applies each edit | Version control in the pane |
| 3. Task view with takeover | Agent | The agent acts, the user supervises | Pause, take over, or cancel at the confirmation |
| 4. Plan for approval | Agent | The user gates execution | Edit the plan or keep planning |
| 5. Session log with steer | Agent | The agent acts, the user steers | Steer with a message, or stop the session |
| 6. Inline ghost text | Copilot | The AI predicts, the user accepts | Keep typing or press Esc |
| 7. Select and rewrite | Copilot | The user starts a local edit | Discard or try again |
| 8. Side panel suggestions | Copilot | The user reviews a batch | Reject one or reject all |
Mistakes that show up in these screens
Most failures come from skipping the way back or putting the AI in the wrong place. Each of these six maps to one of the screens above.
- A chat panel where an inline action fits (examples 2 and 7): opening a chat to fix one sentence breaks the user's focus. Local edits belong in a local menu.
- An agent log with no stop control (example 5): agents go off track, and a user who cannot stop a run will close the window instead.
- Approval prompts for everything (example 4): when every step asks for a click, people click through without reading, and the one prompt that mattered is lost.
- Rewrites with no visible original (example 7): if the new text replaces the old with no diff, the user can lose a good sentence without noticing.
- Sources that look clickable but are not (example 1): a citation badge that leads nowhere does more damage than no badge. On a phone there is also no room for a side panel, so how mobile screens handle the same questions is worth a look.
- No signal that the user is done after a takeover (example 3): if the agent cannot tell that control is back, the task stalls and the user has no idea why.
When an AI product needs outside UX help
Bring in outside help when the model already works and the open questions are about control, not capability. A typical engagement starts with an audit of where the product asks for permission, runs quietly or shows an error. Next comes wireframing the state changes: the plan, the pause, the stop and the way back. Last comes testing those states with real users before engineering builds them. Keep an internal owner for the model and the data, and use outside help for the interaction design around them.
Frequently Asked Questions
What are good examples of AI agents?
In interface terms, good agent examples show their work and keep the user in charge. The agent screens above show three ways to do it: a task view with narration and takeover (example 3), a plan the user approves (example 4) and a session log with stop and steer (example 5). The six agent products whose docs I read all describe at least one such control.
What is the difference between a chat UI and an agent UI?
A chat UI waits for a message, answers and stops, so the user's job is to read and check. An agent UI works across several steps on its own, so the user's job is to watch, approve and step in. That is why agent screens need a progress view and a stop or takeover control that chat screens can do without.
Where should an AI assistant live in a product: chat, side panel or inline?
Put it where the user's attention already is. Short edits and predictions belong inline (examples 6 and 7), a batch of suggestions belongs in a side panel (example 8), and open-ended questions or longer work belong in a chat with a work pane (examples 1 and 2). Moving a small action into a chat panel is the most common misplacement.
How do you design for AI mistakes on screen?
Assume the AI will be wrong and give the user a cheap way back at every level: ignore or open a source for an answer, discard or try again for a rewrite, reject all for a batch, and stop or take over for an agent. Place the control next to the output, not in a menu.
Conclusion
The eight screens answer one question in different ways: how much should the user hold, and how easily can they get it back? Pick the group by the job, chat for judging, copilot for small edits and agent for work that runs without you, and then write the one decision each screen asks the user to make. Your next step is to take the screens in your own product, place them on the control scale, and mark the ones that have no way back.