Multi-agent systems: when one agent isn't enough

Once a first agent is working, the obvious next move is to give it more to do. Add the billing tools. Add the CRM. Add the reporting database. For a while it works. Then quality starts to slip: the agent picks the wrong tool, mixes up instructions, or takes twice as many steps as it should.

This is the moment to stop growing one agent and start building a team.

Why specialists beat generalists

Language models are a little like people: they do their best work with a clear role and a focused set of tools. An agent whose instructions cover support, sales, billing and reporting has to hold all of that in mind at every step. An agent whose only job is billing questions can have detailed, precise instructions and just the five tools it needs.

Specialists are also easier to test, easier to improve and easier to govern, because each one's permissions match one job.

The shape of a multi-agent system

Most of the systems we build follow one of three patterns.

The orchestrator

A coordinating agent receives the request, breaks it into parts and hands each part to a specialist. It then assembles the results. For example, when a large customer asks to upgrade their plan, the orchestrator might ask a billing agent to calculate the new price, a contracts agent to prepare the amendment and a CRM agent to update the account, then send one coherent reply.

The assembly line

Work passes through a fixed sequence of agents, each adding something. A content pipeline might run research, then drafting, then fact-checking, then brand-voice editing. Each agent is simple; the line as a whole produces something none of them could alone.

The reviewer pair

One agent does the work and another checks it against clear criteria, sending it back with notes if needed. This pattern is a cheap and effective way to raise quality on anything that matters.

What makes them work in practice

• Clear hand-offs. Agents pass structured information to each other, not long free-text conversations. That keeps the system predictable.
• Shared memory, carefully scoped. Agents can see the context they need about a customer or task, and nothing more.
• A single place for humans to step in. Approvals and escalations from every agent arrive in one queue, so your team isn't hunting across tools.
• End-to-end tracing. When a request touches four agents, you need to see the full path in one view.

Start with one agent that works. Split it into a team only when it starts to struggle — and split along the lines of real jobs in your business.

A warning about complexity

It's tempting to design an impressive diagram with a dozen agents from day one. Resist it. Every additional agent adds cost, latency and something else to monitor. The best multi-agent systems we've built grew one agent at a time, each added because there was a clear, measured reason for it.

Where this is heading

The direction is clear: businesses will run whole processes — order to cash, lead to customer, ticket to resolution — with teams of agents doing most of the steps and people supervising the important decisions. The companies that get there first won't be the ones that bought the most AI. They'll be the ones that learned, one agent at a time, how to trust it.