Three agents is the sweet spot. Five agents is chaos pretending to be orchestration.

I spent three weeks building a multi-agent team with CrewAI. Five agents: researcher, writer, editor, fact-checker, and publisher. Beautiful orchestration. Clean handoffs. The demo was flawless.

Then I ran it in production.

The researcher would find a great source, pass it to the writer, who would write about something completely different. The editor would polish prose that missed the point. The fact-checker would verify claims nobody made. The publisher would ship content that answered the wrong question.

The problem wasn't the framework. It was the team size.

Multi-agent teams have a coordination tax. Every handoff is a game of telephone. Every agent adds interpretation drift. By agent #5, you're not solving the original problem anymore.

Three agents is the sweet spot. Four agents is manageable. Five agents is chaos pretending to be orchestration.

Here's what actually works:

• Two-agent teams: Doer + Reviewer. One agent executes, one validates. Clean handoff, clear responsibilities.
• Three-agent teams: Researcher + Executor + Validator. Research the problem, execute the solution, verify the outcome.
• Never more than three unless you're building agent infrastructure, not agent solutions.

The magic happens when you keep teams small but give each agent real depth. Instead of five shallow specialists, build two deep generalists.

My current setup: Research agent + Execution agent. The researcher builds context and creates a plan. The executor follows the plan and reports results. That's it.

# Research Agent Output
TOPIC: Customer churn analysis
SOURCES: [3 relevant datasets found]
APPROACH: Cohort analysis + predictive modeling
DELIVERABLES: Dashboard + recommendations
HANDOFF: Ready for execution

# Execution Agent Input
PLAN: [Received from researcher]
STATUS: Executing cohort analysis...
OUTPUT: Dashboard deployed to /dashboards/churn
NEXT: Building recommendation engine

The researcher doesn't try to execute. The executor doesn't try to research. Clean separation, minimal drift.

When teams get bigger, add a coordinator agent, but keep the working teams at 2-3 agents max. Think of it like software architecture: small, focused services with clear interfaces.

The coordination tax is real. Every agent you add makes the system exponentially harder to debug. When something goes wrong with five agents, you're playing detective across five different reasoning chains.

With two agents, debugging is straightforward: did the researcher miss something, or did the executor misinterpret the plan?

Small teams ship. Big teams coordinate.