Step-by-Step Task Decomposition

• Step-by-Step Task Decomposition is the method of splitting complex tasks into sequential, manageable subtasks to optimize search reduction, correctness, and generalization.
• It is applied across domains such as hierarchical planning, image restoration, program synthesis, and script generation by leveraging intermediate representations.
• Empirical evidence shows that adaptive decomposition techniques significantly reduce planning time and improve accuracy in large-scale, long-horizon tasks.

Searching arXiv for recent and foundational papers on step-by-step task decomposition across planning, LLMs, and related domains. Step-by-step task decomposition is the representation of a complex task as a sequence of simpler subtasks or subgoals that can be solved in turn rather than as a monolithic problem. Across contemporary research, the same basic idea appears in hierarchical planning over reusable subgoals, iterative removal of degradation bases in image restoration, execution-guided synthesis of subprograms, learned subgoal sequences for manipulation planning, staged translation workflows, and adaptive decomposition policies for LLMs. The central issue is not only how to decompose, but when a decomposition reduces search, preserves correctness, improves cross-task generalization, or trades training cost for inference cost (Correa et al., 2020, Cao et al., 2024, Zenkner et al., 11 Mar 2025, Zhang et al., 2024, Briakou et al., 2024, Liu et al., 20 Oct 2025).

1. Conceptual foundations

In the planning literature, task decomposition is formalized as choosing a set of subgoals $\mathcal{Z} \subseteq \mathcal{S}$ inside a deterministic shortest-path problem with state space $\mathcal{S}$ and transition graph $T \subseteq \mathcal{S}\times\mathcal{S}$. Hierarchical planning then operates at three levels: the action level, the subtask level, and the task-decomposition level. A subgoal $z \in \mathcal{S}$ can be treated as an option that starts from any state, terminates at $z$, and uses the optimal policy to reach $z$. The resulting decomposition is shared across tasks in an environment rather than constructed separately for each start-goal pair (Correa et al., 2020).

In program synthesis, the same notion becomes a decomposition of a specification $X=\{(I_1,O_1),\ldots,(I_n,O_n)\}$ into intermediate I/O stages. ExeDec aims to find subprograms $p_1,\ldots,p_T$ such that, for each example, $$I_i \xrightarrow{p_1} S_{i,1} \xrightarrow{p_2} \cdots \xrightarrow{p_T} O_i$$. This turns “find one program from input to output” into “predict a subgoal, synthesize a subprogram, execute, update the specification, and repeat” (Zenkner et al., 11 Mar 2025).

In hierarchical script generation, the hierarchy is explicitly linguistic: a goal $G$ is decomposed into subgoals $\mathcal{S}$0, and each subgoal $\mathcal{S}$1 is decomposed into a step sequence $\mathcal{S}$2. The full script is $\mathcal{S}$3. This places subgoals between the title-level goal and the final step list, making decomposition a textual analogue of hierarchical planning (Li et al., 2023).

2. Normative, algorithmic, and structural principles

A major formal account treats decomposition as a resource-rational representation problem. In that view, the immediate reward for choosing a subgoal $\mathcal{S}$4 from state $\mathcal{S}$5 is $\mathcal{S}$6, where $\mathcal{S}$7 is the shortest-path length, and the action-level planning cost $\mathcal{S}$8 is the search cost under a particular planner such as BFS or A*. The subtask-level value for goal $\mathcal{S}$9 satisfies

$T \subseteq \mathcal{S}\times\mathcal{S}$0

and the decomposition itself is chosen by

$T \subseteq \mathcal{S}\times\mathcal{S}$1

Because $T \subseteq \mathcal{S}\times\mathcal{S}$2 depends on the planner, the optimal decomposition is algorithm-dependent: BFS, IDDFS, and A* need not favor the same subgoal set (Correa et al., 2020, Correa et al., 2022).

