SkillComposer: Modular Skill Composition

• SkillComposer is a family of frameworks that modularly composes discrete skills—ranging from simple policies to procedural language instructions—to build complex behaviors.
• The architectures employ diverse methods such as differentiable policy composition, sequential expert linking, autoregressive plan generation, and skill evolution through Create, Improve, and Merge operations.
• Empirical evaluations across gridworld tasks, quadruped transitions, and coding agents demonstrate enhanced learning efficiency, robustness, and effective reuse of modular skills.

SkillComposer denotes a family of skill-composition frameworks rather than a single canonical architecture. Across the literature, the name is used for differentiable composition of reinforcement-learning policies, for reusable transition controllers that connect robot motion experts, for constrained sequence models that generate executable plans over skill libraries, and for language-model systems that iteratively create, improve, and merge skills at inference time (Sahni et al., 2017, Christmann et al., 2024, Zhao et al., 30 Jun 2026, Zhang et al., 4 Jun 2026). The unifying premise is that complex behavior can be built from modular skill units, but the technical meaning of both skill and composition varies substantially by domain.

1. Semantic scope and representational variants

In the cited literature, a skill may be a simple policy trained in isolation to achieve a single subgoal, a low-level motion controller trained by motion imitation, a modular package of procedural knowledge loaded at inference time, or a natural-language procedure represented as a triple of name, description, and body (Sahni et al., 2017, Christmann et al., 2024, Zhao et al., 30 Jun 2026, Zhang et al., 4 Jun 2026). Accordingly, composition may occur at the level of latent embeddings, expert-to-expert transitions, autoregressive plan generation over a closed skill vocabulary, or library evolution through generalized rewriting operations.

Framework	Skill representation	Composition mechanism
ComposeNet	Skill trunk + shared policy decoder	Fully connected layer over concatenated embeddings
Expert Composer Policy	Motion-imitation expert controller	Transition policy to sampled target state
Generative SkillComposer	$(m_i, C_i, \pi_i, T_i, R_i)$ skill package	Constrained autoregressive decoding over skill IDs
SkillComposer for evolution	$(name, description, body)$ textual skill	Create, Improve, Merge operations

This heterogeneity is not merely terminological. In ComposeNet, composition outputs a single policy that simultaneously respects multiple subgoals. In the quadruped setting, composition means sequentially chaining experts while preserving original motion quality. In the LLM-agent setting, one line of work treats composition as structured plan prediction, whereas another treats it as explicit skill construction under specification–generalization tradeoffs. A plausible implication is that “SkillComposer” functions less as a fixed model family than as a design pattern for modular capability reuse.

2. Differentiable policy composition in ComposeNet

"Learning to Compose Skills" formalizes skill composition in deep RL through skill-state embeddings and a shared policy decoder (Sahni et al., 2017). Each base skill has its own trunk network, producing an embedding $z_i(s)=\phi_i(s)=\iota_e^{(i)}(s)$, while a single shared policy layer maps any embedding to an action distribution, $\pi_k:\iota_e^{(k)}(S)\to p(A)$. A composition function

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

aggregates the relevant skill embeddings, and the composed policy is

$\pi_C(a\mid s)=\pi(\iota_c(s)).$

In practice, embeddings are concatenated and passed through a fully connected composition layer whose output has the same dimensionality as the skill embeddings.

The experimental setting is a Pacman-like gridworld. The agent observes a $15\times15$ grayscale image, collectible objects are stationary, enemies chase the agent along the shortest path, the agent teleports across borders, and objects do not. The six base skills are collect-red, collect-green, collect-blue, evade-red, evade-green, and evade-blue. Composed tasks are specified with LTL operators, including “collect $q$ while evading $p$” $(\neg p\ U\ q)$, “collect $(name, description, body)$0 or $(name, description, body)$1” $(name, description, body)$2, “always evade $(name, description, body)$3 and $(name, description, body)$4” $(name, description, body)$5, and “collect $(name, description, body)$6 then $(name, description, body)$7” $(name, description, body)$8. For composed tasks, the environment does not provide subgoal-completion signals; reward is only issued when the full composed task is complete.

Training is split into two phases. First, all skill trunks and the shared policy layer are trained jointly with A3C on skill-specific rewards until convergence. Second, the trunks and shared policy are frozen, and only the composition layer is trained on the composed task, with gradients flowing through the frozen decoder into the composition module. This preserves end-to-end differentiability while preventing interference with the reusable skill library. Recursive composition is also supported: composed embeddings can themselves be inputs to further composition layers, yielding hierarchical trees or DAGs over skills.

