===== Subagent Sweet Spot: 2-3, Not 10 =====

**Optimal subagent count is 2-3, not 10+; coordination overhead exceeds parallel benefit beyond this threshold.**

Optimal subagent count is 2-3, not 10+; coordination overhead exceeds parallel benefit beyond this threshold. More agents do not always mean more throughput. The sweet spot balances parallelism with coordination cost.

The Pattern

For most agent tasks, 2-3 coordinated agents outperforms both single agents and large agent pools. This is because:

1. Coordination Overhead
Each additional agent requires:
    * Message routing and sequencing
    * Result aggregation
    * Conflict resolution
    * State synchronization

2. Communication Complexity
O(n) agents → O(n²) communication paths
3 agents = 3 connections
5 agents = 15 connections
10 agents = 90 connections

3. Diminishing Returns
At 3+ agents, the coordination cost often exceeds parallelization benefit.

When to Break the Rule

Use more than 3 agents when:
    * Tasks are embarrassingly parallel (no coordination needed)
    * Result merging is trivial
    * Network latency dominates (parallel hides latency)
    * Throughput is critical, cost is not

Examples

Good for 2-3 agents:
    * Research + verification + synthesis
    * Writing + editing + fact-checking
    * Analysis + comparison + recommendation

Probably NOT for 5+ agents:
    * Multiple agents doing similar work
    * Tasks requiring frequent synchronization
    * Systems without robust coordination infrastructure

The Trade-off Matrix


Key Takeaway

Start with 2-3 agents. Profile your specific workload. If coordination dominates, reduce count. If idle time dominates, increase carefully.

See Also:
    * Swarming Agents: Parallel Execution Patterns (when scaling beyond 3)
    * Health Monitoring for Agent Systems (keeping agents alive)
    * Verification Before Asserting (quality in parallel work)

Where It Applies
Agent architecture decisions, subagent orchestration, parallel task execution.

Why It Works  
Fewer agents means less coordination overhead, simpler debugging, predictable behavior. The complexity of n-agent systems grows faster than linear.

Risks
Very small agent counts may underutilize resources. Task characteristics (parallelizability, mergeability) determine optimal count.

**Where it applies:** Parallel agent work, batch processing, concurrent task execution

**Why it works:** Lane contention and session queuing create bottlenecks; fewer agents reduces coordination complexity

**Risks:** Very small counts may underutilize resources; task characteristics determine optimal parallelism

{category>transferable}