Agent Experiences

One front door

Where people meet your AI agent, how it hands work to other agents, and why picking the right agent for a request is the system’s job, not the user’s.

Our position

People should meet one AI agent (an AI assistant that carries out tasks for someone, such as booking or filling in a form, as well as answering questions), with one memory, wherever they reach it from. That agent takes any request and decides for itself whether to answer, pass the request to a specialist agent, or get several specialists working on it together. Several ways in (entry points) are fine, because they help people find the agent. What causes trouble is several separate agents: a chat widget on every page, an assistant for every feature, each with its own history. That leaves people to guess which one to ask, which they have no way of getting right, and it splits up the context that would have made the next answer good.

This runs against how most teams build. AI agents tend to arrive one team at a time: the support group ships a support bot, the commerce group ships a shopping assistant, and the docs group ships a docs search. Each one makes sense on its own. Together they make a product where people have to understand your org chart to get help.

Your users don’t know which of your agents owns their problem. Often the problem spans two of them, and that’s exactly the case no single widget can handle.

What goes wrong with many entry points

People are left to pick the right agent

Choosing the right agent means knowing what each one can do. The product knows that, and the user doesn’t. Guess wrong and you’re told to go somewhere else, which is the online version of being transferred between departments.

What you said doesn’t follow you

Five chat windows mean five separate conversation histories. Whatever you explained to the billing widget isn’t available to the support widget, so you explain it all again. Worse, each agent holds only part of the picture and answers confidently from it.

Nobody can tell what the AI can do

When the agents differ from page to page, people can’t build a steady sense of what “the AI here” can do. It answered a question on the pricing page but not on the account page. That inconsistency comes across as unreliability, and people stop trying.

There is nowhere to check what happened

Agents that take actions need a place where people can see what was done for them. Spread the agents around and you spread that record around too, or lose it. For anything with real consequences, that alone rules the setup out.

The big AI companies have already tried this

In 2025, some AI companies launched their agents as separate destinations of their own. OpenAI’s Atlas browser is the clearest case of one being folded back into a product people already used.

OpenAI launched its Atlas browser in October 2025 and switched it off in August 2026, less than ten months later, TechCrunch reported. What Atlas could do moved into ChatGPT itself: the desktop app, a Chrome extension, and Codex, OpenAI’s coding agent.OpenAI had announced that merger in March 2026, a few months before Atlas closed. People now have one place to go, with the specialist tools behind it.

Google closed Project Mariner, its experimental browsing agent, in May 2026, and moved what it could do into Gemini Agent and Chrome without the separate brand.

Others went another way and put the AI inside a browser people already use.Microsoft retired the separate Copilot Mode in its Edge browser in May 2026 and moved the features into ordinary Edge. Anthropic built Claude into Chrome as an add-on called Claude in Chrome, rather than shipping a browser of its own.In August 2026 that add-on became a full Claude Cowork session, tied to your account rather than to one device, so work started in a browser tab can be finished in the desktop app.

Be careful how much weight you put on this. None of these companies called the change a design principle about having a single entry point. That reading is an argument, and it’s ours. What the events do show is narrower, and still useful: a separately branded AI destination has more than once turned out to be a temporary stage.

Who hands out the work behind the door

One front door doesn’t mean only one agent. Behind it sits an orchestrator (a coordinating agent that reads each request and decides which agent or tool should handle it). In the setup we recommend below, it works like a good front desk: you explain your problem once, the desk gets the right colleagues on it, and the answer comes back from the desk. Specialist agents still exist. People just no longer have to go looking for them.

Anthropic, OpenAI, AWS, and Microsoft all document this setup in their agent-building tools, each under its own name.Microsoft’s Agent Framework alone names five ways to arrange it. There’s now a shared standard for it, too: Agent-to-Agent (A2A), an agreed way for agents from different companies to find each other and hand work to one another. A2A reached a stable version 1.0 in March 2026.

Underneath the different names, the toolkits split on one question. Does the orchestrator stay in the conversation and pull together what the specialists send back, or does it hand the conversation over? OpenAI draws the line clearly. Use agents as tools when a specialist should help with a bounded piece of work but not take over the conversation with the user. Use handoffs when the specialist should take over and reply to the user directly. For a single front door, the first option is usually what you want. Once specialists start taking over the conversation, people can end up passed from one agent to the next.

How it’s built isn’t what people should see

Splitting work between agents is a decision about how you build the product. People should experience one agent that’s good at many things, not a switchboard announcing transfers. If your interface says “handing you to the Billing Agent”, you’ve turned the inner workings of your system into something users have to deal with.

What the front door owes the user

Show progress, not the machinery

Work passed to other agents takes longer than a quick reply. Show that something is happening, and roughly what. “Checking your invoices” beats both a silent spinner and a running commentary on which subagent (a specialist the main agent has called in) is working.

