Sme fanout

SME Fanout

One generalist going wide goes shallow. A fan-out of specialists each going deep, feeding a fixed contract, produces a stronger artifact with the same wall-clock.

When to fan out

• The task has 2+ distinct lanes where deep domain knowledge differs (security vs. perf vs. API design vs. data model vs. docs).
• The artifact needs to cover all lanes and a single pass would skim them.
• Lanes are mostly independent — lane B doesn't need lane A's full output to start.

Do NOT fan out when:

• Lanes are sequential / dependent (just do them in order).
• The task is small enough for one focused pass.
• You'd spend more coordinating than the depth gains back.

How to run a fan-out

1. Name the lanes. 3–5 is the sweet spot. More than 5 means lanes are too granular — merge.
2. Write a distinct charter per lane. Not "review security" — a charter names the specific scope and angle: "review authn/authz boundary in api routers; flag any path that touches tenant-scoped data without a workspace check". A vague charter gives vague output.
3. Fix one output contract for every lane. Same filename shape, same headings, same max length. This is the most important step — synthesis is only mechanical if every SME returns the same shape. Example: ## Findings → ## Risk → ## Recommendation → ## Evidence.
4. Fix one output directory. All SMEs write to the same path (e.g. knowledge/reviews/) so the orchestrator knows where to collect without hunting. The filename encodes the lane: knowledge/reviews/<lane>.md.
5. Give each SME its charter + the contract + only the context it needs. Don't dump the whole task into every subagent; that defeats specialization.
6. Run them in parallel (single message, multiple Task tool calls).
7. Surface per-agent status with cost. While they run, report each agent's current task and resource cost: ◯ general-purpose Getting timestamp for backend-architecture.md 5m 50s · ↓ 89.5k tokens. This lets the user spot a stuck or expensive SME without asking (see cost-transparency).
8. Synthesize, don't concatenate. Read all returns, resolve conflicts, dedupe, then write the unified artifact. Mark conflicts you couldn't resolve.

Output contract template (reusable)

# <Lane> review

## Findings
- One per line, each with a severity tag (🔴/🟡/🟢) and a file:line anchor.

## Risk
- What breaks if this is ignored, and how bad.

## Recommendation
- Concrete next step, ordered.

## Evidence
- Command output / diff / metric that supports the above.

Anti-patterns

• Free-form returns. If SMEs return prose, synthesis becomes reading comprehension and you lose the speed.
• Too many lanes. 8 subagents each producing 200 lines = no one reads it all.
• Orchestrator does lane work. The orchestrator assembles; it does not redo a lane's review.
• No conflict resolution. Two SMEs contradicting each other, silently — call it out in the synthesis.

Synthesis output

End with a single ranked list: top 3 actions across all lanes, with the owning lane tagged. That's the artifact the user actually wants.