Empirically, the architecture achieves faster near-optimal behavior than training from scratch or meta-controller baselines across “while,” “or,” “and,” and “then” compositions. Reported zero-shot results include reward $(name, description, body)$9 for “collect blue while evade green” $z_i(s)=\phi_i(s)=\iota_e^{(i)}(s)$0, reward $z_i(s)=\phi_i(s)=\iota_e^{(i)}(s)$1 for “collect red or blue” $z_i(s)=\phi_i(s)=\iota_e^{(i)}(s)$2, episode length $z_i(s)=\phi_i(s)=\iota_e^{(i)}(s)$3 for “evade red and green” $z_i(s)=\phi_i(s)=\iota_e^{(i)}(s)$4, and reward $z_i(s)=\phi_i(s)=\iota_e^{(i)}(s)$5 for “collect red then green” $z_i(s)=\phi_i(s)=\iota_e^{(i)}(s)$6. Hierarchical cases are harder: $z_i(s)=\phi_i(s)=\iota_e^{(i)}(s)$7 has zero-shot reward $z_i(s)=\phi_i(s)=\iota_e^{(i)}(s)$8, though fine-tuning is reported to recover a high-reward policy quickly. Ablations show that correct skill selection matters; irrelevant skills lead to no learning, and single-trunk alternatives perform markedly worse on tasks requiring simultaneous or temporally ordered constraints. The principal limitations are sparse rewards on composed tasks, dependence on the correct skill set and LTL operator, and degraded zero-shot efficacy under larger distribution shift or highly conflicting skill conjunctions.

3. Sequential skill linking in quadruped robotics

"Expert Composer Policy: Scalable Skill Repertoire for Quadruped Robots" uses the term in a distinct sense: a single transition controller composes experts sequentially by driving the robot from the current expert’s state to a sampled target state of the next expert (Christmann et al., 2024). Each expert is a low-level motion controller $z_i(s)=\phi_i(s)=\iota_e^{(i)}(s)$9 trained by motion imitation, while the composer policy $\pi_k:\iota_e^{(k)}(S)\to p(A)$0 outputs 12 PD target joint angles on the Unitree A1. Composition is therefore not latent aggregation but controlled handoff.

The transition episode is an MDP whose state space matches the experts’ proprioceptive state space, augmented for the composer with the target state $\pi_k:\iota_e^{(k)}(S)\to p(A)$1, the current center-path state, short history, and normalized time. The central trajectory is

$\pi_k:\iota_e^{(k)}(S)\to p(A)$2

and the per-component tolerance bounds shrink as

$\pi_k:\iota_e^{(k)}(S)\to p(A)$3

A piecewise tolerance indicator $\pi_k:\iota_e^{(k)}(S)\to p(A)$4 gives reward $\pi_k:\iota_e^{(k)}(S)\to p(A)$5 on success, $\pi_k:\iota_e^{(k)}(S)\to p(A)$6 if the state violates the shrinking bound around the center path, and $\pi_k:\iota_e^{(k)}(S)\to p(A)$7 otherwise. The composer reward is

$\pi_k:\iota_e^{(k)}(S)\to p(A)$8

Training uses episodic on-policy RL with PPO-clip, and deployment proceeds by sampling a target state from the next expert and running the composer until the final tolerance is met or the episode times out.

Two target-sampling strategies are defined. Random phases sample uniformly from the target expert’s motion phases, whereas optimal phases sample uniformly from empirically selected phase intervals with success at least $\pi_k:\iota_e^{(k)}(S)\to p(A)$9. The composer is trained independently of the experts: it never observes expert outputs and is not conditioned on expert identifiers, which permits incremental repertoire expansion without retraining the composer or existing experts. The reported observation vector is 208-dimensional, and the composer network is an MLP with hidden sizes 512 and 256, ELU activations, and a linear output head.

The principal empirical claim is reliability at scale. The study evaluates 72 ordered transition pairs among 9 experts, with 50,000 simulation episodes per pair. The Composer Policy with optimal target-phase sampling attains approximately $$C:\langle \iota_e^{(1)}(S),\iota_e^{(2)}(S),\ldots,\iota_e^{(n)}(S)\rangle \to \iota_c(S)$$0 average success across the 72 pairs, and hardware transfer yields 350 successful transitions out of 360, i.e. $$C:\langle \iota_e^{(1)}(S),\iota_e^{(2)}(S),\ldots,\iota_e^{(n)}(S)\rangle \to \iota_c(S)$$1, on a Unitree A1. Baselines include Random Switch, Linear Interpolation, Mixture-of-Experts gating, Transition Motion Tensor, and Target State Proximity; the composer outperforms them while avoiding action mixing and preserving expert motion quality. The reported limitations are dependence on accessible target-state distributions, sensitivity to target-phase choice, and the requirement that expert and composer state distributions overlap around feasible transition states.

4. Structured skill-plan generation for LLM agents

