Iterative Skill-Aware Decomposition

• Iterative Skill-Aware Decomposition is a design pattern that breaks complex artifacts into smaller, skill-labeled units for targeted iterative refinement.
• It is applied across domains such as reasoning trace pruning, data-efficient distillation, agent routing, semantic communication, and reinforcement learning.
• Empirical studies report improved efficiency, accuracy, and reduced resource usage by aligning decomposition with task-specific skill awareness.

Iterative Skill-Aware Decomposition (SAD) denotes a family of procedures in which a complex artifact is decomposed into smaller units that carry explicit skill information, and those units are then revised, selected, routed, or recomposed through an iterative or refinement-oriented process. The artifact being decomposed varies by domain: in reasoning-model training it may be a chain-of-thought trace; in data-efficient distillation it may be a corpus indexed by skill deficits; in LLM agents it may be a multi-step plan over a large skill library; in workflow induction it may be a heterogeneous execution trace; in semantic communication it may be a typed semantic representation; and in offline reinforcement learning it may be a task embedded into a latent skill space (Jiang et al., 20 May 2025, Zhang et al., 15 Jan 2026, Gao, 16 Jun 2026, Zhang et al., 5 Jun 2026, Fu et al., 4 May 2026, Yoo et al., 2024, Zhao et al., 23 Feb 2026).

1. Terminological scope and recurrent structure

The literature uses the expression heterogeneously. In some cases, SAD is an explicit component name or algorithmic label. In DRP, the central teacher-side mechanism is Skill-aware Step Decomposition, which segments a student’s raw thinking trace into atomic, semantically coherent steps and labels each step with a functional skill before pruning and rewriting (Jiang et al., 20 May 2025). In SkillWeaver, SAD is an explicit retrieval-augmented feedback loop that re-decomposes a query after retrieving candidate skills from a library (Gao, 16 Jun 2026). In other works, the same phrase functions more as an organizing description of a skill-centric decomposition pattern than as the paper’s native method name, as with skill-based data selection plus skill-aware fine-tuning, reverse-curriculum dataset decomposition, workflow induction from traces, and skill-regularized task decomposition (Zhang et al., 15 Jan 2026, Zhao et al., 23 Feb 2026, Zhang et al., 5 Jun 2026, Yoo et al., 2024).

A recurring property is that decomposition is never purely syntactic. The decomposition units are tied to a notion of capability, concept, function, or runtime affordance: arithmetic operations and logical checks in mathematical reasoning, hierarchical nodes in a skill tree, tool specifications in an MCP skill library, workflow nodes with verification and rollback semantics, typed semantic units in a communication channel, or latent skill codes in reinforcement learning (Jiang et al., 20 May 2025, Zhang et al., 15 Jan 2026, Gao, 16 Jun 2026, Zhang et al., 5 Jun 2026, Fu et al., 4 May 2026, Yoo et al., 2024).

Domain	Decomposed object	Skill-aware mechanism
DRP (Jiang et al., 20 May 2025)	Student thinking trace $T$	Skill-labeled steps with KEEP, DELETE, SINGLE-STEP COMPRESS, MULTI-STEP COMPRESS
Data-efficient reasoning distillation (Zhang et al., 15 Jan 2026)	Teacher-generated 100K math corpus	Per-skill accuracy, inverse-accuracy sampling, explicit hierarchical skill chains
SkillWeaver (Gao, 16 Jun 2026)	User query over a skill library	Retrieve hints, re-decompose into atomic one-skill steps, stop on hint stabilization
W2S/RWSA (Zhang et al., 5 Jun 2026)	Demonstrations, trajectories, tool traces, logs	Segment, align, reconcile, and compress workflow/semantics/attachments

One common misconception is to treat SAD as a single fixed algorithm. The cited works indicate instead that it is a design pattern whose operational meaning depends on what is being decomposed and what “skill awareness” is meant to preserve: reasoning granularity, student weaknesses, tool-library vocabulary, workflow safety constraints, channel robustness, or high-quality behavioral primitives.

2. Formal motifs: decomposition, skill attribution, and refinement

In reasoning-trace pruning, the unit of decomposition is an internal reasoning trajectory. DRP formalizes the student response as $R = (T, A)$, where $T$ is the “thinking” segment between > and ``, and $A$ is the final answer summary. The chain-of-thought is segmented into steps $S = (s_1, s_2, \ldots, s_T)$, and the teacher assigns a skill label $k_i \in K$ to each step via

