Structured Skill Composition

• Structured Skill Composition is a framework that explicitly organizes reusable skills through defined interfaces and modular representations.
• It employs diverse mechanisms such as recursive embeddings, graph-based orchestration, and parameter-space merging to combine capabilities effectively.
• Empirical results indicate enhanced generalization, safety, and auditability across domains like robotics, language processing, and multi-agent systems.

Structured skill composition denotes a family of methods that make the combination of reusable skills explicit rather than leaving it implicit in a monolithic policy, prompt, or retrieved text block. In the surveyed literature, the composed objects range from policy embeddings and language skills to LoRA modules, graph nodes, scene-graph-conditioned robot primitives, and reward-evaluation procedures. The common aim is to solve new tasks by organizing previously available capabilities through typed interfaces, dependency structure, factorization, or evidence-bearing intermediate representations rather than by relearning each task from scratch (Sahni et al., 2017, Chen et al., 2023, Liu et al., 9 Feb 2025, Xia et al., 20 Apr 2026, Chen et al., 2 Jun 2026, Knauer et al., 6 Jun 2026).

1. Definitions and scope

The term skill is used heterogeneously across the literature, and the meaning of composition depends on that choice. In ComposeNet, a skill is a policy module represented by a skill-state embedding, and composition is a trainable map

$$C:\langle \iota_e^{(1)}(S),\iota_e^{(2)}(S),\ldots,\iota_e^{(n)}(S)\rangle \to \iota_c(S),$$

so the output of composition remains in the same embedding space and can be recursively reused (Sahni et al., 2017). In Skills-in-Context prompting and in SKILL-MIX-style fine-tuning, skills are named language capabilities such as rhetorical, literary, reasoning, or theory-of-mind constraints, and composition means producing a single coherent text that simultaneously satisfies a requested set of skills (Chen et al., 2023, Zhao et al., 2024). In PSEC, a skill primitive is a LoRA update $\Delta W_i=B_iA_i$ attached to a frozen base policy, so composition occurs directly in parameter space (Liu et al., 9 Feb 2025). In CLASP, a skill is the pair $(\mathcal{O},\phi)$, where $\mathcal{O}$ is a TP-KMP and $\phi$ is a VLM-generated schema (Knauer et al., 6 Jun 2026).

Agent papers make the interface even more explicit. SkillComposer defines a skill as

$s_i=(m_i,C_i,\pi_i,T_i,R_i),$

with metadata, applicability condition, procedural policy, termination condition, and optional callable interface or support resource; composition is then the prediction of an ordered skill sequence over a fixed library (Zhao et al., 30 Jun 2026). Skill-RM adopts the abstract form $S=(M,U)$ and specializes it to a Reward-Evaluation Skill

$$\mathcal{S}_{\mathrm{RM}}=(\mathcal{M}_{\mathrm{RM}},\mathcal{U}_{\mathrm{RM}}),$$

where composition concerns evaluative resources such as rubrics, references, checklists, verifiers, and calibration rules rather than task-execution policies (Chen et al., 2 Jun 2026).

This variation implies that structured skill composition is not a single architecture class. In the surveyed work, it includes latent neural composition, in-context decomposition, graph-structured orchestration, parameter-space merging, factor-wise latent control, trajectory-level probabilistic fusion, and even composition specialized to evaluation or safety analysis. A plausible implication is that the field is best understood through the structure imposed on the composition process—shared latent interfaces, typed graphs, factorized variables, task-parameterized frames, or evidence objects—rather than through any single definition of “skill.”

2. Representational forms

The literature differs chiefly in what it chooses as the compositional unit and what explicit structure it places around that unit.

