Before building an AI system, which matters more: can you break the task into small steps, or does the task vary wildly each time?
How does task decomposability differ from task variance as a design criterion?
This explores two different questions you can ask when designing an AI system or training setup: whether a task can be split into smaller pieces (decomposability), and how much the task's inputs, outputs, or outcomes vary (variance). It also asks why these two questions lead to different design decisions.
This explores two different questions you can ask before building an AI system: can the task be broken into smaller pieces, and how much does it vary? The short version from the corpus is that decomposability tells you how to arrange the work, while variance tells you whether the system will learn anything useful from it. The corpus covers decomposability well. It doesn't directly frame task variance as an architecture criterion, so the variance side here is assembled from training-side findings.
On decomposability, the corpus suggests that splitting a task pays off more than you might expect. MAKER breaks million-step tasks into tiny subtasks, has several agents vote on each step, and finishes with zero errors. It does this using small non-reasoning models, because each piece is so simple that you don't need a strong model Can extreme task decomposition enable reliable execution at million-step scale?. Separating the model that plans the breakdown from the model that solves each piece also helps. The skill of breaking problems down transfers across domains, while the skill of solving them doesn't Does separating planning from execution improve reasoning accuracy?. The catch is that the breakdown has to be at the right level of detail. Standard LLM decomposition recovers only about a third of the steps it should, and that gap, not vocabulary mismatch, is what blocks agents from finding the right skills to reuse What blocks skill retrieval in task decomposition?. When the level is right, the pieces build on each other: agents that pull out reusable sub-task routines get 24–51% better Can agents learn reusable sub-task routines from past experience?.
There is a counterweight. A task can look decomposable without really being so. Walden Yan argues that parallel subagents fail because every action carries unwritten assumptions, so agents working separately make design choices that conflict Why do parallel subagents produce conflicting design decisions?. The real test is whether the pieces share hidden decisions, not whether you can draw boxes around them. Some approaches avoid this by keeping the breakdown inside a single model: recursive subtask trees Can recursive subtask trees overcome context window limits?, or DAG-style contraction where each step depends only on the current state of the problem Can reasoning systems forget history without losing coherence?.
Variance acts on a different part of the system: the learning signal. If a model's answers to a prompt all receive roughly the same reward, there is little for training to learn from. Regularization takes over, and the model collapses into generic templates that ignore the input. Simply choosing high-variance prompts recovers the lost performance Why do language models collapse into generic templates?. Variance across domains matters too. Structured tasks like math narrow a model's outputs, while creative tasks widen them. Training on the structured tasks first avoids damaging open-ended ability and gives a 6.2% gain Does training order reshape how models handle different task types?. RLHF itself pushes in opposite directions depending on the domain: it reduces variety in code but increases it in creative writing Does preference tuning always reduce diversity the same way?. When tasks differ this much, isolating the parameters each task relies on beats training on everything together Can isolating task-specific parameters prevent multi-task fine-tuning interference?.
Put together: decomposability is a question about structure, answered with architecture (how many agents, how to split the work, whether pieces share context). Variance is a question about the learning signal, answered with data and training choices (which prompts to keep, what order to train in, which parameters to protect). The interesting tension is that heavy decomposition lowers variance on purpose. MAKER works because each microstep is so predictable that voting can catch errors. That predictability is exactly what you want when running a system and exactly what weakens learning when training one. A highly decomposed pipeline may be easy to run reliably and hard to improve with reinforcement learning.
Sources 11 notes
MAKER solves million-step tasks with zero errors by decomposing into minimal subtasks, applying voting at each step, and flagging correlated errors. Surprisingly, small non-reasoning models suffice when decomposition is extreme enough, inverting the standard approach to hard problems.
Modular architectures with separate decomposer and solver models outperform monolithic LLMs, with decomposition ability transferring across domains while solving ability does not. The separation prevents planning-execution interference and produces more generalizable skills.
Standard LLM decomposition reaches only 34% step-level recall, gating retrieval success. Correcting step count recovers 75% of gains in iterative methods, shifting the bottleneck to representation-level reranking rather than vocabulary alignment.
Agent Workflow Memory induces sub-task routines at finer granularity than full tasks, abstracts example-specific values, and compounds them hierarchically. This produces 24.6% relative gain on Mind2Web and 51.1% on WebArena, with larger gains as train-test gaps widen.
Walden Yan argues multi-agent parallelism is fundamentally fragile: subagents embed unwritten assumptions in every action, so agents working independently converge on conflicting choices. The fix is reverting to single-threaded linear agents where context remains continuous.
Show all 11 sources
The Thread Inference Model demonstrates that reasoning structured as recursive subtask trees with rule-based KV cache pruning sustains accurate reasoning beyond context limits, even when manipulating 90% of the cache. This enables single models to replace multi-agent systems by handling full recursive reasoning internally.
Atom of Thoughts decomposes problems into DAGs and contracts them iteratively, ensuring each state depends only on the current problem—not prior steps. This memoryless approach eliminates historical baggage that bloats reasoning while maintaining answer equivalence.
When within-prompt reward variance is low, task gradients weaken and regularization dominates, pushing policies toward generic outputs. SNR-Aware Filtering—selecting high-variance prompts before updates—recovers performance across tasks and scales.
Omni-Thinker shows structured domains decrease output entropy while creative domains increase it. BWT-guided scheduling—training structured tasks first—yields 6.2% gains over joint training by preventing entropy collapse from damaging open-ended capabilities.
RLHF reduces lexical-syntactic diversity in code generation but increases it in creative writing. The direction depends on what each domain incentivizes: code rewards convergence toward correct solutions, while creative writing rewards stylistic distinctiveness.
Research shows that identifying core parameter regions per task, clustering overlapping tasks, and freezing core parameters while geometrically merging non-core parameters consistently outperforms standard multi-task fine-tuning. Temporal task scheduling alone proves insufficient without explicit structural parameter isolation.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Agent Workflow Memory
- Divide-or-Conquer? Which Part Should You Distill Your LLM?
- RAGEN-2: Reasoning Collapse in Agentic RL
- Why Do Multi-agent LLM Systems Fail?
- Rethinking Thinking Tokens: LLMs as Improvement Operators
- How Many Instructions Can LLMs Follow at Once?
- Distilling LLMs' Decomposition Abilities into Compact Language Models
- Algorithm of Thoughts: Enhancing Exploration of Ideas in Large Language Models