An AI's planning skill generalizes to new problems; its execution skill doesn't — so bundling them hides which one is broken.
Why should decomposition be diagnosed and fixed separately from solving?
This explores why treating the 'break the problem into steps' phase as its own failure surface — measured and fixed on its own — beats folding it into one monolithic solve.
This explores why the 'break the problem into steps' phase should be diagnosed and repaired on its own terms, rather than treated as one seamless part of solving. The core reason the corpus keeps surfacing: decomposition and solving fail differently, transfer differently, and get masked by different metrics — so a system that scores them together can't tell you which one is broken.
Start with where the failures actually live. When researchers separate a decomposer model from a solver model, accuracy and generalizability both improve, and the reason is revealing: decomposition skill transfers across domains while solving skill does not Does separating planning from execution improve reasoning accuracy?. That asymmetry is the whole argument. If planning generalizes and execution doesn't, then bundling them means your portable, reusable capability is being dragged down by the brittle, domain-specific one — and you'd never see it, because a single end-to-end score can't attribute the loss. Diagnosing them separately is how you find out that the planning was fine and the execution wasn't, or vice versa.
And the decomposition step is often the actual bottleneck, not the solving. Standard LLM decomposition hits only 34% step-level recall, and that gates everything downstream — correcting just the step count recovers 75% of the gains, shifting the remaining problem to a completely different stage (representation-level reranking) What blocks skill retrieval in task decomposition?. In other words, once you isolate decomposition you discover the fix is cheap and the leverage is enormous; folded into solving, the same error looks like a vague, hard-to-place reasoning failure. This echoes a broader finding that fine-tuning can make outputs *look* right — proper structure, valid format — without making them feasible Does supervised fine-tuning actually improve reasoning on optimization problems?: surface metrics reward the appearance of a good plan, not a plan that actually decomposes the problem correctly.
There's also a mechanical payoff to keeping the two apart. Decoupling the reasoning/planning phase from execution — planning fully before acting, or using abstract placeholders for results — eliminates redundant prompt growth and unlocks parallelism, without hurting reasoning quality Can reasoning and tool execution be truly decoupled?. A related architectural stance restricts the LLM to the abstraction-only job (read the messy input, emit clean formal structure) and hands the deterministic grind to a solver that's better at it Should LLMs handle abstraction only in optimization?. Both say the same thing from different angles: decomposition is a distinct competence with a distinct best-tool, and merging it into solving wastes the specialization.
The deepest version of the argument is that identical outputs can hide fundamentally broken internal structure — models can be perfectly linearly decodable yet fractured and entangled underneath, unable to recombine parts in novel ways Can identical outputs hide broken internal representations?, which is a symptom of the binding problem: networks struggle to segregate entities and reuse learned structure compositionally Why do neural networks fail at compositional generalization?. Bad decomposition is exactly this failure wearing a task-success mask. So the case for diagnosing decomposition separately isn't tidiness — it's that a correct-looking answer can sit on top of a decomposition that never actually carved the problem at its joints, and only a separate diagnosis will ever catch it.
Sources 7 notes
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.
Supervised fine-tuning makes model outputs look correct—proper JSON structure, valid identifiers, expected sections—without making them physically feasible. The model learns surface features of solutions, not the reasoning to construct valid ones.
ReWOO and Chain-of-Abstraction both decouple reasoning from tool responses through different mechanisms—planning-before-execution and abstract placeholders respectively—eliminating quadratic prompt growth and sequential latency while maintaining reasoning quality.
LLMs plateau at constraint satisfaction regardless of scale, but excel at natural-language-to-formal-structure translation. The productive architecture restricts LLMs to reading input and emitting solver code, leaving numeric iteration to deterministic solvers.
Show all 7 sources
Networks trained with SGD reproduce outputs perfectly while having radically different internal structure than evolved networks, with weight perturbations revealing fractured, entangled representations that prevent transfer to novel contexts or creative recombination.
Greff et al. argue that neural networks cannot dynamically bind distributed information into compositional structures due to three failures: segregating entities from inputs, maintaining representational separation, and reusing learned structure in novel combinations. Scaling can partially overcome this by enabling compositional representations to emerge.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Divide-or-Conquer? Which Part Should You Distill Your LLM?
- Questioning Representational Optimism in Deep Learning: The Fractured Entangled Representation Hypothesis
- Break It Down: Evidence for Structural Compositionality in Neural Networks
- Scaling can lead to compositional generalization
- From Frege to chatGPT: Compositionality in language, cognition, and deep neural networks
- Scaling Reasoning, Losing Control: Evaluating Instruction Following in Large Reasoning Models
- Open Problems in Mechanistic Interpretability
- Distilling LLMs' Decomposition Abilities into Compact Language Models