Work	Skill unit	Explicit structure
"Learning to Compose Skills" (Sahni et al., 2017)	Skill-state embedding	Binary recursive composition in a shared latent space
"Skills-in-Context Prompting" (Chen et al., 2023) and "Can Models Learn Skill Composition from Examples?" (Zhao et al., 2024)	Named language skills	Skill block plus compositional exemplars; synthetic multi-skill examples
"Skill Expansion and Composition in Parameter Space" (Liu et al., 9 Feb 2025) and "SUSD" (Hosseini et al., 2 Feb 2026)	LoRA modules or factor-wise latent skills	Weighted parameter merging; factorized skill space $\mathcal{Z}_1\times\dots\times\mathcal{Z}_N$
"GraSP" (Xia et al., 20 Apr 2026), "SkillGraph" (Li et al., 12 May 2026), and "Generative Skill Composition for LLM Agents" (Zhao et al., 30 Jun 2026)	Reusable agent skills	Typed DAGs, evolving directed skill graphs, or closed-vocabulary ordered skill sequences
"Compose by Focus" (Qi et al., 19 Sep 2025), "BrickCraft" (Yu et al., 8 May 2026), and "CLASP" (Knauer et al., 6 Jun 2026)	Robot manipulation skills	Focused scene graphs, relation-parameterized assembly plans, and TP-KMP skill schemas
"Skill-RM" (Chen et al., 2 Jun 2026) and "From Skill Text to Skill Structure" (Liang et al., 27 Apr 2026)	Evaluative or documentary skills	Evidence-bearing judgments and Scheduling-Structural-Logical skill structure

These representations solve different bottlenecks. Shared latent spaces support recursive closure; prompt-grounded named skills support interpretable reasoning traces; graphs expose dependency and repair structure; factorization exposes controllable subspaces; task-parameterized frames expose geometric invariants; and evidence-bearing or source-grounded structures expose auditability. This suggests that “structure” functions as an externalization device: knowledge that would otherwise remain buried in weights or prose is lifted into objects that can be routed, checked, fused, or inspected.

3. Composition mechanisms

The mechanisms used to compose skills are correspondingly diverse. ComposeNet trains a differentiable composition function over pretrained skill embeddings and reuses the shared policy layer to decode both primitive and composed behaviors; because the composed embedding has the same type as a primitive embedding, the method supports recursive hierarchies such as $(\neg g \wedge \neg b)\,\mathcal{U}\,r$ and $\Delta W_i=B_iA_i$0 (Sahni et al., 2017). SKiC composes by placing a basic-skill block and a compositional exemplar block in the same prompt context, while the SKILL-MIX follow-up paper induces a “meta-skill” by fine-tuning on curated $\Delta W_i=B_iA_i$1 compositions and testing on higher-order or held-out-skill compositions (Chen et al., 2023, Zhao et al., 2024). Countdown analysis represents solutions as expression trees, treats subtrees as reusable skills, and studies RL post-training as the acquisition of structure-sensitive subtree reuse rather than mere length extension (Park et al., 1 Dec 2025).

Agent systems increasingly formulate composition as an explicit structured prediction problem. SkillComposer predicts

$\Delta W_i=B_iA_i$2

so subset, count, and order emerge jointly from a constrained autoregressive decoder over skill identifiers (Zhao et al., 30 Jun 2026). GraSP inserts a compilation layer between retrieval and execution, producing an executable typed DAG

$\Delta W_i=B_iA_i$3

and then performs node-level verification and locality-bounded repair through Rebind, InsertPrereq, Substitute, Rewire, and Bypass (Xia et al., 20 Apr 2026). SkillGraph instead maintains an evolving directed graph with prerequisite, enhancement, and co-occurrence edges, retrieves a task-conditioned subgraph, and topologically sorts it to guide execution (Li et al., 12 May 2026).

Parameter-space and factorized methods push composition into the policy representation itself. PSEC merges LoRA skill modules through

$\Delta W_i=B_iA_i$4

with $\Delta W_i=B_iA_i$5 acting as a context-aware routing module (Liu et al., 9 Feb 2025). SUSD factorizes both state and skill space,

$\Delta W_i=B_iA_i$6

and trains a single low-level policy $\Delta W_i=B_iA_i$7 on concatenated factor-wise latents, making composition a property of the representation rather than a separate symbolic operator (Hosseini et al., 2 Feb 2026).

