Spend a few minutes on X or LinkedIn and you'll probably run into someone showing off a multi-agent system, with an architect agent, a developer agent, a reviewer, a testing agent and a manager coordinating the whole thing. The diagram has arrows going everywhere and the demo looks impressive, which can leave you wondering whether your own project needs something similar. After seeing enough of these systems, I started noticing a pattern: the architecture often gets more attention than the problem it was meant to solve. Multi-agent orchestration has legitimate uses, but I suspect that many applications built around several agents would work just as well, or even better, with a single agent and a handful of tools.
The microservices parallel
All of this reminds me of something software engineering has already been through. At some point everything had to be a microservice, and building a monolith almost felt like admitting you didn't understand modern architecture. Small applications were broken into independent services that each had their own deployment pipeline and infrastructure, and teams that used to make function calls were suddenly making network requests and needing message brokers and distributed tracing to keep track of them. Some systems benefited from that separation, but plenty of others ended up maintaining distributed infrastructure for applications that could have lived comfortably in a single process. I think we're seeing a similar instinct with AI agents: instead of splitting an application into ten services, we split a task into ten agents, give each one its own prompt and context, and then add another layer to coordinate them.
The cost of coordination
There is an additional complication. Traditional services usually communicate through APIs with defined behavior, whereas agents often exchange natural language or model-generated output that another model has to interpret. Even with structured schemas, misunderstandings can happen, and every handoff has a cost. Each agent needs its own context, which consumes tokens, and passing work along requires extra calls in which summarization can cause details to disappear. A constraint the user mentioned might get lost between two agents, or an incorrect assumption made early on might influence everything that follows. Debugging gets harder too, because instead of inspecting a single execution trace you may have to reconstruct a whole conversation between agents to find where something went wrong. This doesn't make multi-agent systems bad by default, but their benefits have to justify the extra moving parts.
When independent investigations make sense
Consider a competitive intelligence platform that monitors 200 companies every week, tracking pricing changes, product launches, hiring activity and relevant news before producing a strategic report. It's a reasonable candidate for distributed processing, since investigating one company doesn't depend on investigating another and keeping every source inside one agent's context would be impractical. Even so, parallel execution doesn't automatically call for autonomous agents: if every company follows the same research procedure, conventional workers making parallel model calls might be enough.
Multi-agent orchestration gets more interesting when the investigations themselves are unpredictable. Suppose one agent notices that a competitor has suddenly started hiring dozens of AI infrastructure engineers and decides to dig through job postings and recent acquisitions to understand what's going on, while another agent detects unusual pricing changes and explores possible explanations. A coordinator could connect those findings and ask for more research, and because each agent has a reason to make its own decisions, the system can explore paths nobody defined in advance. That is a reasonable use of autonomy.
Multiple steps don't require multiple agents
Now take something much more common, a support assistant that reads tickets and suggests responses based on the documentation. It's tempting to build a classifier agent, a research agent, a writer, a reviewer and a formatter, but classification could simply be a field in the model's structured output, research could be a search tool, and formatting could be ordinary code. Reviewing doesn't necessarily need another autonomous agent either, especially if it would use the same model and the same information. A single agent with access to the documentation and a few validation rules might handle the whole task.
This distinction gets overlooked surprisingly often, because breaking a task into steps doesn't mean every step needs its own agent. A workflow can have several stages that run in parallel and include validation without handing any decisions over to language models, and when the sequence is already known, writing it in code is usually easier to maintain.
Start simple and test the architecture
My preferred approach is to start with a single model call, add tools when they become necessary, and let the agent take multiple steps if the task requires it. If context gets difficult to manage, isolated subagents might help, and full orchestration becomes worth considering once independent investigations need to adapt as new information appears. There are other valid reasons to separate agents, such as tasks that require incompatible tools or strict permission boundaries. One agent might be allowed to access sensitive data while another interacts with external systems, and that separation can improve security as long as the restrictions are enforced by the infrastructure and not just written into prompts.
Even then, I'd want evidence before adopting the architecture. Build a baseline and test it against real tasks: if the agent lacks information, give it better retrieval tools, and if its output is inconsistent, add validation. Only when context becomes overloaded does it make sense to experiment with splitting the work, and then you can compare the results. Measure quality, latency, cost and failure rates. You might find that multiple agents improve performance considerably, or you might find that your five-agent system produces roughly the same results as one agent at several times the cost.
Job titles aren't specialization
Copying human team structures into agent architectures is also somewhat misleading. Human developers specialize because learning takes time and nobody can know everything, whereas a language model can take on different roles through instructions and tools, so giving it five job titles doesn't create five independent areas of expertise. Separate agents can still be useful when they have different contexts, capabilities or sources of evidence, but an architect agent and a manager agent shouldn't exist merely because that's how a software team happens to be organized.
Complexity needs to earn its place
I understand why these architectures are appealing: they're fun to experiment with and make for compelling demos, and agent frameworks have made them easier to build than ever. The problem starts when the demo becomes the architectural blueprint without anyone checking whether the extra coordination improves the result. We learned with microservices that decoupling has a price, and there's little reason to forget that just because the components now talk to each other through language models.
Before drawing five boxes connected by arrows, try giving one capable agent the right tools and see how far it gets. If it hits a limitation that multiple agents can solve, you'll have a good reason to introduce them.
Top comments (0)