Two levels — orchestrator → lead → worker — is the shape that works; depth-1 hits the single-agent ceiling and depth-3+ bleeds coordination cost faster than specialization pays it back.

Principle

Delegation Has a Sweet Spot

The spectrum

Too shallow starves. Too deep pollutes. Two is the peak.

Quality as a function of delegation depth. Not monotonic.

Depth 1

↓

Omnibus agent

One context holds plan + build + test + review. Hits the ceiling.

Sweet spot

Depth 2

✓

Orchestrator → Lead → Worker

Three rigid roles. Matches the shape of a team. Each hop pays for itself.

Depth 3+

↓

Director stacks

Every forwarding step loses fidelity. Coordination cost dominates specialization gain.

context ceilingoptimumcoordination tax

The curve is shaped like an inverted U — adding layers past two trades quality for latency.

Who does what at depth-2

Three roles. Each one is defined by what it doesn't do.

The division is rigid. A role that drifts collapses the depth.

Orchestrator

Classifies and routes

✗ does not execute · ✗ does not write code

Owns: "which team owns this?"

│

Lead

Delegates and synthesizes

✗ does not execute — a lead with write access starts pulling work

Owns: "which worker, with what context?"

│

Worker

Executes one task, returns one artifact

✗ does not delegate — that breaks the depth rule and invites depth-3

Domain-locked to its specialty.

An orchestrator that writes code collapses to depth-1. A worker that delegates spawns depth-3.

What breaks when you leave the sweet spot

Four distinct failure modes. Same root cause — wrong depth.

Omnibusdepth-1

One agent plans, builds, tests, and reviews

Output quality drops as the context fills with debug chatter. Reviews conflate with build details. Tests get implementation bias. context ceiling

Tall stackdepth-3+

Orchestrator → Director → Lead → Worker

Each layer adds latency. Each forwarding step paraphrases the request. The worker ends up two hops from the user. fidelity loss

Flat Nno router

N workers, no orchestrator

No routing, no classification. Every request reaches every worker. Duplicate effort or arguments over ownership. O(N²) coordination

Monoleadfan-in

All specialists under one lead

One lead becomes the only bottleneck. Its context fills with every worker's output. Synthesis quality collapses.

If you skip the depth rule, the pipeline pays the coordination tax without getting the specialization.

Why two, not three

The same reason human org charts settle at two.

Human org

1.Director routes

2.Manager delegates

3.IC ships

Each level = one round-trip.

Three round-trips per query — already slow.

Agent system

1.Orchestrator routes

2.Lead delegates

3.Worker ships

Each level = one context handoff.

Four handoffs shred the original intent.

Two levels isn't a convention — it's the ceiling where round-trip cost exceeds specialization gain, in humans and in agents alike.

The discipline

Depth-2 isn't a default — it's the observed optimum.

Before you add a third layer, prove the second one is saturated. Before you collapse to one, prove the task doesn't need routing. Every deviation from user → lead → worker pays a tax the specialization gain won't cover.