Task Decomposition Strategies

Effective task decomposition is the single most important skill in multi-agent orchestration. The goal is to split a large task into units that are independent (no shared state), complete (each produces a usable artifact), and mergeable (outputs can be combined without conflicts). Three decomposition strategies cover most scenarios: by module (each agent owns a directory or package), by concern (one agent writes code, another writes tests, a third writes docs), and by phase (one agent plans, another implements, a third reviews).

Module decomposition works best for monorepos and large codebases where different packages have minimal coupling. Concern decomposition works when the concerns genuinely do not overlap — the test writer needs the implementation as input, so this is sequential, not parallel, unless the test writer works from a spec rather than the implementation. Phase decomposition works for complex tasks where planning, implementation, and review benefit from different model capabilities.

# Decomposition strategies

1. BY MODULE (parallel)
   Agent A: Refactor apps/auth/
   Agent B: Refactor apps/payments/
   Agent C: Refactor apps/users/
   ✓ Independent — different directories
   ✓ Parallel — no shared files

2. BY CONCERN (sequential or spec-parallel)
   Agent A: Implement the feature
   Agent B: Write tests (after A, or from spec)
   Agent C: Write documentation (after A)
   ✓ Clear deliverables per agent
   ⚠ Sequential unless B/C work from spec

3. BY PHASE (sequential)
   Agent A: Plan the architecture (o3, high reasoning)
   Agent B: Implement the plan (codex-1, fast)
   Agent C: Review the implementation (o3, high reasoning)
   ✓ Each phase uses the optimal model
   ⚠ Strictly sequential — each needs prior output

1. List all deliverables Write down every file, test, and artifact the task needs to produce. This is your decomposition inventory.
2. Group by independence Cluster deliverables that share no files. Each cluster is a candidate for a parallel agent.
3. Identify dependencies For clusters that depend on each other, determine the dependency order. These must be sequential, not parallel.