Skip to content
be-human.ai
← Back to the journal

Business workflows

When to Add More AI Agents: Signals That One Agent Should Split

Signals that show when one company AI agent should split into several scoped agents, with a decision guide, a step-by-step check and clear approval limits.

Be Human typographic cover with the title: When to Add More AI Agents: Signals That One Agent Should Split
Conceptual illustration created with AI · Be Human

Add a second agent when one agent's work splits into parts that need different memory, different tools, or different approvers, and when a single set of instructions can no longer explain every decision it makes. Volume alone is a weak signal. A busy agent with one clear role is usually fine, while a quiet agent that touches payments, customer records and personnel data should be scoped more tightly than its workload suggests. The practical test is whether each part of the work has one owner, one success criterion and one stop point that a person can reach.

Key takeaways

  • Split an agent when its work needs different owners, permissions or success criteria, not when its task list simply gets long.
  • Start with one scoped role and add a second agent only after a repeated signal shows where the boundary belongs.
  • Give each scope its own memory, tools, approvers and evaluations.
  • Pass context between agents through a defined handoff rather than a shared memory of everything.
  • Test each new scope in shadow mode before it can write to any system.

Why one scoped agent is the right starting point

A company should rarely begin with several agents. The sensible first step is one agent with one clearly defined role, the memory and tools that role needs, approval boundaries that name who decides what, and an observable success criterion, such as how many intake records reach the right queue without correction. This is the same shape Be Human uses to define a first engagement, because a single well-bounded role gives you something concrete to observe and judge.

Anthropic's engineering guidance on building agents makes a similar point from the builder's side: begin with the simplest pattern that works, and add complexity only when it clearly improves the result. For a business owner, that becomes a working rule. Every additional agent adds a handoff, another permission set and another thing to review, so each split has to earn its place.

What signals show that one agent is carrying too much?

These signals usually appear in review meetings and operations logs long before anyone writes a design document. Watch for any of the following:

  • Its tool list includes both read-only reporting and write access to money, customer commitments or personnel records, and those writes need different approvers.
  • Its success criterion has two parts that pull against each other, such as reply speed and the accuracy of account changes.
  • Its memory holds records from unrelated areas, so a correction in one area changes its answers in another.
  • Reviewers cannot tell which part of the work a decision came from, because intake, judgment and follow-up all happen inside one undivided run.
  • Failures take a long time to diagnose because nobody can point to the step where the output went wrong.
  • Its instructions keep growing to cover exceptions from different teams, and those instructions begin to contradict each other.

None of these signals proves much on its own. Two or three of them appearing in the same workflow over several review cycles are a much stronger sign that the scope is too wide.

Where the split line belongs: a decision guide

Once a signal repeats, use a short decision guide to find the boundary. The line belongs where the owner, the permission or the failure cost changes, not where the task list happens to be long.

  • If two tasks use the same data, the same approver and the same failure cost, keep them in one agent.
  • If the tasks share data but the approver changes at a later step, keep the agent together and split the approval queue instead. The approach described in our guide on routing each request to the right approver shows how to make that step explicit.
  • If one task writes to a system of record and another only reads from it, give the reading task a separate, read-only scope.
  • If a mistake in one task would cost far more than a mistake in another, separate them so the higher-cost task has tighter stop points.
  • If one agent reads untrusted text such as inbound email or supplier documents while also holding write access, separate the reading step from the writing step.

The last rule matters more as agents read more outside content. The OWASP guidance on prompt injection prevention describes how instructions hidden in documents or messages can try to steer an agent. Keeping untrusted input in a scope that cannot write to downstream systems limits what a successful attempt can do.

A step-by-step check before you add an agent

Run this sequence with the people who actually perform the workflow. It takes less time than a design debate and produces a scope that a reviewer can read.

  • Write the current work as a list of decisions rather than a list of tasks. Each decision gets one named owner.
  • Mark the decisions that change money, customer commitments or personnel records.
  • Group decisions that share the same data, the same approver and a similar failure cost.
  • For each group, name the memory it needs and remove anything it does not use.
  • List the tools each group needs, and remove any tool that the group's success test never touches.
  • Define the handoff: what the first group passes on, in which format, and who receives exceptions.
  • Run the proposed scope in shadow mode for a while, comparing its proposals with what people decided.
  • Split only when the comparison shows a repeatable gap that a change in scope would close.

