Task Decomposition
Match the decomposition pattern to the task, and recognize attention dilution - the structural failure where later items in a batch get shallow analysis.
Task decomposition breaks complex work into pieces an agent can handle well. The exam centers on two patterns and one critical failure mode. Choosing the right pattern is about task characteristics, not model sophistication.
Pattern 1: fixed sequential pipelines
In a fixed pipeline (also called prompt chaining), the steps are defined upfront and run in order, each consuming the previous step's output. A code review might run per-file local analysis, then a cross-file integration pass, then a unified report. Fixed pipelines are consistent, reliable, and easy to debug and monitor - the same input always follows the same path. Their weakness is rigidity: they cannot adapt when an intermediate step discovers something that should change the plan. Best for predictable, structured work like document processing, data extraction, and compliance checks.
Pattern 2: dynamic adaptive decomposition
In dynamic decomposition, subtasks are generated from what the agent discovers, so the plan evolves. Testing a legacy codebase might start by mapping structure, identifying high-impact areas, and building a prioritized plan - then, on discovering that Module A depends on untested Module B, reprioritizing to test B first. It adapts to complexity and unexpected issues but is less predictable and harder to debug. Best for open-ended investigation: security audits, research, and unfamiliar-system debugging.
| Task characteristics | Pattern | Why |
|---|---|---|
| Known steps, structured input | Fixed pipeline | Consistency over adaptability |
| Open-ended, undefined scope | Dynamic decomposition | Adaptability is essential |
| Multi-file code review | Fixed pipeline | Phases are predictable |
| Legacy codebase exploration | Dynamic decomposition | Dependencies emerge during work |
| Document field extraction | Fixed pipeline | Fields and format are predetermined |
| Unfamiliar-system debugging | Dynamic decomposition | Root cause is unknown |
The attention dilution problem
Attention dilution is the exam's key failure mode. When an agent processes too many items in a single pass, its analysis depth degrades: early items get thorough treatment, later items get superficial coverage. In a 14-file review, files 1-5 might get line-specific bug reports while files 10-14 miss null-pointer bugs and SQL-injection risks entirely - and the same forEach loop flagged inefficient in file 3 sails through unremarked in file 11. The cause is structural: the model allocates finite attention across all items, so a high item count shrinks per-item attention.
It is not fixed by a bigger model or a larger context window. Processing many items in one pass produces inconsistent depth regardless of raw capability. The fix is architectural: a multi-pass design.
The multi-pass fix
- 1Layer 1 - per-item local analysis. Analyze each file or document in its own dedicated pass so it gets the full attention budget. This catches local issues consistently.
- 2Layer 2 - cross-item integration pass. After all local passes, run a separate pass focused only on relationships - data flow, inconsistent patterns, cross-file dependencies.
# Layer 1: each item gets a dedicated pass (full attention budget).
local_results = []
for f in files:
local_results.append(analyze_single_file(f)) # one item at a time
# Layer 2: one integration pass over relationships only.
report = integration_pass(
local_results,
focus="data flow, cross-file consistency, shared dependencies",
)Feeding all 14 files into one pass. Attention dilutes across items: files 1-5 get line-level findings while files 10-14 miss null-pointer and SQL-injection bugs. A bigger model or context window won't fix it.
analyze(all_files) # depth degrades on later itemsUse a multi-pass architecture: one dedicated local pass per file (full attention budget each), then a single cross-file integration pass for relationships.
locals = [analyze_single_file(f) for f in files]
report = integration_pass(locals, focus="cross-file")Improving the prompt raises average quality but does not guarantee dedicated attention per item, so later items still degrade. Likewise, batching without a cross-item integration pass just moves the problem to cross-batch issues. Only the multi-pass architecture gives each item its own attention budget and then reconciles relationships.
How the exam will try to trick you
The distractors below look right under time pressure — learn the tell.
- The trap
Fix attention dilution with a more powerful model or a larger context window.
Correct answerRestructure into a multi-pass architecture - dilution is architectural, not a capability limit.
Why: Processing too many items in one pass degrades depth regardless of model power or context size.
- The trap
Treat a single pass with better prompts as equivalent to multi-pass review.
Correct answerGive each item its own dedicated pass so it gets the full attention budget.
Why: Better prompts lift average quality but do not guarantee dedicated attention per item.
- The trap
Apply a fixed pipeline to an open-ended investigation like a security audit.
Correct answerUse dynamic adaptive decomposition when the full scope is unknown at the start.
Why: Fixed pipelines cannot respond to unexpected findings that emerge mid-task.
- The trap
Batch files into groups without adding a cross-file integration pass.
Correct answerAdd a dedicated cross-file integration pass after the batched local analysis.
Why: Batching curbs dilution within a batch but misses data-flow and pattern issues across batches.
Key takeaways
- Match the decomposition pattern to task characteristics, not to model sophistication.
- Fixed pipelines give consistency and easy debugging for predictable, structured work.
- Dynamic decomposition gives adaptability for open-ended investigation and exploration.
- Attention dilution is structural: processing many items in one pass degrades depth on later items.
- A bigger model or larger context window does not fix attention dilution - a multi-pass architecture does.
- Multi-pass = per-item local passes plus a separate cross-item integration pass.
Frequently asked questions
What is attention dilution in a Claude agent?+
It is a structural failure where an agent processing too many items in a single pass gives thorough analysis to early items and increasingly shallow analysis to later ones, because the model's finite attention is spread across all items at once.
How do you fix attention dilution?+
With a multi-pass architecture: analyze each item in its own dedicated pass so it gets the full attention budget, then run a separate cross-item integration pass focused on relationships. Upgrading the model or enlarging the context window does not fix it.
When should I use a fixed pipeline vs. dynamic decomposition?+
Use a fixed pipeline for predictable, structured tasks with known steps, such as document extraction or multi-file review, where consistency matters most. Use dynamic decomposition for open-ended work like security audits or debugging unfamiliar systems, where the plan must adapt as findings emerge.