Robotics papers emphasize compositional execution under geometric or relational structure. Compose by Focus builds a focused sub-scene graph over task-relevant objects and relations, encodes it with a two-layer GAT, and conditions a diffusion policy on the resulting graph embedding and skill-language description (Qi et al., 19 Sep 2025). BrickCraft reduces assembly to a sequence of relative operations $\Delta W_i=B_iA_i$8 and chains pick and assembly skills under explicit preconditions and postconditions (Yu et al., 8 May 2026). CLASP composes two selected local KMPs by covariance-weighted Gaussian fusion and requires temporal dominance regions satisfying the compatibility condition in Eq. (1), so fusion is allowed only when one primitive is clearly more certain than the other in each region (Knauer et al., 6 Jun 2026).

The same pattern appears in task synthesis and reward evaluation. EvoTD defines a skill crossover operator

$\Delta W_i=B_iA_i$9

to generate tasks with novel skill combinations and pairs it with parametric mutation over complexity attributes and a dynamic ZPD filter (Ye et al., 12 May 2026). Skill-RM executes a reward-evaluation trace

$(\mathcal{O},\phi)$0

and reads out reward deterministically from the completed evidence-bearing judgment rather than from a raw scalar head (Chen et al., 2 Jun 2026).

4. Empirical patterns across domains

Prompt-based and example-based studies show that explicit composition structure can materially improve systematic generalization. In SKiC, with only two compositional exemplars, text-davinci-003 reached 98.5 on 7-digit addition, ChatGPT reached 100.0 on the same setting, ChatGPT reached 92.0 on dynamic-programming length 8, and GPT-4 reached 98.0 on that dynamic-programming setting; on MATH, SKiC raised GPT-4 from 50.3 with ComplexCoT to 56.4 (Chen et al., 2023). In the SKILL-MIX-style fine-tuning study, D1-only training improved single-skill competence but not composition, whereas D2 and D3 training improved unseen higher-order composition and transfer to held-out skill groups; after D1∪D2∪D3 fine-tuning on held-out skills/topics, Mistral-7B achieved Ratio of Full Marks $(\mathcal{O},\phi)$1 for $(\mathcal{O},\phi)$2 respectively (Zhao et al., 2024). Countdown RL showed out-of-distribution generalization to larger $(\mathcal{O},\phi)$3 and to unseen tree shapes, together with a stable structure-dependent hierarchy in which balanced trees are learned before left-heavy trees, and right-heavy trees remain hardest (Park et al., 1 Dec 2025).

In sequential decision-making and agent orchestration, explicit structure also improves practical performance. GraSP outperforms ReAct, Reflexion, ExpeL, and flat skill baselines in every reported configuration, improving reward by up to +19 points and reducing environment steps by up to 41% (Xia et al., 20 Apr 2026). SkillGraph achieves 90.6 overall success on ALFWorld and 84.4 WebShop success rate, with especially strong gains on strict-order subtasks such as Clean and Heat (Li et al., 12 May 2026). SkillComposer reaches 45.3% pass rate on GPT-5.2-Codex and 44.0% on Gemini-3-Pro, improving over the no-skill baseline by +23.1 pp and +18.2 pp and surpassing top-3 retrieval while using fewer prompt tokens (Zhao et al., 30 Jun 2026). In reward modeling, Skill-RM raises Qwen3.5-27B average benchmark performance from 83.9 for direct LLM-as-a-Judge to 86.2, and to 89.1 when sample-specific resources are mounted through the skill (Chen et al., 2 Jun 2026).

Robotics results show a similar divide between isolated skill competence and compositional robustness. Compose by Focus reports near-perfect single-skill performance for several baselines but a much larger gap under composition; for example, on real-world vegetable picking the Scene Graph method reaches 0.97 while Diffusion Policy scores 0.0, DP3 0.2, and $(\mathcal{O},\phi)$4 0.05 (Qi et al., 19 Sep 2025). BrickCraft reports 86.25% overall success across 240 single-step assembly trials and substantial completion on an entirely unseen Castle structure in long-horizon evaluation (Yu et al., 8 May 2026). CLASP achieves 100% (16/16) success when composing existing learned skills and 73.3% (11/15) after active acquisition and composition of grasp and insert, with the four failures concentrated in the $(\mathcal{O},\phi)$5 rotated measurement-station setting (Knauer et al., 6 Jun 2026).

These results support a recurring pattern: explicit composition structure tends to matter most when the task requires nontrivial dependency management, conflict resolution, or generalization beyond directly observed combinations. The literature also repeatedly shows that simply exposing more skills or more context is not equivalent to structured orchestration.