$$f(s_i; \theta_T) = \arg\max_{k \in K} p_T(k \mid s_i).$$

The decomposition output is $D(T) \to \{(s_1,k_1), \ldots, (s_m,k_m)\}$, after which each step is revised with an action $$a_i \in \{\text{Keep}, \text{Delete}, \text{Rewrite}, \text{Merge}\}$$ (Jiang et al., 20 May 2025).

In data-efficient reasoning distillation, the unit of decomposition is not a token span but a skill-indexed training pool. Each problem is attributed to one or more leaf skills in a hierarchical math skill tree, student accuracy is computed per skill,

$$a_k = \frac{\#\{x \in D_T : k \in K(x) \text{ and } M_\theta \text{ solves } x\}}{\#\{x \in D_T : k \in K(x)\}},$$

and weakness weights are defined as

$R = (T, A)$0

An example then receives score

$R = (T, A)$1

with $R = (T, A)$2 when skill $R = (T, A)$3 is exercised by $R = (T, A)$4. This couples decomposition to student diagnostics rather than to a fixed teacher curriculum (Zhang et al., 15 Jan 2026).

In compositional agent routing, decomposition is explicitly iterative. A vanilla plan $R = (T, A)$5 is first produced; for each sub-task $R = (T, A)$6, a retriever returns top-$R = (T, A)$7 candidate skills from library $R = (T, A)$8; the union of these candidates becomes a hint set $R = (T, A)$9; and the query is re-decomposed using those hints:

$T$0

Stopping is governed by hint-set stabilization through

$T$1

with default $T$2, $T$3, and $T$4 (Gao, 16 Jun 2026).

In reverse-curriculum dataset decomposition, the refinement variable is difficulty. A teacher recursively extracts steps, tags concepts, generates subproblems, verifies them, and recurses to maximum depth $T$5. A concept dependency DAG is built over the induced tags, and each sample is scored by

$T$6

where $T$7 is structural complexity and $T$8 is conceptual depth in the refined concept graph. The decomposition is therefore not only skill-aware but also curriculum-aware (Zhao et al., 23 Feb 2026).

These formulations differ substantially, but they converge on three operations: identify smaller units, attach skill-bearing structure to those units, and use that structure to decide what to preserve, emphasize, revise, or order.

3. Reasoning-trace SAD in distilled reasoning pruning

DRP places SAD inside a teacher–student framework for reducing overthinking in Large Reasoning Models. The teacher segments the student’s raw thinking trace into atomic, semantically coherent steps, labels each step with a functional skill, applies step-level pruning and rewriting, synthesizes a coherent shorter chain-of-thought, and may revise the final answer to maintain consistency. The teacher-time procedure is a single pass per example: decompose into skill-labeled steps, decide an action for each step, resolve merges, synthesize the revised trace, and optionally revise the answer (Jiang et al., 20 May 2025).

The skill taxonomy enumerated in the prompts includes arithmetic addition, subtraction, division, multiplication, interpreting quantities, converting units, simplifying, algebraic representation, apply a formula, checking a condition, comparison, logical inference, and final synthesis and answer consistency. The paper does not learn explicit numerical importance scores or thresholds. Instead, the teacher LLM makes pruning decisions by prompt-guided judgment. A conceptual scoring formalization is given as

$T$9

with retention based on a threshold $A$0, but in implementation both $A$1 and $A$2 remain implicit in the prompt and in the teacher’s Keep/Delete/Compress/Merge heuristics (Jiang et al., 20 May 2025).

A central methodological claim is that stable step boundaries and functional labels make pruning more reliable than sentence-based splitting. In a 50-example pairwise comparison judged by Gemini 2.0 Flash, skill-based decomposition was preferred in 33 cases versus 17 for naive sentence splits. The worked example on the “Joy can read 8 pages in 20 minutes” problem shows how an original verbose derivation is segmented into interpreting quantity, division, and simplifying steps, then compressed into three concise lines while preserving the answer “5 hours” (Jiang et al., 20 May 2025).

The reported gains are both efficiency- and accuracy-oriented. On GSM8K, R1-Distill-Qwen-7B improves from 91.7% to 94.1% while reducing average token usage from 917 to 328. On AIME24, it keeps accuracy at 15/30 while reducing tokens from 8674 to 4966, a 43% reduction. R1-Distill-Qwen-1.5B on GSM8K improves from 70.7% to 83.4% while reducing tokens from 1443 to 721. The ablation on structured pruning versus direct distillation is especially important: direct distillation to short teacher chain-of-thought traces reduces tokens but harms OOD accuracy, with MATH500 dropping from 92.4% to 88.6%, whereas DRP reaches 93.0% at 1781 tokens (Jiang et al., 20 May 2025).

A distinctive feature of this variant is that “iterative” does not mean a multi-round search. The paper explicitly states that it does not use multi-round or beam-search iterations; the only internally iterative aspect is that Multi-Step Compress merges neighboring steps in a single pass. This makes DRP’s SAD a structure-preserving pruning procedure rather than a repeated plan-rewrite loop.

4. Skill-centric data selection and reverse-curriculum training

A second major usage of SAD appears in data-efficient reasoning distillation. Here the core problem is not pruning a single reasoning trace but selecting a small training subset that matches the student’s weak skills, then fine-tuning on examples that explicitly expose an ordered skill chain. The teacher-generated corpus contains 100K curated math QA pairs extracted from OpenMathReasoning, which itself contains 306K unique problems and 3.2M DeepSeek-R1 solutions. The reported pipeline is: skill tree attribution by top-down LLM labeling, skill-based sampling using per-skill student accuracy, and skill-aware SFT in which each selected example is augmented with a chain such as “Skills: [Mathematics → Probability → Bayes’ theorem]” (Zhang et al., 15 Jan 2026).

The main empirical result is that only 1,000 selected examples are sufficient to outperform random 1K SFT baselines across five mathematical reasoning benchmarks. For Qwen3-4B, the average rises from 66.8 with Random 1K + standard SFT to 68.4 with Skill-based 1K + skill-aware SFT; for Qwen3-8B, it rises from 68.1 to 69.5. Full 100K standard SFT underperforms the base model, dropping to 58.1 on Qwen3-4B and 58.5 on Qwen3-8B. The gains concentrate on skills emphasized during training, and the full hierarchical chain is better than only root or only leaf skills, with averages of 72.9, 72.2, and 72.7 respectively in the reported ablation (Zhang et al., 15 Jan 2026).

A related but distinct curriculum-oriented formulation appears in reverse dataset decomposition. Decomp starts from complex examples with chain-of-thought solutions, recursively extracts steps, assigns concept tags, generates easier subproblems grounded in those steps, verifies each subproblem by re-solving without the original context, and recurses up to depth $A$3. It then builds a concept dependency graph, clusters tags by cosine similarity threshold $A$4, computes difficulty by structural complexity and conceptual depth, and trains the student stage-wise over quantile bins ordered from easy to hard (Zhao et al., 23 Feb 2026).

The reported results show that decomposition alone already improves over conventional SFT, and decomposition plus curriculum improves further. On MATH-500 with Qwen2.5-1.5B, SFT on the full dataset reaches 47.6 ± 2.2, while Decomp reaches 50.8 ± 2.2 and Decomp + Curriculum reaches 51.6 ± 2.2. On AIME 2025 with Qwen3-4B-Base trained on AIME 2024, the base model scores 10.0 ± 5.6, Decomp reaches 13.3 ± 6.3, and Decomp + Curriculum reaches 16.7 ± 6.9. On HumanEval, DeepSeek-R1-Distill-Qwen-1.5B improves from 36.01 ± 1.85 to 57.90 ± 0.98 under Decomp (Zhao et al., 23 Feb 2026).

The two lines of work differ in what drives the iteration. Skill-based selection uses measured student weakness but, in the reported experiments, runs only a single iteration. Reverse curriculum uses recursive teacher decomposition and staged training but does not estimate an explicit student competence vector. This distinction matters because it separates adaptive remediation from fixed easy-to-hard scheduling.

5. Agentic planning, routing, and workflow induction

In compositional LLM agents, SAD addresses the mismatch between the language used by an LLM decomposer and the vocabulary actually present in a large skill library. SkillWeaver formalizes Compositional Skill Routing as the problem of mapping a query $A$5 to a decomposition $A$6, a skill assignment $A$7, and a dependency-aware DAG $A$8. The central claim is that decomposition quality is the primary bottleneck: vanilla decomposition yields only 34.2% CatR@1 and 51.0% strict Decomposition Accuracy. SAD closes this vocabulary and granularity gap by retrieving candidate skills for the first-pass sub-tasks and feeding those skill names and descriptions back into the decomposer as hints (Gao, 16 Jun 2026).

The system uses an off-the-shelf all-MiniLM-L6-v2 bi-encoder with L2-normalized 384-d embeddings and a FAISS IndexFlatIP over 2,209 real MCP server skills spanning 24 functional categories. CompSkillBench contains 300 compositional queries at Easy, Medium, and Hard difficulty levels. With one SAD iteration, strict DA improves from 51.0% to 67.7%, a +32.7% relative gain with Wilcoxon $A$9; unconditional CatR@1 rises from 34.2% to 37.0%; and when conditioned on DA = 1, CatR@1 reaches 41.2%. The paper also reports that exposing all 2,209 skills would cost about 884k tokens, whereas SkillWeaver/SAD typically exposes only about 2.9 skills to the executor, roughly 1,160 tokens, a context reduction of about 99.9% at execution time (Gao, 16 Jun 2026).

A more workflow-oriented variant appears in automatic skill construction from traces. W2S treats demonstrations, agent trajectories, tool traces, and execution logs as evidence for building an executable skill representation $S = (s_1, s_2, \ldots, s_T)$0, where $S = (s_1, s_2, \ldots, s_T)$1 is a routing header, $S = (s_1, s_2, \ldots, s_T)$2 is the workflow backbone, $S = (s_1, s_2, \ldots, s_T)$3 assigns node-level execution semantics, and $S = (s_1, s_2, \ldots, s_T)$4 provides runtime attachments such as tool affordances, validation schemas, and state operations. The pipeline segments traces, induces local skill drafts, aligns shared structures across scenarios, reconciles branches and loops, and compresses redundancy while preserving verification, safety, rollback, and state-management behaviors (Zhang et al., 5 Jun 2026).

The evaluation on 70 reference skills uses replay-based behavioral fidelity through

$S = (s_1, s_2, \ldots, s_T)$5

W2S reaches 0.503 versus 0.455 for the Anthropic Skill Creator baseline, a +0.048 absolute improvement, approximately 10.5% relative. The T5 type is the reported exception, where ASC scores 0.550 and W2S 0.480, reflecting the difficulty of attachment-heavy workflows without strong semantic guidance (Zhang et al., 5 Jun 2026).

These agentic formulations broaden the meaning of “skill awareness.” It no longer refers only to concept labels inside a reasoning trace. It also refers to alignment with a concrete external skill inventory, I/O compatibility, dependency structure, validation hooks, approval gates, and rollback semantics.

6. Typed-unit and latent-skill variants beyond reasoning

SkillCom applies the same decomposition logic to semantic communication. Instead of sending one monolithic compressed text block, it decomposes the end-to-end system into four explicit skills: semantic abstraction, channel-adaptive transmission, receiver-side repair, and task execution. The interface is a set of typed semantic units

$S = (s_1, s_2, \ldots, s_T)$6

where $S = (s_1, s_2, \ldots, s_T)$7 is semantic payload, $S = (s_1, s_2, \ldots, s_T)$8 is a unit type, $S = (s_1, s_2, \ldots, s_T)$9 is task relevance, $k_i \in K$0 is source importance, $k_i \in K$1 is channel robustness score, and $k_i \in K$2 is token cost. Transmission selects units by

$k_i \in K$3

under budgets on unit count, token cost, and payload length. The experiments implement a single-shot pipeline, but the paper explicitly states that the same design naturally supports iterative operation in which units are progressively selected, transmitted, repaired, and executed until confidence or budget criteria are met (Fu et al., 4 May 2026).

The reported empirical results are task- and channel-dependent. At SNR = 7 dB on HotpotQA, the monolithic baseline reaches EM 0.42 and F1 0.51, whereas SkillCom-Struct+Dedup reaches EM 0.56 and F1 0.68. On MultiWOZ, the monolithic baseline reaches JGA 0.02 and Slot F1 0.03, whereas SkillCom-Enrich reaches JGA 0.08 and Slot F1 0.42. The SNR sweep from 4–14 dB shows that SkillCom variants degrade more gracefully than the monolithic baseline; at SNR = 4 dB, the monolithic utility approaches zero while SkillCom retains meaningful performance (Fu et al., 4 May 2026).

In multi-task offline reinforcement learning, the relevant decomposition is into latent skills and latent task/subtask codes learned from heterogeneous offline datasets. Skill Regularized Task Decomposition, mapped here to SAD, uses two Wasserstein auto-encoders sharing latent space $k_i \in K$4: one for skills, one for tasks. The crucial alignment term is

$k_i \in K$5

and the full objective is

$k_i \in K$6

The iteration then consists of decomposition, dataset augmentation with imaginary trajectories, offline RL training in the latent space, and refinement (Yoo et al., 2024).

The performance gains are reported on Meta-World MT10 and AirSim-based multi-task drone navigation. SAD outperforms TD3+BC, PCGrad, and SoftMod across mixed-quality MT10 settings, with gains over SoftMod of 8.67%–17.67% absolute success rate. Adding Imaginary Demonstrations yields about 2.97% further improvement on average in MT10. On drone tasks, SAD+ID improves over SoftMod by 5.01%–11.37% absolute in normalized return (Yoo et al., 2024).

These non-reasoning variants show that SAD need not operate on language-only step decompositions. Typed units in communication systems and latent codes in control systems instantiate the same high-level idea: decompose a coupled process into skill-bearing components, then allocate budget or learning pressure at the component level.

7. Limitations, failure modes, and unresolved questions

The major failure mode across reasoning-trace variants is destructive compression. DRP notes that aggressive deletion can remove essential derivations, and that skill labels are heuristic because they are produced by an LLM via prompting rather than by a learned calibrated classifier. The external preference result of 33 out of 50 examples is evidence of benefit, not a guarantee of correctness (Jiang et al., 20 May 2025).

Skill-centric data selection introduces a different fragility: the skill tree itself may be misaligned with the student’s latent decomposition, and per-skill accuracy estimates can be noisy for infrequent skills. The paper explicitly identifies reliance on a predefined skill tree and noisy weakness estimates as limitations, and notes that calibration or uncertainty modeling could improve robustness (Zhang et al., 15 Jan 2026). Reverse-curriculum decomposition shares related issues: the teacher may hallucinate during subproblem generation or mis-tag concepts, structural complexity and conceptual depth are only proxies for difficulty, and excessive decomposition can fragment global reasoning patterns (Zhao et al., 23 Feb 2026).

In agentic routing, the residual gap between retrieval at rank 1 and rank 10 remains substantial. SkillWeaver reports a remaining @1 versus @10 gap of roughly 40% versus roughly 70%, heuristic compatibility scoring, no cross-encoder reranking in the main pipeline, and two-pass latency (Gao, 16 Jun 2026). In trace-to-skill induction, attachment-heavy workflows remain difficult; W2S identifies T5 as the exception case, and the paper notes under-specified low-frequency edges, conflicting evidence, and the absence of formal correctness guarantees such as temporal-logic enforcement (Zhang et al., 5 Jun 2026).

In semantic communication, the decomposition is only as good as the unit schema and channel estimates. SkillCom requires a well-designed type set, known or estimated SNR, and task-specific tuning because deduplication can hurt recall-heavy tasks such as dialogue state tracking; modularization also increases LLM calls (Fu et al., 4 May 2026). In offline RL, latent-skill decomposition depends on sufficient skill coverage in the offline data, while imaginary trajectories can amplify model bias when rollouts are long or quality estimates are noisy (Yoo et al., 2024).

A plausible implication is that the hardest part of SAD is not decomposition in isolation but calibration of decomposition granularity to the operative constraint: student capacity in reasoning distillation, taxonomy fidelity in skill-based sampling, library vocabulary in agent routing, attachment semantics in workflow induction, channel impairment in semantic communication, or dataset quality in offline RL. The surveyed literature repeatedly points to the same trade-off: decomposition is useful when it preserves the structure required by the downstream learner or executor, and harmful when it replaces that structure with an overcompressed, mismatched, or misattributed surrogate.