This account is empirically tied to graph structure. Across 11,117 distinct 8-node graphs, resource-rational task decomposition with IDDFS was highly correlated with betweenness centrality, and in a behavioral study with $T \subseteq \mathcal{S}\times\mathcal{S}$3 participants on 30 randomly sampled graphs, explicit and implicit subgoal probes were best fit by RRTD-IDDFS among the normative models, while betweenness centrality fit best among the heuristics (Correa et al., 2022). In a spatial-navigation extension using A* with Manhattan distance, the model compared two symmetrically optimal routes that differed only in planning cost, predicting a preference for the route with fewer node expansions; participants chose the favorable path on 42.5% of first trials and 67.5% of last trials (He et al., 2023).

A stronger structural claim appears in synchronized multi-agent decomposition. There, a global task is a deterministic finite automaton $T \subseteq \mathcal{S}\times\mathcal{S}$4, each agent has a local event set $T \subseteq \mathcal{S}\times\mathcal{S}$5, and decomposition is defined by

$T \subseteq \mathcal{S}\times\mathcal{S}$6

where $T \subseteq \mathcal{S}\times\mathcal{S}$7 is the natural projection onto $T \subseteq \mathcal{S}\times\mathcal{S}$8. The paper proves by counterexample that not all specifications are decomposable in this sense, gives necessary and sufficient conditions for two agents, and proposes a hierarchical algorithm as a sufficient condition for arbitrary finite $T \subseteq \mathcal{S}\times\mathcal{S}$9. This formalizes a strict version of “decomposition is not arbitrary”: local subtasks must compose back to the original global behavior (0911.0231).

A different structural program appears in ACONIC, which models the task as a constraint problem, uses the constraint graph induced by a planning-as-satisfiability reduction, and measures complexity via treewidth and the number of bags in a tree decomposition. Subtasks are then defined by bags in a minimal tree decomposition, so that local consistency on each bag plus consistency on shared variables implies global satisfiability. This suggests a systematic route from formal complexity analysis to decomposition policies, rather than heuristic prompt splitting (Zhou et al., 9 Oct 2025).

3. Intermediate representations and operational patterns

Although the domains differ, many decomposition systems introduce an intermediate representation that is both simpler than the full task and rich enough to guide the next step. In universal image restoration, the intermediate object is a currently hypothesized degradation basis chosen by a Degradation Discriminator; in masked-language-model reasoning it is an intermediate step $z \in \mathcal{S}$0 placed in a convertible slot $z \in \mathcal{S}$1; in long-form translation it is a sequence of translation artifacts—research notes, a draft, and a refined text; in video reasoning it is a partial spatial-temporal scene graph and target tracklets. In each case, the decomposition is operationalized by iterating over these intermediate states rather than jumping directly from input to final answer (Cao et al., 2024, Fan et al., 2023, Briakou et al., 2024, Fei et al., 2024).

Domain	Intermediate state	Stepwise controller
Universal image restoration	Degradation basis and “clean” label	Degradation Discriminator + multi-task restorer
NLU with MLMs	Intermediate step $z \in \mathcal{S}$2 in slot $z \in \mathcal{S}$3	Step I $z \in \mathcal{S}$4, Step II $z \in \mathcal{S}$5
Long-form translation	Research, draft, refined text	Multi-turn research–draft–refine–proofread
Video reasoning	Partial STSG and target tracklets	Five-stage VoT prompt chain

In Chain-of-Restoration, the iterative loop is

$z \in \mathcal{S}$6

and iteration stops when the discriminator outputs the “clean” label. The method assumes that a model trained on isolated degradation bases often removes only one basis per pass, so a composite degradation can be handled by repeated basis-specific restoration (Cao et al., 2024).

In CoTT, the latent-decomposition perspective is explicit: $z \in \mathcal{S}$7 Step I predicts $z \in \mathcal{S}$8 from $z \in \mathcal{S}$9; Step II predicts $z$0 from $z$1 and $z$2. A probability-rectification rule then interpolates between $z$3 and the direct $z$4 according to $z$5. Here decomposition is not merely a prompt style but a factorization of the decision problem itself (Fan et al., 2023).