5. Auditability, evaluation, and safety

A distinctive branch of the literature treats composition itself as something to be audited. Skill-RM reifies reward evaluation as a structured judgment

$(\mathcal{O},\phi)$6

so criterion-level evidence can be inspected before the final reward readout (Chen et al., 2 Jun 2026). SSL performs a related externalization for skill artifacts through a three-layer representation $(\mathcal{O},\phi)$7, improving Skill Discovery MRR from 0.573 to 0.707 and Risk Assessment macro F1 from 0.744 to 0.787 (Liang et al., 27 Apr 2026). Both works argue, in different settings, that source-grounded structure makes skills easier for machines to search, review, and operationalize.

Safety-oriented work shows that composition can introduce risks absent from isolated skills. SkillFuzz models a marketplace composition as an activation vector $(\mathcal{O},\phi)$8, extracts contracts

$(\mathcal{O},\phi)$9

and uses contract-guided MCTS to search for implicit intents. It reports over 1,000 distinct implicit intents, confirms 80.6% of the highest-risk flagged compositions during execution-time validation, and on the detailed strategy study finds 90 high-severity implicit intents for SkillFuzz versus 64 for Random while covering only 39.7% of pairwise interactions (Hu et al., 2 Jul 2026).

Multimodal evaluation studies further show that having constituent skills is not sufficient for reliable end-to-end composition. In the cross-modality benchmark, the composition gap is defined as the performance difference between cascaded and direct inference. Llama 3.2 11B improves from 55.40 to 74.46 on reasoning over rendered text and from 27.95 to 50.90 on card playing when composition is manually enforced in two stages, while Qwen2.5-VL-72B shows a much smaller gap on some tasks (Ontalvilla et al., 11 Nov 2025). This supports a narrower but important point: explicit composition procedures can outperform direct inference even when the same model performs both constituent subtasks.

6. Limitations and open problems

The surveyed literature is also clear about its constraints. ComposeNet assumes that the correct primitive skills for the task are provided and that the form of the composition is known (Sahni et al., 2017). SUSD assumes a meaningful state factorization is given rather than learned and is sensitive to under-factorization and over-factorization (Hosseini et al., 2 Feb 2026). GraSP notes that a DAG does not naturally represent cyclic or iterative procedures, and SkillGraph depends on a strong teacher model, known task types, and prompt-based execution rather than a learned graph encoder (Xia et al., 20 Apr 2026, Li et al., 12 May 2026). Skill-RM explicitly states that skill construction is an LLM-assisted curation process and “does not introduce an automatic skill-learning algorithm,” while also incurring higher inference cost than single-pass scalar models (Chen et al., 2 Jun 2026).

Robotics systems face their own boundaries. CLASP validates only pairwise compositions, depends on accurate object pose estimation, and assumes a relatively static scene (Knauer et al., 6 Jun 2026). Compose by Focus relies on Grounded-SAM and VLM-based relation inference, which adds computation overhead and couples performance to segmentation quality (Qi et al., 19 Sep 2025). BrickCraft currently lacks strong autonomous failure recovery and remains restricted to a narrow brick family and known CAD models (Yu et al., 8 May 2026). In multimodal reasoning, the cross-modality study shows that even simple two-stage compositions remain fragile, and composition-specific CoT or fine-tuning improves but does not fully close the gap (Ontalvilla et al., 11 Nov 2025).

Several open problems recur across papers. EvoTD keeps static skill and complexity taxonomies after extraction and remains tied to verifiable domains (Ye et al., 12 May 2026). SkillFuzz depends on contract extraction quality and planner observability, and it analyzes declared intent rather than guaranteed runtime behavior (Hu et al., 2 Jul 2026). SSL is presented as a practical intermediate representation rather than a finished standard or an end-to-end mechanism for skill use, and the paper explicitly leaves actual planning-time composition to future work (Liang et al., 27 Apr 2026). This suggests that the next stage of the field will require tighter integration between explicit skill structure, automated skill induction, runtime verification, and adaptive composition under uncertainty, rather than simply larger skill libraries or longer prompts.