The 2026 paper "Generative Skill Composition for LLM Agents" uses SkillComposer for structured prediction over a fixed skill library (Zhao et al., 30 Jun 2026). A skill is formalized as

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

where $$C:\langle \iota_e^{(1)}(S),\iota_e^{(2)}(S),\ldots,\iota_e^{(n)}(S)\rangle \to \iota_c(S)$$3 is metadata, $$C:\langle \iota_e^{(1)}(S),\iota_e^{(2)}(S),\ldots,\iota_e^{(n)}(S)\rangle \to \iota_c(S)$$4 an applicability condition, $$C:\langle \iota_e^{(1)}(S),\iota_e^{(2)}(S),\ldots,\iota_e^{(n)}(S)\rangle \to \iota_c(S)$$5 a procedural policy, $$C:\langle \iota_e^{(1)}(S),\iota_e^{(2)}(S),\ldots,\iota_e^{(n)}(S)\rangle \to \iota_c(S)$$6 a termination condition, and $$C:\langle \iota_e^{(1)}(S),\iota_e^{(2)}(S),\ldots,\iota_e^{(n)}(S)\rangle \to \iota_c(S)$$7 an optional callable interface or supporting resource. The core claim is that composition is a joint decision over subset, count, and order, so it should be modeled as task-conditioned generation of a variable-length skill sequence rather than as flat retrieval.

A plan is an ordered sequence $$C:\langle \iota_e^{(1)}(S),\iota_e^{(2)}(S),\ldots,\iota_e^{(n)}(S)\rangle \to \iota_c(S)$$8 over the closed vocabulary of skill identifiers and a STOP token, with factorization

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

Training minimizes the autoregressive loss

$\pi_C(a\mid s)=\pi(\iota_c(s)).$0

augmented by a set-membership head and a cardinality head. The architecture consists of a frozen task encoder, instantiated as Qwen3-Embedding-0.6B with last-token pooling and projection to $\pi_C(a\mid s)=\pi(\iota_c(s)).$1, a projected skill-memory embedding for each skill, and a 3-layer transformer decoder with hidden size 256, 4 heads, dropout 0.1, and cross-attention over the skill memory. Output vocabulary is $\pi_C(a\mid s)=\pi(\iota_c(s)).$2, with $\pi_C(a\mid s)=\pi(\iota_c(s)).$3 in the reported library.

Decoding uses masked softmax over valid skill identifiers, typically enforcing library membership and a no-duplicate policy. It also fuses three signals at each step: the decoder’s autoregressive logit, a TF–IDF cosine task–skill prior, and the set-membership prior. The fused logit is

$\pi_C(a\mid s)=\pi(\iota_c(s)).$4

STOP is not boosted by these priors; it is governed by the autoregressive STOP head and may be biased using the predicted cardinality. Reported decoding settings are beam width 4, length penalty 0.7, temperature 0, and maximum plan length $\pi_C(a\mid s)=\pi(\iota_c(s)).$5.

The training set contains 9,872 task–composition pairs over the 196-skill library: 65 real “anchors” from SkillsBench, 2,880 single-skill synthetic tasks, and 6,927 multi-skill synthetic tasks grounded in a dependency graph with 196 nodes and 924 edges. Optimization uses AdamW with learning rate $\pi_C(a\mid s)=\pi(\iota_c(s)).$6, weight decay 0.01, batch size 64, and up to 100 epochs with patience-15 early stopping on validation Set F1. On the synthetic test set, SkillComposer reports Set F1 73.9, Recall@5 72.4, MRR 86.5, nDCG@5 75.0, and Set EM 41.3, outperforming predicted-$\pi_C(a\mid s)=\pi(\iota_c(s)).$7 baselines and exceeding oracle-$\pi_C(a\mid s)=\pi(\iota_c(s)).$8 TF–IDF retrieval ceilings on multiple ranking metrics. On held-out real tasks, it reports Set F1 62.9, Recall@5 54.7, MRR 90.8, nDCG@5 63.4, and Set EM 20.0. Downstream on SkillsBench, pass rate rises from 22.2 to 45.3 on GPT-5.2-Codex and from 25.8 to 44.0 on Gemini-3-Pro-Preview, corresponding to improvements of +23.1 and +18.2 percentage points over the no-skill baseline. Prompt-token cost on Codex is reported as 1.03M for SkillComposer, versus 1.09M for top-3 retrieval, 1.13M for oracle retrieval, 1.12M for Gold Skills, and 1.27M for injecting all skills. Ablations show that both decode-time priors are load-bearing: removing set fusion drops Set F1 to 65.0, and removing the retrieval prior drops it to 67.5.

5. Skill evolution through Create, Improve, and Merge

"SkillComposer: Learning to Evolve Agent Skills for Specification and Generalization" addresses a different problem: not plan selection over a fixed library, but learnable construction and revision of textual skills (Zhang et al., 4 Jun 2026). Here a skill is