One conversation, one memory

Anything the user said earlier is still there later, whichever specialist handled it. That’s the main thing people get in return for a single front door, and the first thing a badly built orchestrator loses when it passes work along.

The door owns the failure

When a specialist fails, the user has no relationship with that specialist. Their relationship is with your company. So the front door reports the failure in its own voice, says what it couldn’t do, and offers a next step. “The billing agent returned an error” tells the customer nothing they can act on.

The same permission, asked the same way

A consequential action needs the same confirmation whichever specialist carries it out. If each agent has its own rules for asking permission, the same risk gets confirmed some of the time and not the rest, and people soon learn to click through whatever appears.

One record of what was done

A single place that lists the actions taken for the user, in their language, and reversible wherever that’s possible. See interaction models for how much of this people need to see before an action rather than after.

You may need only one agent behind the door

Two claims often get lumped together here. It helps to pull them apart, because the evidence treats them very differently.

The interface claim is that people should get one consistent place to go, with the system working out who handles what. That’s a design position, and the product history above supports it. The architecture claim is that you should therefore build a fleet of specialist agents behind it. That doesn’t follow, and the people who build these systems are much less keen on it than the marketing suggests.

Anthropic’s guidance has said since 2024 to find the simplest solution possible and only increase complexity when needed. OpenAI’s practical guide to building agents recommends getting the most out of a single agent first, noting that one agent with tools is often enough. LangChain, which makes popular tools for building agents, says plainly in its documentation on multi-agent systems that not every complex task needs several agents. And this advice comes from the very vendors whose products would gain from saying the opposite, not from skeptics.

What extra agents cost

Anthropic measured agents using roughly four times the tokens (the small chunks of text AI models read and are billed by) of a chat conversation, and multi-agent systems around fifteen times. Every handoff also adds latency (a delay before the answer arrives), and each specialist starts without the context the orchestrator has built up unless you deliberately pass it along.

That cost buys something real when the work can be split up and done in parallel, or when it’s more than one agent can hold in view at once. In Anthropic’s write-up, a subagent can work through tens of thousands of tokens and send back a summary of one to two thousand. The benefit comes from boiling material down, not from extra intelligence. If your task doesn’t need boiling down, you’re paying about fifteen times the tokens and getting nothing for them.

Many agents can help, but one makes the changes

In June 2025, Cognition, the company behind the coding agent Devin, argued against multi-agent systems outright, on the grounds that splitting decisions across agents produces work that conflicts. Their example was two subagents building a game that produced a bird and a background in clashing visual styles, because neither could see what the other was doing. In April 2026 they revised that position into something more useful: several agents can contribute ideas to a task, but writes stay single-threaded. Many readers, one writer: lots of agents can look and suggest, but only one of them makes changes.

Anthropic ran into the same rule in early 2026, when it ran a large experiment with many agents working side by side. What kept them in step was plain file locking (only one agent can edit a file at a time), with no coordinating AI at all. When two agents went after the same problem, they wrote over each other’s changes.

A controlled comparison published in 2026 tested six multi-agent systems against a single agent with the same setup. At most one of the six beat the single agent on average accuracy. A workflow that decided how to split the work while it ran, based on the actual request, beat every fixed arrangement by more than 20 percentage points. Splitting work between agents can pay off, then, as long as the split is decided on the request in front of it rather than drawn up in advance. That’s one more reason the orchestrator should read each request instead of following an org chart.

What we would do

Build the single front door. That part is settled enough to act on. Behind it, start with one capable agent and a good set of tools, and split into specialists only when you hit a reason to: tools so similar that the model mixes them up, work that can run in parallel, or more context than one agent can hold.

Anthropic said in late 2025 that it was still unclear whether one general-purpose agent or a team of agents works better across different situations, and nobody has settled it since. What we can say is that the interface question has far more evidence behind it than the architecture question.

Where the argument breaks down

Pushed too far, the case for a single entry point turns into a case against help in context, and that would be wrong. An agent that acts on the thing you’re looking at has real advantages. It already knows what you’ve selected, which record you’re on, and what state it’s in. Making someone open a panel and describe what’s already on their screen is worse, not better.

Sending everything through one general agent has a cost, too. The extra step adds latency, and meaning can get lost between the orchestrator and the specialist that knows the subject.

The way out is to see that a shortcut that acts on what you’re looking at is a different thing from a separate conversation. A “summarize this” button on a document is fine, and it should be there. What it shouldn’t do is open a second chat with its own history. It should feed into the same conversation and bring its context along, so there’s still one thread and one record.