VoT extends the same idea from text to video by chaining five prompts: target identification, object tracking via partial STSG, action and interaction analysis with commonsense, answer scoring, and answer verification. The STSG for frame $z$6 is $z$7 with object nodes $z$8, so the intermediate states are simultaneously perceptual and symbolic. This suggests that decomposition can bridge pixel-level grounding and cognitive inference only if the intermediate representation preserves both spatial-temporal structure and semantic identity (Fei et al., 2024).

4. Learning and discovering decompositions

One research line learns decompositions from demonstrations or execution traces. Learn2Decompose treats each symbolic trajectory as a sequence of scene graphs, converts each scene graph into connected subgraphs, and uses Sequential Pattern Mining with PrefixSpan and $z$9 to identify frequent subgoal sequences. It then trains a Graph Neural Network to predict object importance for each transition $z$0, thresholds importance at $z$1, and uses those object sets to define reduced subproblems that can be planned independently and often in parallel (Zhang et al., 2024).

A related but more implicit route is Ordered Memory Policy Network. OMPN is a recurrent policy with ordered memory slots whose update dynamics resemble a stack of nested subtasks. When trained only by behavior cloning plus a terminal “done” label, the model’s expansion distribution $z$2 and its expectation $z$3 reveal subtask boundaries. In Craft and Dial, decomposition quality was evaluated by boundary F1 and task alignment accuracy, and OMPN outperformed strong baselines in unsupervised and weakly supervised settings, especially under partial observability (Lu et al., 2021).

In program synthesis, ExeDec uses explicit decomposition traces derived from ground-truth programs: a Subgoal Model predicts next intermediate outputs, and a Synthesizer Model predicts the subprogram for the induced local I/O mapping. REGISM removes the Subgoal Model and repeatedly invokes the Synthesizer with execution feedback only. The comparison shows that decomposition guidance and execution guidance are separable algorithmic ingredients: explicit decomposition helps length generalization and some concept-composition settings, but repeated execution-guided synthesis can match or surpass ExeDec in several DeepCoder conditions and often yields intermediate states closer to ground-truth decompositions (Zenkner et al., 11 Mar 2025).

Other work learns decomposition at the instruction or discourse level rather than from trajectories. Step-by-step instruction tuning augments Super-NaturalInstructions with task-level procedural instructions generated and refined by ChatGPT; these instructions average about 6 steps on train tasks and about 5.4 on test tasks, and shuffling step order largely removes the gains from training with them. Hierarchical script generation likewise encodes decomposition directly in sequence targets through <section> delimiters and subgoal phrases, and reports that decomposing goals into subgoals is harder than summarizing segmented steps into subgoals (Wu et al., 2023, Li et al., 2023).

5. Empirical patterns across domains

A recurring empirical pattern is that explicit decomposition is most useful when the flat alternative faces either combinatorial search or long-horizon coherence problems. In reactive task and motion planning, Learn2Decompose reduces both horizon and active-object count: in Block8, planning time drops from PS: ~192 s to Ours: ~1.65 s, and in Cook5 from PS: ~2.26 s to Ours: ~0.45 s after combining learned subgoals, object reduction, and parallelization (Zhang et al., 2024). In translation, a staged workflow of pre-translation research, drafting, refinement, and proofreading improves WMT24 reference-based MetricX-23 average scores from 3.04 for zero-shot to 2.20 after proofreading, with similar gains in the QE-based metric (Briakou et al., 2024).

Setting	Flat or one-shot regime	Stepwise regime
UIRD-12 translation-free restoration	PromptIR: 24.03 / 0.7904	PromptIR+CoR: 27.83 / 0.8556
WMT24 long-form translation	Zero-shot: 3.04	Proofreading stage: 2.20
Block8 TAMP	PS: ~192 s	Ours: ~1.65 s
Towers of Hanoi, 20 disks	Long chains derail after at most a few hundred steps	$z$4 steps with zero errors

