Agent Experiences

Your Agent's Architecture Is a UX Decision

By Alan WeibelPublished 6 min read

When engineers build an AI agent (an AI assistant that carries out tasks for someone, such as booking, buying, or filling in a form), they decide how it works inside, mostly to get good answers at a sensible cost. Should one lead agent split the job up and hand the pieces to specialists? Should a second agent check the first one's work? Should the agent keep going round until the tests pass? Those are fair engineering questions, but every answer also shapes the user experience (UX, meaning how it feels to use): how long your users wait, what they can see while they wait, and when they get asked to make a decision.

Maryam Miradi's list of 15 agent design patterns, shared on LinkedIn in November, is a good map of those choices. Like most pattern lists, it describes the machinery, meaning which agent calls which and in what order, and it stops before it gets to whoever is sitting at the screen. This post takes five of the fifteen and looks at them from that side: what someone using the agent sees, where it goes wrong for them, and what you can design to help.

The short version

Every agent architecture comes with a user experience, whether anyone designs it or not. Splitting work across several agents costs much more, and your users sit through long silences while the helpers work. When an agent checks and redoes its own work, your users need to know when it will stop. When it retries a failed step, it can charge or book something twice. Approval prompts that pop up too often teach people to click yes without reading. Our interaction patterns cover all fifteen patterns, with what to design for each.

1. One lead agent handing out the work

Orchestrator-Subagent is the name for a setup where one lead agent breaks a goal into parts and gives each part to a specialist helper, called a subagent. Engineers call the lead agent the orchestrator (the one that coordinates the others). From the user's side it looks like one conversation with long silences, while the work spreads out behind the scenes.

Splitting the work up can give much better answers, and it costs a lot more. Anthropic reported in June 2025 that its multi-agent research system outperformed a single agent by 90.2% on its internal research evaluation. The same report found that agents use about four times the tokens of a normal chat (tokens are the small chunks of text a model reads and writes, and they are what you pay for), and multi-agent systems use about 15 times as many. Early versions of Anthropic's system started 50 subagents to answer simple questions.

So describe what is being looked into, in words that mean something to your users. "Checking your March invoices" tells them something useful, while "Handing off to the Billing Agent" only tells them how you built the system. Give them one control that stops all of it, and when a job is going to be expensive, say so before it starts.

2. When the plan changes after you approve it

In the Plan-and-Execute pattern, the agent writes out the whole plan first, then works through it step by step. Many coding tools offer this now. Cursor and Claude Code (two AI coding tools) both have a plan mode that writes the plan and changes nothing until you approve it, and Cursor lets you edit the plan first. Google's coding agent Jules works the same way.

If the agent rewrites its plan halfway through without asking, someone who agreed to five steps can end up with seven.

Have the agent ask again when a change adds cost, sends something to someone new, or adds a step that can't be undone. If a change only shuffles the order of the work, a short note where they'll see it is enough.

3. Loops that check their own work

One agent produces some work, a second agent (the evaluator) scores it, and the first keeps revising until the score clears a bar. That's the Evaluator-Optimizer pattern, and if the score never clears the bar, nothing in the loop makes it stop. Google's Agent Development Kit (Google's toolkit for building agents) says in its documentation that its loop agent doesn't decide when to stop: the developer has to set a maximum number of passes or a signal that ends the loop. If neither is set, the wait never ends.

Say what the bar is, such as "until every test passes" or "under 150 words". Show which round the agent is on, and what happens when it hits the limit. Better still, let people change the bar themselves, since they often know what good enough looks like before the evaluator does.

4. Retrying a failed step without paying twice

The Self-Healing / Retry pattern is how an agent copes with failure: when a step fails, it works out why and tries again, often in a different way. A retry that works goes unnoticed, as it should. One that goes wrong may only show up later, as a double charge.

Trying again is harmless when the agent was only looking something up, but it gets risky once the step changed something. Say the agent's first attempt to send an email, book a table, or charge a card went through, and only the confirmation got lost. A retry does it a second time, and now your customer has two emails, two bookings, or two charges.

Payment APIs (the connections other software uses to talk to a payment service) already handle this case. Stripe, the payment company, supports idempotency (making a repeated request take effect only once). You attach a unique key to each request, and if the same request arrives twice, Stripe carries it out once. An agent acting inside your product needs the same protection, whether it comes from your product or from the agent itself.

Before retrying anything that sends, books, or charges, check whether the first attempt landed. When the agent switches to a different method, say so: "The export timed out, so I downloaded the report as a spreadsheet instead." And after a set number of tries, stop and show them what was tried.

5. Asking for approval too often

A human-in-the-loop agent stops at set points so a person can approve, correct, or redirect it. Most patterns on the list need a human check somewhere, and this one sounds like the safe default. The Model Context Protocol, an open standard for connecting AI agents to outside tools, says a person should always be able to deny a tool call. A tool is anything the agent can do outside the chat, such as sending an email.

If you ask about every step, though, people learn to approve without reading. That's worse than asking about nothing, because it still looks safe.

Place checkpoints by what's at stake rather than by step: ask before anything that can't be undone, anything that spends money, and anything that goes out to other people. Make each request make sense on its own, so it says what will happen, why, and what happens if they say no. And let the pause survive a closed browser tab. LangGraph, a framework for building agents, does this with its interrupt feature, which waits indefinitely, picks up where it left off, even days later, and lets someone edit the action before it runs.

What the usual lists leave out

Three more patterns are built into the major agent frameworks (the toolkits developers build agents with), and each one changes what users see.

  • Routing sends each request to the right specialist. Customers need an easy way to say "that's not what I meant" without starting over.
  • Handoff passes the conversation to another agent. In the OpenAI Agents SDK (OpenAI's toolkit for building agents), the next agent sees the whole previous conversation unless a filter trims it. So decide what carries over: nobody should have to repeat themselves, and the next agent shouldn't see what it doesn't need.
  • Guardrails stop an agent when one of its checks fails. The user should get a plain reason and a next step, not a generic error.

Start with the simplest pattern

Anthropic's advice in "Building effective agents" is to find the simplest solution possible, and add complexity only when it's needed. It points out that systems built from agents often trade latency (how long a response takes) and cost for better task performance. Whoever uses the agent sits through that wait, so before you add a second agent or another loop, picture what waiting for it will feel like.

Five questions to ask about your agent

  • Can your users tell what your agent is doing, in their own terms, and stop it?
  • If the plan changes after they approve it, do they find out?
  • Does every loop show its bar, which round it's on, and what happens at the limit?
  • Could a retry ever send, book, or charge twice?
  • Are your approval prompts rare enough that they still get read?

All fifteen patterns, and what to design for each

This post covers five. Our interaction patterns cover all fifteen, from ReAct (one agent that works out a step, takes it, and checks the result) to Debate (several agents argue opposite sides and a judge settles the answer). For each one we describe what a user sees, what to design for, and where it lets them down, with a source. Each one also links to the ten habits that make any agent easier to work with, such as intent preview (showing what the agent is about to do before it does it) and graceful escalation (handing over to a person cleanly when the agent gets stuck).

Read the full set of interaction patterns.

References

See the path on your own site

Patterns describe how an agent works inside. The Agent Visualizer shows what an agent meets on your own pages: where it arrives, what it reads, and where it stops.