Patterns to avoid

  • An agent picker. If people have to choose the agent, the job of matching a request to the right agent landed on the wrong side.
  • Chat widgets on different pages of the same product, each keeping its own history.
  • Describing internal handoffs to the user as though the subagents were people they ought to know about.
  • A specialist that answers in a different voice, or with different permission rules, from the place that called it in.
  • Shortcut buttons that start new conversations instead of adding to the existing one.
  • An orchestrator that quietly drops what the user said three turns ago because the specialist never received it.

Questions to ask about your own product

  • How many separate places can people reach an agent today, and do they share a history?
  • If someone asks a question in the wrong place, what happens? Are they sent elsewhere, or answered?
  • Does a request that spans two of your teams’ areas work, or does it fall through the gap?
  • Is there one place people can go to see everything done on their behalf?
  • Do your in-context shortcuts add to the main conversation, or start their own?
  • Does a consequential action get confirmed the same way, whichever specialist carries it out?

What the research supports

One study tests the handoff advice above fairly directly. A paper at CHI 2026 (the main academic conference on how people use computers) looked at how people read interfaces with several agents. It kept the answer the same and changed only how much of the process was shown, from a bare final answer all the way to a full debate between agents. Two findings matter here.

The first is a Goldilocks effect. Participants wanted to see enough of the process to know the system was thinking it through, and showing more than that reduced trust on simple tasks. Most wanted a simple answer first, with the option to expand it. The second finding is sharper. Whether the agents ran one after another or at the same time, and how information passed between them, stayed perceptually latent and did not affect trust judgments at all. In plain terms, people didn’t notice it, and it made no difference to how far they trusted the answer. The authors also advise showing the distinct lines of reasoning rather than a count of agents, because people use the number of agents as a trust heuristic (a rule of thumb for deciding how far to trust something), and it’s a bad one.

In the study, people didn’t notice how the agents were wired together, so a diagram of it is unlikely to help. Report the work, and offer the detail when asked. A February 2026 study by Grunde-McLaughlin and colleagues, on overseeing agents by reading the record of their steps, found that designs which made reviewers feel more confident did little for their accuracy. Keep that in mind before you build an elaborate viewer for those records.

The best argument against this page

Atlassian’s design system (the shared rules and components it builds its products from) openly takes the opposite position, and it’s the only major design system we found with a published stance on any of this. Its first principle is integrated, not segregated: the agent lives where work already happens, built in alongside everything else rather than set apart, with its controls in the place you work so you don’t have to switch context. If you’re looking for the strongest published counter-argument, that’s it.

Nielsen Norman Group, a long-established usability research firm, has published both sides within two months. Its April 2026 guidance says to bring AI chat together in one place and avoid bots that compete with each other, because users shouldn’t need to understand how your system is built to find help. Its May 2026 guidance, based on watching people fail to find an agent at all, recommends the opposite: multiple entry points, because most users stuck with the interface they knew and never tried the agent. Nielsen Norman Group hasn’t said how the two fit together.

Our way of reconciling them (and this is our argument, not their finding) is that they answer different questions. People need many ways in so they can find the agent, and one agent behind them so it remembers what they said. Those only conflict if you assume each door leads to a separate agent, and it doesn’t have to. Keep one agent and one running conversation, however many ways in there are. Put a way in wherever the work is, and have every one of them open into the same ongoing conversation, with the same memory.

What nobody has measured

We found no controlled comparison of help built into the page against a central agent. Anyone who tells you inline help has been proven better than chat is overstating it, and so is anyone claiming the reverse. The measured work in this area tests how agents’ step-by-step records are designed, not where the agent sits. Beyond the two studies above, we found nothing from Nielsen Norman Group, Google’s People + AI Guidebook, or Microsoft’s HAX Toolkit (its guidance for designing AI features) on telling users that a request was passed to a subagent. There’s plenty written on how to build these systems and almost nothing on how they should look to the people using them. So most of the “what the front door owes the user” section above is reasoned rather than researched.

References

Related

  • Interaction models: how much oversight a given action needs
  • Design patterns: setting expectations, recovering from errors, and handing the agent more work a step at a time
  • Implementation: MCP (a standard way to connect agents to tools and data), A2A, and the other technical plumbing that lets agents pass work to each other

Last reviewed . The case for one front door is a design position backed by what happened to real products, not by a controlled study. Both the architecture question and the question of where the agent should sit are still open. Treat the advice on keeping one conversation and one memory as the part that will last, the advice on one front door as a strong starting assumption, and the advice on splitting work between agents as a starting point to test against your own workload.

See the path on your own site

The Agent Visualizer follows an AI agent through one of your pages and shows where it arrives, where it reads, where it gets stuck, and everything past that point it never reaches.

Further reading from Field Notes

Posts with more on this topic, each with its date.

All Field Notes

Stay Updated

A monthly email about AI search, AI crawler policy (the rules for the AI bots that visit websites), and new standards for agents. It includes every Field Note published that month, and you can unsubscribe at any time.

We store your email address only to send you this newsletter. See our privacy policy.