In image restoration, CoR shows that low-order training plus stepwise inference can compete with or exceed end-to-end composite training. On UIRD-12, PromptIR improves from 24.03 / 0.7904 to 27.83 / 0.8556 with CoR, InstructIR from 23.68 / 0.7042 to 28.44 / 0.8726, and OneRestore-1-order from 23.34 / 0.6952 to 27.78 / 0.8607. On CDD-11, HAIR 2-order + CoR reaches 28.33 / 0.8688, outperforming HAIR 3-order at 27.85 / 0.8663, while OneRestore 2-order + CoR reaches 28.84 / 0.8794, comparable to or better than OneRestore 3-order at 28.72 / 0.8821 (Cao et al., 2024).

In language-model control, adaptive decomposition also exhibits a performance-cost structure. Select-Then-Decompose reports that the existing task decomposition approaches are confronted with a performance-cost dilemma, then uses selection, execution, and verification to choose among IO, CoT, Plan-and-Solve, ReAct, Plan-and-Execute, and DAG-based Plan-and-Execute. On GSM8K it reports 93.56% accuracy at 516.57 tokens and 1.28 calls, on MATH 52.39% at 2560.22 tokens and 2.31 calls, and on HumanEval 88.55% at 845.82 tokens and 1.18 calls, while lying on the Pareto frontier across the reported benchmarks (Liu et al., 20 Oct 2025).

At the extreme end of execution length, MAKER shows what maximal decomposition plus local error correction can do. For Towers of Hanoi with 20 disks, the task length is

$z$5

MAKER decomposes the run into one-step subtasks, assigns each to focused microagents, applies voting and red-flagging at each step, and solves the full task with zero errors. The associated analysis argues that maximal agentic decomposition with $z$6 yields expected full-task cost $z$7, whereas larger $z$8 induces an exponential penalty in $z$9 (Meyerson et al., 12 Nov 2025).

6. Limitations, controversies, and trade-offs

A persistent theme is that decomposition is beneficial only under particular interactions between environment structure, task distribution, and the solver that will consume the decomposition. In resource-rational planning, one graph from Solway et al. still elicited “bus stop” judgments from participants, yet the model found that no subgoal helps BFS and returned $X=\{(I_1,O_1),\ldots,(I_n,O_n)\}$0. In program synthesis, explicit subgoals are valuable for length generalization and some concept-composition tasks, but the largest performance jump in DeepCoder is associated with repeated synthesis plus execution, and REGISM often matches or surpasses ExeDec despite having no explicit decomposition module (Correa et al., 2020, Zenkner et al., 11 Mar 2025).

Several domain-specific failure modes recur. CoR requires that the composite test degradation be expressible as a combination of trained degradation bases; otherwise performance degrades sharply. It also suffers from degradation coupling, formally described by the mismatch

$X=\{(I_1,O_1),\ldots,(I_n,O_n)\}$1

which means later restoration steps operate on out-of-distribution residuals. Resource-rational graph models assume known environments, deterministic shortest-path tasks, and fixed planners; Learn2Decompose assumes demonstrations and symbolic scene graphs; OMPN requires a chosen hierarchy depth $X=\{(I_1,O_1),\ldots,(I_n,O_n)\}$2; and hierarchical script generation remains bottlenecked by subgoal discovery rather than by step realization (Cao et al., 2024, Correa et al., 2020, Zhang et al., 2024, Lu et al., 2021, Li et al., 2023).

More recent work therefore emphasizes adaptive rather than uniform decomposition. Select-Then-Decompose argues that task characteristics determine the sequence, calling form, and topology of task decomposition, and that scaling the execution model yields greater performance gains than scaling the decomposition model. ACONIC similarly replaces heuristic splitting with constraint-induced complexity analysis, while MAKER demonstrates that some long-range tasks become tractable only under extreme decomposition plus local error correction (Liu et al., 20 Oct 2025, Zhou et al., 9 Oct 2025, Meyerson et al., 12 Nov 2025). This suggests that the central research question is no longer whether tasks should be decomposed, but which decomposition form is compatible with the planner, the verifier, the intermediate representation, and the cost budget available for the task.