If the workflow has not been mapped at this level of detail, start with the process itself. Our article on mapping the work before an agent is built covers the decision list in more depth, and the approach to watching an agent before it gets autonomy explains how to run the comparison safely.

Illustrative scenario: a purchasing workflow that outgrew one agent

The following scenario is illustrative and does not describe a real client. A small operations team gives one agent the whole purchasing path. It reads supplier requests, compares prices, drafts purchase orders and can release payments. The first problem appears when a supplier email asks for a change of bank details, and the drafting step picks up that request together with old supplier notes still held in memory.

Reviewing the signals, the team sees three separate owners. Procurement decides what to buy, finance decides what to pay, and supplier master data needs its own check. They split the work into three scopes. The intake agent reads supplier documents and price lists with read-only access and writes a structured request. The drafting agent proposes purchase orders into an approval queue and has no payment tool. Payment release and bank detail changes stay with finance, and the agent that reads supplier email has no write access to supplier records.

Nothing about the underlying work became harder. What changed is that each scope can now be tested on its own, and a reviewer can see which decision came from which step. Whether the split improves results is a question the team answers with its own evaluations, not with an assumed benefit.

How Be Human handles the split

Be Human treats each agent as a scoped role with its own identity, memory, channels, tools, permissions and operating context, all kept under human control. In a first engagement we define the role, the memory and tools it needs, the approval boundaries and one observable success criterion. When a split is proposed, the new scope receives the same definition before it touches any system. Its access is granted only for the actions that scope needs, following the least-privilege principle described in the OWASP authorization guidance. Managed operations then add monitoring, recurring evaluations, permission reviews and controlled changes, so a split becomes a managed change with a record rather than an informal edit to one shared prompt. The NIST AI Risk Management Framework offers a useful vocabulary for identifying these risks and assigning an owner to each.

Keeping the split healthy after launch

A split can drift over time. Two scopes that were separate at launch can slowly start sharing memory or tools when someone adds a convenient connection. Review each agent's tool list and memory sources on a regular schedule, and check that every handoff still carries the fields the next scope depends on.

Run evaluations per scope. An evaluation of the whole chain hides which handoff failed. Keep a short record of each correction a reviewer makes, and when the same correction repeats, decide whether it reflects a process gap, a prompt gap or a scope gap. Our guide on turning corrections into process changes explains how to keep that record useful. If you are unsure which workflow should be split first, or whether it should be split at all, the free Be Human AI diagnostic is a practical way to find the first task worth handing to an agent.

Frequently asked questions

How many AI agents should a company run? There is no fixed number, and any figure offered would be a guess. Most companies should start with one scoped agent for one role and add another only when a repeated signal shows that responsibility, permission or failure cost has separated. Each added agent brings its own memory, tools, evaluations and handoffs, so the count should follow the boundaries of the work.

Is it better to give one agent more tools or to add a second agent? Add a tool to an existing agent only when it serves the same decision and the same approver. When the new tool writes to a different system, carries a different risk or belongs to a different team, a second agent with its own permissions is easier to govern. The deciding question is ownership, not capability.

Can several agents share one memory store? They can read from a shared source, such as an approved policy document, but each agent should keep its own working memory and its own permissions. A memory that holds everything makes it hard to explain why an agent said what it said, and a correction in one area can leak into unrelated answers.

Does splitting agents make them harder to govern? It usually makes governance clearer, provided each scope has a named owner, a defined tool list and a record of its decisions. The cost is more handoffs, and those handoffs need to be written down and tested. Without that discipline, one large agent is harder to review than several small ones.

Your next step

See where an AI agent fits in your company first.

Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.

Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.

Less busywork. More room for you.

Bring us the work you wish you had time for.

Book a call to try a personalized AI agent free for 7 days ↗Or take the free AI diagnostic →