$\pi_C(a\mid s)=\pi(\iota_c(s)).$9

where $15\times15$0 is a stable identifier, $15\times15$1 encodes the trigger condition, and $15\times15$2 is a markdown-style procedural body. The method decomposes skill construction into three operations. Create distills a reusable skill from an unskilled trajectory. Improve refines an existing skill using a skill-guided trajectory on a task. Merge consolidates two similar skills into a more general one to prevent library bloat and improve transfer.

Skill pairing for Merge uses multi-view similarity over name, description, and body,

$15\times15$3

with a threshold $15\times15$4. Acceptance is controlled by delta pass rate. For Create,

$15\times15$5

For Merge, the average improvement over the two source tasks must exceed $15\times15$6, and for Improve, the average improvement over the original and target tasks must exceed $15\times15$7. All three thresholds are set to 0.4 in the reported experiments. The composer is trained by supervised fine-tuning on accepted examples from systematic rejection sampling, using standard next-token cross-entropy.

The reported system uses SkillComposer-4B as composer and Qwen3.5-4B or Qwen3.5-27B as executor. Around 7,000 accepted examples are collected for SFT. Training uses LlamaFactory with learning rate $15\times15$8, batch size 64, 3 epochs, maximum length 65,536 tokens, cosine learning rate scheduling, and 0.1 warmup. Deployment proceeds in three modes. Offline mode builds generalized libraries by Create followed by iterative Merge. Online mode creates a seed skill for the current task and then performs repeated Improve iterations. Hybrid mode retrieves from an offline library and then refines online.

The reported gains are consistent across benchmarks. On a 4B executor, SkillComposer-4B online reaches 84.8 on $15\times15$9-Bench overall versus 79.5 for No Skill, and hybrid reaches 85.7. On LiveCodeBench overall, online reaches 59.1 versus 56.6 for No Skill. Cross-model transfer is explicit: with a 27B executor, online SkillComposer-4B reaches 88.0 on $q$0-Bench overall versus 83.5 for No Skill, and 83.1 on LiveCodeBench overall versus 79.7. The paper also reports out-of-distribution gains on AppWorld, where online mode raises Accuracy from 55.2 to 57.7 and Pass Rate from 88.1 to 88.3. Ablations show that Merge is the dominant contributor in offline construction: Create only yields 73.8 / 58.5 on $q$1-Bench / LiveCodeBench overall, Create + Merge yields 77.5 / 59.0, and adding Improve offline can reduce transfer by overspecializing. This is the paper’s central distinction between specification and generalization: Improve is most useful online, whereas Merge is most useful offline.

6. Benchmarking, misconceptions, and recurrent limitations

A persistent misconception is that skill composition is synonymous with sequential option switching. The literature is explicitly split on this point. ComposeNet composes skills in parallel at the embedding level and “never executes multiple options,” whereas the quadruped composer is precisely a sequential transition mechanism between experts. The generative LLM SkillComposer argues that flat retrieval misses the structural nature of subset, count, and order, while the skill-evolution framework argues that one-shot extraction misses the tension between specification and generalization (Sahni et al., 2017, Christmann et al., 2024, Zhao et al., 30 Jun 2026, Zhang et al., 4 Jun 2026). These are different problem formulations sharing a modularity premise, not direct architectural variants of one another.

SkillCraft provides an evaluation perspective that clarifies the operational consequences of these design choices (Chen et al., 28 Feb 2026). It introduces a benchmark of 126 tasks across 21 task families and 6 domains, with a test-time protocol in which agents can save, verify, cache, and reuse code-based skills through a minimal MCP interface. Across evaluated agents, token usage is reduced by up to 80% via skill saving and reuse, and success rate correlates strongly with skill execution/composition ability, with reported correlation $q$2 between skill execution rate and success. The benchmark also shows that shallow, well-tested skills are generally more reliable than deep hierarchies: for GPT-5.2, hierarchical mode reduces success from 90% in flat Skill Mode to 79% while weakening token savings. This result does not invalidate hierarchical composition in principle, but it does indicate that deeper reuse structures amplify debugging overhead and error propagation in current agent implementations.

Across the cited SkillComposer variants, several limitations recur. ComposeNet assumes access to the relevant skills and the correct LTL operator; wrong or irrelevant skills lead to poor or no learning. The quadruped composer depends on feasible target-state distributions and overlap between expert and composer state distributions. Generative SkillComposer for coding agents relies on curated closed-vocabulary libraries and still under-emits on some long chains. Skill evolution via Create/Improve/Merge incurs substantial rejection-sampling cost and can overspecialize when Improve is used indiscriminately. Taken together, these results suggest that the central technical problem is not merely composing modules, but controlling the interface between modularity, validity constraints, and generalization.