Agent Delegation Patterns

Three delegation patterns for multi-agent work. Choose based on the decision matrix in CLAUDE.md. All delegation uses the Agent tool exclusively -- no TeamCreate, TeamDelete, or SendMessage.

Single Sub-Agent

One agent owns the work start to finish. Use when the task maps cleanly to one domain.

• "Fix the button alignment on the dashboard" -- Frontend Developer
• "Add rate limiting to the API" -- Backend Architect

Sequential Sub-Agents

Output of one agent feeds the next. Order matters -- these agents MUST NOT run in parallel.

Execution rule: Invoke each agent as a separate Agent tool call. Wait for completion before invoking the next. Do NOT combine multiple sequential agents in a single message -- Claude may parallelize calls that appear in the same response.

CORRECT — separate calls, each waits for the previous:
  Agent(plan, "Design the data model...")        → wait for output
  Agent(backend-architect, "Build API from: ...")  → uses plan output

WRONG — both in one message, may launch simultaneously:
  Agent(plan, "Design the data model...")
  Agent(backend-architect, "Build API...")  ← no access to plan output

Background agents: If an agent must run in the background (run_in_background: true), always add isolation: "worktree" to prevent branch-switching conflicts with the main session.

Examples:

• "Design the data model, then build the API on top of it" -- Plan agent hands spec to Backend Architect
• "Write the feature, then security review it" -- engineer agent hands code to Security Engineer

Parallel Sub-Agents

Multiple agents evaluate the SAME artifact independently and simultaneously. Order does not matter. Invoke multiple Agent tool calls in a single message -- Claude will run them in parallel.

Use for cross-domain review or when you need multiple perspectives:

• "Is this feature production ready?" -- Security Engineer + Backend Architect in parallel
• "Review this API design" -- Backend Architect + Security Engineer in parallel

For multi-round structured review (diverge, respond, converge), use sequential rounds of parallel Agent calls:

1. Round 1 (parallel): Each agent reviews independently. Produces critique + recommendations.
2. Round 2 (parallel): Each agent sees ALL Round 1 output. Reacts to peers: agree, challenge, build on.
3. Round 3 (single): One agent leads implementation incorporating synthesized direction.

Max 3 rounds. Only use structured rounds when genuine tension between perspectives benefits the outcome. For independent concerns (security + performance checking the same PR), a single round of parallel agents is sufficient.

Rules

• Do not assemble parallel agents just because they are tangentially related -- only parallelize when domains have real interdependencies or genuine tension
• Cap parallel agents at 3 unless complexity clearly demands more
• State which agent(s) you are using and why before proceeding
• Always provide agents with Locked Decisions that are relevant to their work
• If no built-in agent type matches, use a general-purpose agent with a detailed prompt describing the role

Review Passes

• Standard tasks: 2 passes max (review, then resolve and ship)
• High-stakes tasks: 3 passes max (review, resolve, then verify-only)

On the final pass, resolve all conflicts and deliver output. Do not re-open new issues or start additional cycles.