AI Agent UX: When Your Agent Should Ask, Act, or Undo

Every AI startup we talk to wants an agent that "just does it." Very few have designed what happens in the second before it does.

That second is the product. It decides whether a user hands your agent more work next week or quietly turns it off. Model quality matters, but users do not experience model quality directly. They experience the approval screen, the activity log, and the undo button. If those are missing or vague, a smart agent feels reckless.

The question founders are really asking

Look at what ranks for this topic and you see the same anxiety in different words: how to design AI approvals, how to implement human-in-the-loop approval, how to build agent interfaces with control and consent. Nobody searches "how to make my agent more autonomous." They search for how to make it safe enough to use.

Reddit says it more bluntly. In r/SaaS, a solo founder described letting an agent handle support tickets, then watching it issue refunds he never approved on the first day. His new rule was simple: if money moves, a human clicks the button. In another r/SaaS thread, a founder asked where the line should sit between acting alone and asking first, and whether a validation step reads as safety or friction. The answers clustered around money, permissions, and deletion.

That is not a model problem. It is a design problem nobody scoped.

Gate by consequence, not by confidence

Here is our strongest opinion on this: never let model confidence decide whether an action needs approval.

A model can be very confident and very wrong. High confidence on an irreversible action is still irreversible. So the gate should depend on what the action does in the world, and confidence should only show up in how you present the result.

We sort every agent action into three tiers:

1. Just do it. Reads, lookups, drafts, summaries, internal tagging. Reversible and invisible to anyone outside the product. Log it and move on.
2. Do it, then tell me. Impactful but recoverable. Updating a record, moving a file, changing a status. The agent acts, shows a notice, and offers a real undo right there.
3. Ask me first. Anything that moves money, changes access, deletes data, or sends something to a customer or the public. The agent stops and waits.

One rule keeps this honest. If you cannot build a working undo for a tier two action, it belongs in tier three. A "do it, then tell me" notice without undo is just an unrecoverable action wearing a friendly toast.

Design the approval packet, not the approve button

Most approval UIs we review are a sentence and two buttons. "Agent wants to issue a refund. Approve / Deny." That is not oversight. That is a rubber stamp with extra clicks.

A good approval screen is a small brief the human can judge in seconds:

• The exact action. Who, what, how much, where. Not a paraphrase.
• Why the agent chose it. The reason in plain language, with the source records one click away.
• What it is unsure about. Missing fields, conflicting data, or context it had to guess. This is where confidence belongs.
• What happens if we do nothing. Sometimes waiting is the right call, and the screen should make that visible.
• Three real choices. Approve, edit, or reject. Editing matters most, because it turns a no into a better yes and tells you what the agent got wrong.

One of the sharpest Reddit replies made a point we agree with: the most dangerous run is the one where the agent confidently filled in gaps. If the agent had to guess, it should pause, even on a low risk task. Your UI should say "I assumed X" out loud instead of hiding it in a log.

Reject list: agent UX we would not ship

Before you add another agent feature, strip these out:

• A single "autonomy on" toggle for everything
• Approval prompts that hide the actual payload behind a summary
• Confidence scores with no meaning attached (sure of what, exactly?)
• Activity logs that only engineers can read
• Undo that silently fails, or expires without telling anyone
• Agents that retry a failed action in a loop instead of stopping to ask
• Chat as the only way to see what the agent did

Chat is a fine way to give instructions. It is a poor audit trail. When an agent changes real records, the user needs a structured view of what changed, in the same table or screen where that data normally lives.

Earn autonomy in public

Trust in an agent should grow the way trust in a new hire grows: through visible track record, one category of work at a time.

Start supervised. Let users approve everything in a category, then offer to auto-approve that category once they have reviewed enough runs to feel comfortable. Make that promotion the user's choice, with a clear way to step back down. And guard against approval fatigue. If you ask for sign-off on trivial actions, people start clicking yes without reading, which defeats the gate on the actions that matter.

Why this is harder in regulated products

In fintech, insurance, health, and marketplaces, a bad agent action is not just embarrassing. It can be a compliance event, a frozen account, or money that is hard to claw back. Those products need the approval layer to double as a record: who approved what, when, with which evidence on screen.

This is the work we focus on at UX Signal Studio, a boutique UX studio serving founders in San Francisco, the wider Bay Area, and remote teams. Our operating belief is HI+AI. AI does the grunt work, humans keep the judgment. AI helps us map every action an agent can take and draft approval copy fast. Senior designers decide which actions are allowed to happen without asking, what the human must see before saying yes, and where the product has to stop and escalate.

And we build it. An approval flow is only real when you can click through it with live data, edge cases, and a working undo. A Figma screen of a happy path approval tells you almost nothing about trust. A working front-end slice tells you everything.

A one-afternoon agent trust audit

List every action your agent can take. For each one, write down:

• Which tier it belongs in, based on consequence
• What the user sees before and after it happens
• Whether undo works, and for how long
• What the agent does when context is missing

Anything without a clear answer is a design task, not a prompt-engineering task.

Soft next step

If your agent demos well but users will not let it touch real work, Book a discovery call. Or email us at ash@uxsignalstudio.com with the three agent actions that make you most nervous. We will tell you which ones should ask, which should act, and what the approval screen needs to show.

We make complex products feel obvious.