# Sme Fanout

> Spawn parallel subject-matter-expert subagents each owning one lane of a complex task, with a fixed output contract, then synthesize. Use when a task spans multiple distinct domains (e.g. security + perf + docs + tests + schema), when a single-agent pass would be shallow across all of them, or when the user asks for a multi-perspective review/report.

- Skill: `jcdavis131/sme-fanout` (Agent Skill)
- Install (CLI): `npx skillmds@latest add jcdavis131/sme-fanout`
- Raw SKILL.md: https://api.skillmd.com/api/skills/jcdavis131/sme-fanout/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: jcdavis131 (https://skillmd.com/u/jcdavis131)
- Updated: 2026-09-21
- Page: https://skillmd.com/skills/jcdavis131/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)

```markdown
# <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.