Great paper on scaling agent skills.

It includes some great tips for keeping your agent skill library updated and running smoothly.

(bookmark it)

You will often see that adding a new skill to an agent can break routing for older skills, even when nothing about the older skills or the router changed.

Routers pick skills by name and description. When a new skill has similar metadata, it can replace or crowd out an earlier one.

Skill++ rewrites only the name and description of each incoming skill. The new description says what the skill supports, how it differs from its closest existing skill, and what it excludes. There is no router training and no labeled data.

As a library grows to 731 skills over ten sessions, the router selects every required skill for 76.3% of queries, against 36.4% with the original metadata. Substitution errors nearly disappear, and crowding errors fall by half.

The gains hold across three benchmarks and five routers, and they carry over to the Codex CLI harness.

When you add a skill, describe how it differs from the closest skill you already have.

Paper: https://arxiv.org/abs/2611.00544

Chat with Paper: https://academy.dair.ai/papers/skill-towards-lifelong-agents-via-routing-aware-skill-refinement-2611.00544…

Skill++: Towards Lifelong Agents via Routing-Aware Skill Refinement

Source: https://arxiv.org/html/2611.00544 Minghao LiangJiawei WuYankai ChenShicheng FanZhiwei LiuEnze MaJunwei YuanTianyi WangDehai MinKening ZhengXue LiuPhilip S. Yu

Abstract

Large language model (LLM) agents extend their capabilities with skills, each with a name, a description, and a body. Under progressive disclosure, an LLM router selects skills by name and description alone and loads only the selected bodies. Skill libraries grow continually as users and agents add new skills. Because the router relies on this metadata, a similar new skill can displace an earlier one, breaking previously correct routing even though the earlier skill and the router are unchanged. This routing interference is aggravated for public skills, whose descriptions may not match their bodies. We formulate the problem as lifelong skill routing, a class-incremental continual learning problem. A solution must keep earlier skills selectable without suppressing new ones. Existing approaches fall short, since continually retraining the router risks catastrophic forgetting and rewriting methods either ignore similar skills or require per-skill feedback. We therefore proposeSkill++, which rewrites only the name and description of each incoming skill, without router training or labeled data. The new description states what the body supports, how the skill differs from its closest predecessor, and what related work it excludes. As a library grows to 731 skills over ten sessions,Skill++selects all required skills for 76.3% of queries, versus 36.4% under the original metadata. Across three benchmarks and five LLM routers, it outperforms all compared approaches, and it also improves on the original metadata in the Codex CLI agent harness.

00footnotetext:## 1Introduction

Figure 1:This figure presents an example of routing interference, to show why incoming metadata needs refinement. The router reads only skill names and descriptions. (a) For a query about an AI paper, it selects the AI paper-writing skill. (b) A biology paper-writing skill arrives with the same metadata, and the router selects it instead. (c)Skill++refines only the incoming skill against the earlier one, so the router selects the correct skill again.Figure 2:This figure compares three ways of handling a growing skill library, to position our problem. (a) Continuous router training follows arriving skills but retrains the router at every step, risking catastrophic forgetting of earlier skills. (b) One-shot skill optimization refines a fixed skill set once, so it ignores skills that arrive later. (c)Skill++keeps the router frozen and refines each new batch against similar earlier skills, so both earlier and new skills are selected for the queries that need them.LLM agents(Zou et al., 2026a;Zou et al., 2026b)increasingly acquire new capabilities through skills(Song et al., 2026). A skill is a reusable package that teaches an agent how to perform a specific type of task. It consists of a name, a short description, and a body that holds instructions, code, and reference material, such as a guide to drawing charts with matplotlib. Because loading every body would exceed the context window, agents follow a design known as progressive disclosure, in which a skill’s body is read only after the skill is selected(Zheng et al., 2026). Skill selection therefore relies on a router that sees only the names and short descriptions of skills, which we call routing metadata. As a result,a skill is effective only if the router selects it when a query calls for it. Such selection would be straightforward in a small, fixed library, butin practice, skill libraries rarely stay fixed. Users continually install community skills for new tools and domains, and some agents even generate new skills without human authoring(Zhang et al., 2026b;Yan et al., 2026;Yang et al., 2026). For instance, a recent analysis covers 138K public skill files(Zhang et al., 2026a), and controlled audits(Kang, 2026)show that a router reading only names and descriptions easily confuses synonymous or overlapping skills (Fig.1).

Because new skills continue to arrive while earlier ones must remain usable, routing in a growing library is naturally a continual learning problem (also known as lifelong learning). More specifically, it is class-incremental, because new kinds of skills arrive over time while the router must still recognize the earlier ones. We formulate it as lifelong skill routing (Fig.2c), with skills arriving in batches, the router kept frozen, and only the metadata of each incoming skill allowed to change. This setting raises two challenges.1Whether a skill’s metadata identifies the skilldepends on the other skills in the library. A description that singled out a skill at insertion can lose its distinctiveness once similar skills arrive. The problem is more severe for skills collected from public sources, whose quality varies widely and whose routing metadata is often defective(Zhang et al., 2026a;Hao et al., 2026;Zhang et al., 2025a), so a name or description may not reflect what the body covers. In our experiments with the original metadata, 62 of the 115 queries that were routed correctly when their required skills first became available fail once the library reaches 731 skills (AppendixC.1). We call this effect routing interference, a form of forgetting at access rather than in parameters. It takes two forms. Insubstitution, a similar incoming skill is selected in place of the required skill (Fig.1a–b). Incrowding, incoming skills occupy the few selected slots and thereby exclude the required skill. These two forms cause 87.5% of the errors under the original metadata (Fig.5a).

2

Avoiding this interference is itself difficult, becauseprotecting earlier skills conflicts with adding new ones. This conflict mirrors the stability–plasticity dilemma of continual learning(De Lange et al., 2022), where shared parameters must retain earlier knowledge (stability) while acquiring new knowledge (plasticity). In our setting, the same tension arises in skill metadata. Stability requires that each earlier skill is still selected for the queries that need it after new skills arrive, and plasticity requires that each new skill is selected for its own queries. Concretely, a narrow description prevents a new skill from competing for the queries of earlier skills but leaves it rarely selected, whereas a broad description makes it selectable but diverts queries meant for earlier skills.

Existing approaches address these challenges only in part. Retraining a learned router(Zheng et al., 2026;Wang et al., 2026a)after each addition requires new training data and computation, and sequential updates can overwrite what the router learned about earlier skills, a problem known as catastrophic forgetting(Murtaza et al., 2026). Rewriting the text the router reads avoids retraining, but current rewriters fall short in our setting. Specifically, descriptions written from each tool’s own documentation ignore which similar skills the tool competes with(Lu et al., 2026a;Guo et al., 2026). Rewriting from routing errors(Zhou et al., 2026)requires labeled queries for each new skill, which our setting does not provide. Contrasting skills within a cluster needs no feedback but has been tested only on fixed libraries, so its effect on earlier skills is unknown(Wang et al., 2026b). Moreover, none of them measures stability and plasticity together as the library grows (Fig.2).

To address both challenges, we proposeSkill++, a simple yet effective method that refines the metadata of each incoming skill against the earlier skills it is most likely to be confused with (Fig.1c). Our key observation is that routing metadata cannot be written in isolation, because the router needs to know not only what a skill does but also what separates it from similar skills in the library.Skill++realizes this idea with three components. Description differentiation rewrites the description from the skill’s own body, which keeps it aligned with what the skill does, and centers it on what distinguishes the skill from its most similar predecessor. Scope exclusions state related work that the skill does not cover, and name clarification qualifies a name that overlaps with an earlier one. Differentiation and clarified names thus reduce substitution, and exclusions reduce crowding (challenge1, Fig.5c). Earlier skills stay selectable while each new skill is selected for its own queries, which addresses the trade-off of challenge2. Refinement is performed once at insertion, without router training or labeled feedback, so routers use the revised metadata directly.

In summary, our contributions are as follows:

• •To the best of our knowledge, we are the first to formalize lifelong skill routing, in which skills arrive sequentially into the skill library. Within this formulation, we show that routing interference prevents earlier skills from being selected for the queries that need them, even though their content and the router are unchanged, and that mitigating it raises the stability–plasticity dilemma of traditional continual learning at the level of skill metadata rather than model parameters.
• •We proposeSkill++, a simple yet effective method that incrementally optimizes the skill library for skill routing. Whenever a skill arrives,Skill++refines only that skill’s name and description against similar earlier skills, without router training or labeled feedback.
• •We evaluateSkill++on three skill benchmarks (SRA-Bench, SkillRet, and SkillRouter) with five LLM routers and the Codex CLI harness. Averaged over the five routers,Skill++improves routing accuracy at the final session by 23.1 percentage points (pp) over the original metadata, and achieves state-of-the-art performance among all compared approaches across benchmarks and routers.

2Related Work

Skill routing.

Prior work improves skill routing either by training the router or by rewriting the text it reads. Router-side methods train retrievers and rerankers to select individual skills(Kang et al., 2026;Zheng et al., 2026), and later ones model the compatibility among candidates to select complementary skill sets(Wang et al., 2026a). These methodsleave descriptions unchanged, although audits show that overlapping skills and weak descriptions cause routing failures(Kang, 2026;Zhang et al., 2026a). Text-side methods rewrite the descriptions instead. Descriptions derived from each tool’s own documentation(Lu et al., 2026a;Guo et al., 2026)never see the similar tools in the library, and enriching them yields little benefit on a production catalog(Gillespie and Perry, 2026). Later methods make these differences explicit, either by learning from execution traces or labeled routing errors thatmust be collected for each skill(Lu et al., 2026b;Zhou et al., 2026;Ghoshal et al., 2026)or by contrasting the skills within a cluster andrecompiling the cluster whenever a skill is added(Wang et al., 2026b).Skill++overcomes both limitations by refining only the incoming skill at insertion, with a description grounded in its body. Because the router stays unchanged, it also complements router-side methods.

Continual learning.

Our setting is a class-incremental continual learning problem, because earlier skills must remain selectable as new skills arrive. Classic methods retain earlier tasks by constraining parameter updates(Kirkpatrick et al., 2017;Lopez-Paz and Ranzato, 2017;De Lange et al., 2022). In the class-incremental scenario, the hardest of the three standard ones, confusion between old and new classes is a main source of forgetting(van de Ven et al., 2022;Zhou et al., 2024;Zhang et al., 2025b;Yao et al., 2026). Beyond parameters, LLM agents can also store capabilities outside the model in a growing skill library(Wang et al., 2024;Huang et al., 2026;Wu et al., 2026;Zhu et al., 2026).Forgetting then resurfaces at retrieval time, because new entries or retriever fine-tuning make earlier entries harder to retrieve(Hu et al., 2026;Murtaza et al., 2026;Song and Wei, 2026;Chen et al., 2026). Existing remediesretrain the retriever or add structuressuch as skill graphs(Murtaza et al., 2026;Bai et al., 2026).Skill++instead keeps the router frozen and edits only the metadata of the incoming skill. Unlike standard class-incremental learning, the class descriptions change rather than the classifier, and a new skill may join an old class. We therefore evaluate stability and plasticity separately.

3Method

Figure 3:This figure gives an overview ofSkill++, to show how it refines an incoming skill before the router reads it.Skill++first retrieves similar earlier skills from a record of their original names, descriptions, bodies and synthetic queries. Three components then refine the new skill independently. Description differentiation rewrites its description around what makes it unique, scope exclusions list related work that it does not cover, and name clarification makes an overlapping name more specific. The refined name and description enter the library that the router reads, and the original skill joins the record for future additions.### 3.1Problem Formulation

Continual learning setting.

We formulate skill routing in a growing library as class-incremental continual learning. In standard class-incremental learning(van de Ven et al., 2022;Zhou et al., 2024), a modelfθf_{\theta}receives a sequence of tasks whose data𝒟1,…,𝒟T\mathcal{D}_{1},\dots,\mathcal{D}_{T}introduce disjoint sets of classes. After each task, a learning algorithm𝒜\mathcal{A}updates the parameters, and the model is tested on the pooled data𝒟≤t\mathcal{D}_{\leq t}of all tasks so far (Fig.A1a):

θt\displaystyle\theta_{t}=𝒜⁡(θt−1,𝒟t),\displaystyle=\mathcal{A}(\theta_{t-1},\mathcal{D}_{t}),(1)Acct\displaystyle\mathrm{Acc}_{t}=Pr(x,y)∼𝒟≤t[fθt(x)=y].\displaystyle=\Pr_{(x,y)\sim\mathcal{D}_{\leq t}}\bigl[f_{\theta_{t}}(x)=y\bigr].In our setting (Fig.A1b), skills arrive in batches and are added one at a time, so stepttbrings a single skillct=(rt,bt)c_{t}=(r_{t},b_{t}). Its routing metadatart=(nt,dt)r_{t}=(n_{t},d_{t})consists of a name and a short description, and its bodybtb_{t}holds instructions and supporting material. Skills that serve the same kind of work form a skill class, such as the skills for plotting with matplotlib. Unlike in standard class-incremental learning,ctc_{t}may join an existing class and then compete with its earlier members for the same queries. A frozen router reads the names and descriptions in a libraryℒ\mathcal{L}and returns the identifiers ofKKskills,topK​(q,ℒ,ξ)\mathrm{top}_{K}(q;\mathcal{L},\xi), for a queryqq, whereξ\xicaptures its randomness. Routing succeeds when the selection contains the annotated skillsS⋆​(q)S^{\star}(q), one for each class whose workqqneeds. Whenctc_{t}arrives, a method observesctc_{t}, the current libraryℒt−1\mathcal{L}_{t-1}, and the recordsℋt−1\mathcal{H}_{t-1}of original metadata and bodies, but no queries, routing outcomes, or class labels. It may edit onlyrtr_{t}, which keeps the metadata of earlier skills stable. The edited metadatar~t\tilde{r}_{t}then updates the library and records as

ℒt=ℒt−1∪{(r~t,bt)},ℋt=ℋt−1∪{ct},\mathcal{L}_{t}=\mathcal{L}_{t-1}\cup\{(\tilde{r}_{t},b_{t})\},\quad\mathcal{H}_{t}=\mathcal{H}_{t-1}\cup\{c_{t}\},(2)whereℒ0\mathcal{L}_{0}andℋ0\mathcal{H}_{0}hold the initial skills.

Objective.

Queries follow a fixed deployment distribution𝒬\mathcal{Q}. Let𝒞t\mathcal{C}_{t}denote the skills that have arrived by steptt, so the queries served at stepttfollow𝒬t(q)∝𝒬(q)1[S⋆(q)⊆𝒞t]\mathcal{Q}_{t}(q)\propto\mathcal{Q}(q)\,\mathbf{1}[S^{\star}(q)\subseteq\mathcal{C}_{t}]. The success rate after stepttis

At=Prq∼𝒬t,ξ[S⋆(q)⊆topK(q;ℒt,ξ)].A_{t}=\Pr_{q\sim\mathcal{Q}_{t},\,\xi}\!\left[S^{\star}(q)\subseteq\mathrm{top}_{K}(q;\mathcal{L}_{t},\xi)\right].(3)It splits by whether a query needs the new skill:

At=ωt​Atold+(1−ωt)​Atnew,A_{t}=\omega_{t}\,A_{t}^{\mathrm{old}}+(1-\omega_{t})\,A_{t}^{\mathrm{new}},(4)whereωt=Prq∼𝒬t[ct∉S⋆(q)]\omega_{t}=\Pr_{q\sim\mathcal{Q}_{t}}[c_{t}\notin S^{\star}(q)], andAtoldA_{t}^{\mathrm{old}}andAtnewA_{t}^{\mathrm{new}}are the success rates of Eq. (3) conditioned onct∉S⋆​(q)c_{t}\notin S^{\star}(q)and onct∈S⋆​(q)c_{t}\in S^{\star}(q).AtoldA_{t}^{\mathrm{old}}measures stability andAtnewA_{t}^{\mathrm{new}}measures plasticity. The two can conflict, because makingctc_{t}more prominent can raiseAtnewA_{t}^{\mathrm{new}}while loweringAtoldA_{t}^{\mathrm{old}}. We seek an editing policyπ\pithat maps each observation to an edit and maximizes

𝔼π​[1T​∑t=1TAt],\mathbb{E}_{\pi}\!\left[\frac{1}{T}\sum_{t=1}^{T}A_{t}\right],(5)where the expectation is taken over addition orders and metadata generation. Eqs. (2)–(5) instantiate Eq. (1), with the libraryℒt\mathcal{L}_{t}in the role ofθt\theta_{t}, the policyπ\piin that of𝒜\mathcal{A}, andAtA_{t}in that ofAcct\mathrm{Acc}_{t}.

3.2Skill++: Routing-Aware Refinement

Skill++targets Eq. (5) through a surrogate objective that uses only the information available when a skill is added, namely the incoming skill and the earlier skills. Routing errors concentrate among skills with similar metadata(Chen et al., 2026), so the incoming metadata should separate the skill from the earlier skills𝒩t\mathcal{N}_{t}it is most likely to be confused with, while staying faithful to its own body (Sec.1):

maxr⁡Γ⁡(r,𝒩t)s.t.r⊧bt,|r|≤ℓmax.\max_{r}\,\Gamma(r;\mathcal{N}_{t})\ \ \text{s.t.}\ \ r\models b_{t},\ |r|\leq\ell_{\max}.(6)HereΓ\Gammameasures how wellrrseparatesctc_{t}from the skills in𝒩t\mathcal{N}_{t}, the fidelity constraintr⊧btr\models b_{t}requires every capability claimed inrrto be supported bybtb_{t}, andℓmax\ell_{\max}bounds the length. Rather than searching overrrnumerically,Skill++realizes each term of Eq. (6) with one part of its design. Description differentiation and name clarification separatectc_{t}from its most similar earlier skillgtg_{t}, and scope exclusions separate it from the related skills𝒢t\mathcal{G}_{t}, so𝒩t={gt}∪𝒢t\mathcal{N}_{t}=\{g_{t}\}\cup\mathcal{G}_{t}. Grounding the capability description inbtb_{t}targets fidelity, and dropping exclusion phrases from an overlong description enforces the length bound.

The three components (Fig.3) read the original recordsℋt−1\mathcal{H}_{t-1}, so earlier revisions never affect later references. We writeℳD\mathcal{M}_{D},ℳE\mathcal{M}_{E}, andℳN\mathcal{M}_{N}for the prompted LLM calls that write descriptions, exclusion phrases, and names, and AppendixAgives their settings and summarizes one addition step in Algorithm1.

Figure 4:This figure shows FC@5 as the library grows (sizes in Tab.A2), to test whether routing stays accurate. (a) The main router, Claude Haiku 4.5 (Tab.A1). (b)–(e) Four other routers (Tab.A4). With every router, Vanilla declines whileSkill++leads or ties at every checkpoint.#### Differentiating Skill Descriptions.

This component writes the positive part of the metadata. A description written from the body alone tends to repeat capabilities that many similar skills share, so it gives the router little evidence to separate them. Differentiation therefore contrasts the incoming skill with the earlier skill whose original metadata is most similar,

gt=arg⁡maxs:cs∈ℋt−1ϕ(rs)⊤ϕ(rt),g_{t}=\underset{s:\,c_{s}\in\mathcal{H}_{t-1}}{\arg\max}\;\phi(r_{s})^{\top}\phi(r_{t}),(7)whereϕ⁡(r)\phi(r)is the unit-normalized embedding of the name and description inrr. The callℳD\mathcal{M}_{D}reads both names and short passages from both bodies and writes a capability descriptiond^t\hat{d}_{t}that leads with what sets the incoming skill apart. An original description can also misstate its body. It may overclaim, advertising work that the body does not support, so that the skill takes the queries of earlier skills. It may instead underclaim, omitting work that the body covers, so that the skill misses its own queries. Every claim ofd^t\hat{d}_{t}must therefore come from the incoming body, which aligns the description with what the skill does, and the reference is never named.

Adding Scope Exclusions.

This component writes the negative part and targets crowding. It tells the router which nearby work the incoming skill does not cover, so that the skill leaves those queries to related skills. Related skills may serve the same queries under different wording, so their metadata need not look alike, andSkill++therefore compares skills through synthetic queries. When a skill is installed, a generation model writes a setQ~s\tilde{Q}_{s}of up to eight queries from its body alone, and the record stores them with the skill. These queries never draw on evaluation queries or labels, and they serve only this search. Each earlier skillssthen receives three scores.σ1​(s)\sigma_{1}(s)asks whether the incoming metadata matches a typical query ofss,σ2​(s)\sigma_{2}(s)whether the two skills serve similar queries, andσ3​(s)\sigma_{3}(s)whether their original metadata look alike. The reference set and the exclusion clause are

𝒢t\displaystyle\mathcal{G}_{t}={s:cs∈ℋt−1,ρ¯(s)≤3},\displaystyle=\bigl\{s:\ c_{s}\in\mathcal{H}_{t-1},\ \bar{\rho}(s)\leq 3\bigr\},(8)et\displaystyle e_{t}=ℳE​({rs}s∈𝒢t),\displaystyle=\mathcal{M}_{E}\bigl(\{r_{s}\}_{s\in\mathcal{G}_{t}}\bigr),whereρ¯​(s)\bar{\rho}(s)is the fused rank ofssunder the three scores, with 1 for the best candidate (Eq. (14) in AppendixA). The callℳE\mathcal{M}_{E}summarizes the responsibility of each reference in a short phrase, andete_{t}joins these phrases afterDoes not cover.

Clarifying Skill Names.

Names are short and prominent in the router’s input, so two skills with similar names can be confused even when their descriptions differ. This component therefore targets substitution through the name. Leth⁡(n)h(n)denote the name head ofnn, its first word (AppendixA). A conflict is flagged by

zt=𝟏[∃cs∈ℋt−1:h(ns)⊑nt],z_{t}=\mathbf{1}\bigl[\exists\,c_{s}\in\mathcal{H}_{t-1}:\ h(n_{s})\sqsubseteq n_{t}\bigr],(9)where⊑\sqsubseteqdenotes substring containment. Ifzt=1z_{t}=1, the callℳN\mathcal{M}_{N}readsntn_{t}, a passage frombtb_{t}, and the reference namengtn_{g_{t}}, and proposes a name qualified by the topic, workflow, or type of guidance in the body. The final namen~t\tilde{n}_{t}is this proposal if it has 4 to 60 characters, andntn_{t}otherwise.

Assembling Outputs.

The revised metadata is

r~t=(n~t,d^t⊕et),\tilde{r}_{t}=(\tilde{n}_{t},\ \hat{d}_{t}\oplus e_{t}),(10)where⊕\oplusappends the exclusion clause. If the result exceeds a length thresholdℓmax\ell_{\max}, exclusion phrases are dropped from the end, so the capability description is never truncated.

4Experiments

We evaluateSkill++with four research questions (RQs) on performance (RQ1), the source of its gains (RQ2), generalization (RQ3), and the contribution of each component (RQ4).

4.1Experimental Setup

Benchmarks.

We build on the multi-skill queries of three benchmarks, SRA-Bench(Su et al., 2026), SkillRet(Kang et al., 2026)and SkillRouter(Zheng et al., 2026). Each originally evaluates routing over a fixed skill library with queries annotated by their required skills, and we turn each into a class-incremental version with the same recipe. Over ten sessions (S0 to S9), new skill classes arrive together with the queries that need them. From S1 onward, incoming skills similar to but distinct from earlier required skills also join.Skill++refines these incoming skills, and the required skills keep their original metadata. After each session from S1 to S9, a checkpoint routes all queries released so far, so routing is tested at nine points as the library grows. The main study uses 198 BigCodeBench(Zhuo et al., 2025)queries of SRA-Bench, each needing three to five skills, and its library grows from 27 to 731 skills (AppendixB.1and Tab.A2). For RQ3, SkillRet and SkillRouter add 60 and 42 queries. RQ3 also installs the libraries in Codex CLI at every session (AppendixC.3).

Router.

As in agent harnesses such as Codex CLI(OpenAI, 2025), an LLM router selects skills from their names and descriptions alone. The main router is Claude Haiku 4.5(Anthropic, 2025), and it routes each query in two calls. The first call shortlists ten skills from all installed skills, and the second reorders the shortlist. The first five skills of the reordered list form the final selection, which istopK\mathrm{top}_{K}in Eq. (3) withK=5K=5. We call this two-call pipeline our routing harness.

Metrics.

To measure whether required skills remain selectable as the library grows, we report two metrics on the final selectiontopK\mathrm{top}_{K}. Full coverage atKK(FC@KK), adopted from SkillRouter(Zheng et al., 2026), is the fraction of queries whose required skills all appear intopK\mathrm{top}_{K}. It serves as the primary metric, because an agent needs every required skill to complete a query. Recall@KKis the fraction of each query’s required skills that appear intopK\mathrm{top}_{K}, averaged over queries, and it shows how many required skills are lost when full coverage fails. We setK=5K=5, because each query of the main study needs at most five skills and an agent loads only a few skills into its context. FC@5 at a checkpoint thus estimatesAtA_{t}in Eq. (3), and its average over the nine checkpoints S1–S9, reported as Avg, estimates the objective in Eq. (5).

Baselines.

BesidesVanilla, which keeps the original metadata, we compare three kinds of baselines (AppendixB.3). The first kind rewrites the incoming skill.Body-distilled, adapted from SkillRouter(Zheng et al., 2026), writes the incoming skill’s description from that skill’s body alone. The second kind rewrites earlier skills.Neighbor-contrastive, adapted from A-MEM’s memory evolution(Xu et al., 2025), rewrites the three most similar earlier skills whenever a skill arrives. LikeSkill++, these rewriting baselines use the same generator and never see the evaluation queries or their labels. The third kind keeps the metadata and narrows the candidates.Retrieve-and-rerank(R&R), SkillRouter’s base pipeline, narrows the library to a short candidate list with an embedding retriever and a reranker(Zhang et al., 2025c), and the router’s first call reads only these candidates. ItsHybridvariants add BM25(Robertson and Zaragoza, 2009)followingLiu et al. (2026), and its*-CFT*(continual fine-tuning) variants fine-tune the embedding model at every checkpoint on synthetic queries for the incoming skills(Zheng et al., 2026;Murtaza et al., 2026). We also run the released pages of Cluster-Contrastive Capability Pages (CC-Pages)(Wang et al., 2026b).

(a) Vanilla errors by form and type

(b)Skill++against Vanilla

(c) Components added to Vanilla

Figure 5:This figure breaks down the routing errors at S9 into two forms and seven types (defined in AppendixC.2), to show which errorsSkill++removes. All panels draw on the eight combinations of Tab.A3. (a) The 200 Vanilla errors, by form (inner ring) and type (outer ring). (b) Errors per type under Vanilla andSkill++, as a share of the Vanilla errors. (c) Errors per form when one component or all three are added to Vanilla, shown in the same way.Skill++removes most errors of both forms, and each component mainly reduces one form.

4.2Experimental Results

RQ1: As the library grows, doesSkill++keep earlier skills selectable while new skills remain selected for their own queries?Takeaway 1:Yes. Refining only the incoming metadata against similar earlier skills prevents most of the loss caused by library growth and outperforms all baselines, including those that keep fine-tuning the retriever. New skills are selected for their own queries more often than under the original metadata, soSkill++gains stability without trading away plasticity.

Fig.4a shows thatthe gap betweenSkill++and the original metadata widens as the library grows. From S1 to S9, FC@5 under Vanilla falls from 92.5% to 36.4%, whileSkill++still reaches 76.3% and leads at every checkpoint. The strongest baseline reaches 67.8%, and CC-Pages 60.1%. As for plasticity, refined incoming skills rank first on 56.9% of queries written from their bodies, compared with 51.9% under Vanilla (AppendixC.1).

RQ2: Which routing errors doesSkill++reduce, and does each component address the error it targets?Takeaway 2:Under the original metadata, most errors arise because a similar incoming skill takes the place of a required skill (substitution) or because generic and redundant skills fill the selected slots (crowding).Skill++nearly eliminates substitution and halves crowding. Differentiation and name clarification mainly reduce substitution, and exclusions mainly reduce crowding.

Fig.5shows thatmost Vanilla errors take one of two forms, andSkill++reduces both. Each required skill missing from the final selection at S9 counts as one error (AppendixC.2).

• •Three types cause most Vanilla errors.Substitution and crowding account for 46.0% and 41.5% of the 200 Vanilla errors (Fig.5a). Similar-Skill Confusion, Generic-Skill Crowding and Duplicate Crowding together make up 70.0%.
• •Skill++nearly removes substitution and halves crowding.Substitution falls from 46.0% to 6.5% of the Vanilla errors and crowding from 41.5% to 20.0% (Fig.5b). Similar-Skill Confusion falls from 28.5% to 1.5%, and Description Inconsistency, in which an incoming description overclaims or underclaims its body, disappears.
• •Each component mainly reduces the form it targets.Added alone to Vanilla, differentiation and name clarification lower substitution by 27.0 and 14.5 pp, while exclusions lower crowding by 14.0 pp (Fig.5c). Each component lowers the other form by at most half as much.

RQ3: DoesSkill++generalize beyond SRA-Bench and Claude Haiku 4.5?Takeaway 3:Yes. Its gains generalize beyond the main study without retuning, becauseSkill++changes only the metadata that every router reads. They persist on the SkillRet and SkillRouter benchmarks, across theGPT-5.4-mini,GPT-5.6 Luna,GPT-5.6 SolandQwen3.7-Flashrouters, and in the Codex CLI harness. The gains are largest where routing over the original metadata is weakest, suggesting that refinement is most beneficial when a router alone cannot distinguish similar skills.

Fig.4b–e and Fig.A3show thatSkill++raises FC@5 in every new setting. On SkillRet and SkillRouter (Tab.A6), it stays above Vanilla at every session as the libraries grow to about 2,000 skills. Its mean FC@5 over S1–S9 is 10.9 and 12.4 pp higher, and it leads by 14.4 and 18.9 pp at S9. Across the five routers, it stays above Vanilla at every checkpoint and improves S9 FC@5 by 23.1 pp on average (Fig.4and AppendixC.3). At S9, it also exceeds Body-distilled across the four evaluated routers, from 31.9 pp with Claude Haiku 4.5 to 9.6 pp with GPT-5.6 Sol(OpenAI, 2026b). In Codex CLI, its mean FC@5 over S1–S9 exceeds Vanilla by 34.3 pp with GPT-5.6 Luna and by 11.1 pp with GPT-5.6 Sol.

RQ4: How much does each component contribute?Takeaway 4:Every component contributes, and differentiation contributes most.

Tab.A3shows thatremoving any component lowers FC@5, and removing differentiation lowers it most. At S9, FC@5 falls from 76.3% to 56.6%, 64.6% and 61.6% without differentiation, exclusions and name clarification, respectively.

5Conclusion

This paper formulates skill routing over a continually growing library as lifelong skill routing. New skills cause routing interference through substitution and crowding, even though neither the earlier skills nor the router changes. To mitigate this interference, we proposeSkill++, which refines the metadata of each incoming skill against similar earlier skills, without router training or labeled feedback. Experiments show thatSkill++outperforms all compared approaches and keeps both earlier and new skills selectable. It also nearly eliminates substitution and halves crowding, and its gains hold across benchmarks, routers and the Codex CLI harness. Future work can extend lifelong skill routing to multimodal skills and queries.

Limitations

Our study is limited to text. Every skill consists of a name, a description, and a textual body, and both the queries and the router’s input are text. Skills or queries involving images, audio, or other modalities may interfere in ways that textual metadata cannot capture. We leave multimodal skills and queries to future work.

References

• Anthropic (2025)Anthropic. 2025.Claude Haiku 4.5 system card.
• Anthropic (2026)Anthropic. 2026.Claude Opus 4.6 system card.
• Bai et al. (2026)Tong Bai, Zhenglin Wan, Pengfei Zhou, Xingrui Yu, Yang You, and Ivor W. Tsang. 2026.SkillDAG: Self-evolving typed skill graphs for LLM skill selection at scale.Preprint, arXiv:2606.03056.
• Chen et al. (2026)Charles Chen, Qiming Yu, Yuhang Gu, Zhuoye Huang, Hanjing Li, Hongyu Liu, Simin Liu, Jinhao Liu, Dengyun Peng, Jiangyi Wang, Zheng Yan, Fanqing Meng, Ethan Qin, Carl Che, and Mengkang Hu. 2026.The scaling laws of skills in LLM agent systems.Preprint, arXiv:2605.16508.
• Cormack et al. (2009)Gordon V. Cormack, Charles L. A. Clarke, and Stefan Buettcher. 2009.Reciprocal rank fusion outperforms Condorcet and individual rank learning methods.InProceedings of the 32nd International ACM SIGIR Conference on Research and Development in Information Retrieval, pages 758–759.
• De Lange et al. (2022)Matthias De Lange, Rahaf Aljundi, Marc Masana, Sarah Parisot, Xu Jia, Aleš Leonardis, Gregory Slabaugh, and Tinne Tuytelaars. 2022.A continual learning survey: Defying forgetting in classification tasks.IEEE Transactions on Pattern Analysis and Machine Intelligence, 44(7):3366–3385.
• DeepSeek-AI (2026)DeepSeek-AI. 2026.DeepSeek-V4: Towards highly efficient million-token context intelligence.Preprint, arXiv:2606.19348.
• Ghoshal et al. (2026)Sandip Ghoshal, Anshul Mittal, Jyotika Singh, Miguel Ballesteros, Weiyi Sun, Fang Tu, Shailender Singh, Yassine Benajiba, Fahad Shah, Sujeeth Bharadwaj, Sujith Ravi, and Dan Roth. 2026.JTPRO: A joint tool-prompt reflective optimization framework for language agents.InFindings of the Association for Computational Linguistics: ACL 2026, pages 40573–40595.
• Gillespie and Perry (2026)Kellen Gillespie and Robyn Perry. 2026.Scaling enterprise agent routing: Degradation, diagnosis, and recovery.Preprint, arXiv:2606.17519.
• Google DeepMind (2026a)Google DeepMind. 2026a.Gemini 3.5 Flash-Lite model card.
• Google DeepMind (2026b)Google DeepMind. 2026b.Gemini 3.6 Flash model card.
• Guo et al. (2026)Ruocheng Guo, Kaiwen Dong, Xiang Gao, and Kamalika Das. 2026.Learning to rewrite tool descriptions for reliable LLM-agent tool use.Preprint, arXiv:2602.20426.
• Hao et al. (2026)Haochang Hao, Dehai Min, Zhifang Zhang, Yunbei Zhang, Miao Xu, Yingqiang Ge, Philip S. Yu, and Lu Cheng. 2026.One skill, two masters: Serving users and attackers through skill injection.Preprint, arXiv:2606.07943.
• Hu et al. (2026)Qisheng Hu, Quanyu Long, and Wenya Wang. 2026.When continual learning moves to memory: A study of experience reuse in LLM agents.Preprint, arXiv:2604.27003.
• Huang et al. (2026)Wei-Chieh Huang, Weizhi Zhang, Yueqing Liang, Yuanchen Bei, Yankai Chen, Tao Feng, Xinyu Pan, Zhen Tan, Yu Wang, Tianxin Wei, Shanglin Wu, Ruiyao Xu, Liangwei Yang, Rui Yang, Wooseong Yang, Chin-Yuan Yeh, Hanrong Zhang, Haozhen Zhang, Siqi Zhu, and 41 others. 2026.A survey of agent memory in the second half: Towards self-evolving and long-horizon agents.Transactions on Machine Learning Research.
• Kang (2026)Ruiyuan Kang. 2026.SkillSeam: Six principles for auditing agent skill collections.Preprint, arXiv:2609.13321.
• Kang et al. (2026)Ryangkyung Kang, Hongcheol Cho, and Youngeun Kim. 2026.SkillRet: A large-scale benchmark for skill retrieval in LLM agents.Preprint, arXiv:2605.05726.
• Kirkpatrick et al. (2017)James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A. Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, Demis Hassabis, Claudia Clopath, Dharshan Kumaran, and Raia Hadsell. 2017.Overcoming catastrophic forgetting in neural networks.Proceedings of the National Academy of Sciences, 114(13):3521–3526.
• Koehn (2004)Philipp Koehn. 2004.Statistical significance tests for machine translation evaluation.InProceedings of the 2004 Conference on Empirical Methods in Natural Language Processing, pages 388–395.
• Liu et al. (2026)Yujian Liu, Jiabao Ji, Li An, Tommi Jaakkola, Yang Zhang, and Shiyu Chang. 2026.How well do agentic skills work in the wild: Benchmarking LLM skill usage in realistic settings.Preprint, arXiv:2604.04323.
• Lopez-Paz and Ranzato (2017)David Lopez-Paz and Marc’Aurelio Ranzato. 2017.Gradient episodic memory for continual learning.InAdvances in Neural Information Processing Systems, volume 30, pages 6467–6476.
• Lu et al. (2026a)Xuan Lu, Haohang Huang, Rui Meng, Yaohui Jin, Wenjun Zeng, and Xiaoyu Shen. 2026a.Tools are under-documented: Simple document expansion boosts tool retrieval.InThe Fourteenth International Conference on Learning Representations.
• Lu et al. (2026b)You Lu, Kun Zhang, Bihuan Chen, and Xin Peng. 2026b.DocsChisel: Adaptive tool documentation optimization framework for LLM agents.Preprint, arXiv:2608.10037.
• Murtaza et al. (2026)Syed Shariyar Murtaza, Yifan Nie, Utkarsh Soni, Eugene Wen, and Arvid Frydenlund. 2026.When synthetic data hurts: On catastrophic forgetting in skill retrieval for LLM agents.Preprint, arXiv:2609.10750.
• OpenAI (2025)OpenAI. 2025.Codex CLI: A lightweight coding agent that runs in your terminal.
• OpenAI (2026a)OpenAI. 2026a.GPT-5.5 system card.
• OpenAI (2026b)OpenAI. 2026b.GPT-5.6 system card.
• OpenAI (2026c)OpenAI. 2026c.Introducing GPT-5.4 mini and nano.
• Qwen Team (2026)Qwen Team. 2026.Qwen3.7-Flash.QwenCloud model release, 25 July 2026.
• Reimers and Gurevych (2019)Nils Reimers and Iryna Gurevych. 2019.Sentence-BERT: Sentence embeddings using Siamese BERT-networks.InProceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 3982–3992.
• Robertson and Zaragoza (2009)Stephen Robertson and Hugo Zaragoza. 2009.The probabilistic relevance framework: BM25 and beyond.Foundations and Trends in Information Retrieval, 3(4):333–389.
• Song et al. (2026)Dingjie Song, Hanrong Zhang, Dawei Liu, Yixin Liu, Zongxia Li, Zhengqing Yuan, Siqi Zhang, Henry Peng Zou, Zhiling Yan, Yuxuan Zhang, Yanfang Ye, Philip S. Yu, and Lichao Sun. 2026.Dr. Claw: An AI scientist workspace for vibe research.InProceedings of the 2026 Conference on Empirical Methods in Natural Language Processing: System Demonstrations.
• Song and Wei (2026)Hongwen Song and Song Wei. 2026.More skills, worse agents? Skill shadowing degrades performance when expanding skill libraries.Preprint, arXiv:2605.24050.
• Su et al. (2026)Weihang Su, Jianming Long, Qingyao Ai, Qiaozhi He, Yichen Tang, Changyue Wang, Yiteng Tu, Yingbo Wang, and Yiqun Liu. 2026.Skill retrieval augmentation for agentic ai.Preprint, arXiv:2604.24594.Author repository:https://github.com/oneal2000/SR-Agents.
• van de Ven et al. (2022)Gido M. van de Ven, Tinne Tuytelaars, and Andreas S. Tolias. 2022.Three types of incremental learning.Nature Machine Intelligence, 4(12):1185–1197.
• van den Oord et al. (2018)Aaron van den Oord, Yazhe Li, and Oriol Vinyals. 2018.Representation learning with contrastive predictive coding.Preprint, arXiv:1807.03748.
• Wang et al. (2024)Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. 2024.Voyager: An open-ended embodied agent with large language models.Transactions on Machine Learning Research.
• Wang et al. (2020)Wenhui Wang, Furu Wei, Li Dong, Hangbo Bao, Nan Yang, and Ming Zhou. 2020.MiniLM: Deep self-attention distillation for task-agnostic compression of pre-trained transformers.InAdvances in Neural Information Processing Systems, volume 33, pages 5776–5788.
• Wang et al. (2026a)Zifei Wang, Wei Wen, Qiang Ji, Keyu Chen, Ruizhi Qiao, and Xing Sun. 2026a.Skill is not document: Query-conditioned compatibility for LLM agent skill routing.Preprint, arXiv:2606.03565.
• Wang et al. (2026b)Zifei Wang, Wei Wen, Qiang Ji, and Ruizhi Qiao. 2026b.Skills know their neighbors: Cluster-contrastive capability pages for skill retrieval.Preprint, arXiv:2608.04482.
• Wu et al. (2026)Zhaofen Wu, Hanrong Zhang, Fulin Lin, Wujiang Xu, Xinran Xu, Yankai Chen, Henry Peng Zou, Shaowen Chen, Weizhi Zhang, Xue Liu, Philip S. Yu, and Hongwei Wang. 2026.GAM: Hierarchical graph-based agentic memory for LLM agents.InProceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 34647–34664.
• Xu et al. (2025)Wujiang Xu, Zujie Liang, Kai Mei, Hang Gao, Juntao Tan, and Yongfeng Zhang. 2025.A-Mem: Agentic memory for LLM agents.InAdvances in Neural Information Processing Systems, volume 38, pages 17577–17604.
• Yan et al. (2026)Zhiling Yan, Dingjie Song, Hanrong Zhang, Wei Liang, Yuxuan Zhang, Yutong Dai, Lifang He, Philip S. Yu, Ran Xu, Xiang Li, and Lichao Sun. 2026.OpenSkill: Open-world self-evolution for LLM agents.InProceedings of the 2026 Conference on Empirical Methods in Natural Language Processing (EMNLP).
• Yang et al. (2026)Jie Yang, Yan Zheng, Jiarui Sun, Xiran Fan, Junpeng Wang, Liang Wang, Zelin Xu, Qinghua Liu, Zhengyu Fang, Yiwei Cai, and Philip S. Yu. 2026.TimeEvo: Failure-driven self-evolution of a time series agent.Preprint, arXiv:2609.27277.
• Yao et al. (2026)Yifei Yao, Hanrong Zhang, Fulin Lin, Ziyan Jin, Xiaoxiao Li, Hongwei Wang, and Ying Chi. 2026.From uncertainty to clarity: Uncertainty-guided class-incremental learning for limited biomedical samples via semantic expansion.IEEE Journal of Biomedical and Health Informatics, pages 1–14.
• Zhang et al. (2026a)Chi Zhang, Yimin Liu, Xinze Chen, and Ping Ji. 2026a.What keeps agent skills from being reusable? evidence from 138K SKILL.md files.Preprint, arXiv:2608.08453.
• Zhang et al. (2026b)Hanrong Zhang, Shicheng Fan, Henry Peng Zou, Yankai Chen, Zhenting Wang, Jiayu Zhou, Chengze Li, Wei-Chieh Huang, Yifei Yao, Kening Zheng, Xue Liu, Xiaoxiao Li, and Philip S. Yu. 2026b.CoEvoSkills: Self-evolving agent skills via co-evolutionary verification.InConference on Language Modeling (COLM).
• Zhang et al. (2025a)Hanrong Zhang, Jingyuan Huang, Kai Mei, Yifei Yao, Zhenting Wang, Chenlu Zhan, Hongwei Wang, and Yongfeng Zhang. 2025a.Agent security bench (ASB): Formalizing and benchmarking attacks and defenses in LLM-based agents.InInternational Conference on Learning Representations (ICLR).
• Zhang et al. (2025b)Hanrong Zhang, Yifei Yao, Zixuan Wang, Jiayuan Su, Mengxuan Li, Peng Peng, and Hongwei Wang. 2025b.Class incremental fault diagnosis under limited fault data via supervised contrastive knowledge distillation.IEEE Transactions on Industrial Informatics, 21(6):4344–4354.
• Zhang et al. (2025c)Yanzhao Zhang, Mingxin Li, Dingkun Long, Xin Zhang, Huan Lin, Baosong Yang, Pengjun Xie, An Yang, Dayiheng Liu, Junyang Lin, Fei Huang, and Jingren Zhou. 2025c.Qwen3 Embedding: Advancing text embedding and reranking through foundation models.Preprint, arXiv:2506.05176.
• Zheng et al. (2026)YanZhao Zheng, ZhenTao Zhang, Chao Ma, YuanQiang Yu, JiHuai Zhu, Yong Wu, Tianze Xu, Baohua Dong, Hangcheng Zhu, Ruohui Huang, and Gang Yu. 2026.SkillRouter: Skill routing for LLM agents at scale.Preprint, arXiv:2603.22455.
• Zhou et al. (2024)Da-Wei Zhou, Qi-Wei Wang, Zhi-Hong Qi, Han-Jia Ye, De-Chuan Zhan, and Ziwei Liu. 2024.Class-incremental learning: A survey.IEEE Transactions on Pattern Analysis and Machine Intelligence, 46(12):9851–9873.
• Zhou et al. (2026)Yangqiaoyu Zhou, Mohammad Alqudah, Kwei-Herng Lai, Aaron Halfaker, Yingqi Xiong, and Yaar Harari. 2026.A single rewrite suffices: Empirical lessons from production skill description optimization.Preprint, arXiv:2606.30775.
• Zhu et al. (2026)Sibo Zhu, Shicheng Fan, Xinyue Wang, Wenyi Wu, Kun Zhou, and Biwei Huang. 2026.RSIAgent: Autonomous exploration for recursive self-improvement in new environments.Preprint, arXiv:2609.15364.
• Zhuo et al. (2025)Terry Yue Zhuo, Minh Chien Vu, Jenny Chim, Han Hu, Wenhao Yu, Ratnadira Widyasari, Imam Nur Bani Yusuf, Haolan Zhan, Junda He, Indraneil Paul, Simon Brunner, Chen Gong, Thong Hoang, Armel Randy Zebaze, Xiaoheng Hong, Wen-Ding Li, Jean Kaddour, Ming Xu, Zhihan Zhang, and 14 others. 2025.BigCodeBench: Benchmarking code generation with diverse function calls and complex instructions.InProceedings of the Thirteenth International Conference on Learning Representations.
• Zou et al. (2026a)Henry Peng Zou, Wei-Chieh Huang, Yaozu Wu, Jizhou Guo, Yankai Chen, Chunyu Miao, Hoang H. Nguyen, Yue Zhou, Weizhi Zhang, Liancheng Fang, Hanrong Zhang, Fangxin Wang, Pengfei Zhang, Langzhou He, Yangning Li, Dongyuan Li, Renhe Jiang, and Philip S. Yu. 2026a.LLM-based human-agent collaboration and interaction systems: A survey.InFindings of the Association for Computational Linguistics: ACL 2026, pages 36335–36364.
• Zou et al. (2026b)Henry Peng Zou, Chunyu Miao, Wei-Chieh Huang, Yankai Chen, Yue Zhou, Hanrong Zhang, Yaozu Wu, Liancheng Fang, Zhengyao Gu, Zhen Zhang, Kening Zheng, Fangxin Wang, Yi Nian, Shanghao Li, Wenzhe Fan, Langzhou He, Weizhi Zhang, Xue Liu, and Philip S. Yu. 2026b.When users change their mind: Evaluating interruptible agents in long-horizon web navigation.Preprint, arXiv:2604.00892.

Appendix Contents

AppendixAdetails the implementation ofSkill++, AppendixBdescribes the experimental setup, and AppendixCgives evidence for each RQ.

Appendix AImplementation Details

This appendix gives the settings that Sec.3defers. Fig.A1first contrasts the formulation of Sec.3.1with conventional class-incremental learning.

Figure A1:This figure compares conventional class-incremental learning with lifelong skill routing, to motivate our formulation. Both settings aim to retain earlier performance while accommodating new classes or skills. (a) The model is trained on new labeled classes, so parameter updates can change its decisions on earlier classes. (b) New skill classes and skills similar to earlier ones arrive while the router stays frozen and reads only names and descriptions. A biology paper-writing skill with the same metadata as the earlier AI skill can push the unchanged AI skill out of the top-KKfor an earlier query, soSkill++refines only the metadata of incoming skills.#### Description differentiation.

The referencegtg_{t}is selected with all-MiniLM-L6-v2(Reimers and Gurevych, 2019;Wang et al., 2020)embeddings of the original name and description. Gemini 3.5 Flash-Lite(Google DeepMind, 2026a)then reads up to 1,600 characters of the incoming body and 1,200 of the reference body. Its prompt asks for at most 220 characters that state only capabilities contained in the incoming body, lead with what the reference does not offer, and never name or allude to the reference. Outputs that are too long or name the reference are regenerated and then retried with Gemini 3.6 Flash(Google DeepMind, 2026b), and the original description is kept if none passes.

Scope exclusions.

For each skill, DeepSeek-V4-Flash(DeepSeek-AI, 2026)writes up to eight synthetic queries from up to 2,600 characters of its body, phrased as a user would write them during a task and never naming the skill. Queries are generated once per skill and are checked for overlap with the 198 routing queries. Letu⁡(r)u(r)be the name and the first 300 characters of the description joined by a period, and letι⁡(q)\iota(q)prepend a retrieval instruction to a query. For a candidatesswith query setQ~s\tilde{Q}_{s},

σ1​(s)\displaystyle\sigma_{1}(s)=maxq∈Q~s⁡ψ​(ι⁡(q))⊤​ψ​(u⁡(rt)),\displaystyle=\max_{q\in\tilde{Q}_{s}}\psi(\iota(q))^{\top}\psi(u(r_{t})),(11)σ2​(s)\displaystyle\sigma_{2}(s)=maxq∈Q~s,q′∈Q~t⁡ψ​(ι⁡(q))⊤​ψ​(ι⁡(q′)),\displaystyle=\max_{q\in\tilde{Q}_{s},\,q^{\prime}\in\tilde{Q}_{t}}\psi(\iota(q))^{\top}\psi(\iota(q^{\prime})),(12)σ3​(s)\displaystyle\sigma_{3}(s)=ϕ′​(u⁡(rs))⊤​ϕ′​(u⁡(rt)),\displaystyle=\phi^{\prime}(u(r_{s}))^{\top}\phi^{\prime}(u(r_{t})),(13)whereψ\psiis Qwen3-Embedding-4B(Zhang et al., 2025c)andϕ′\phi^{\prime}is MiniLM applied tou⁡(⋅)u(\cdot). Intuitively,σ1\sigma_{1}asks whether the incoming metadata matches a typical query ofss,σ2\sigma_{2}whether the two skills serve similar queries, andσ3\sigma_{3}whether their names and descriptions look alike. The first two take a maximum because one shared use already suffices for confusion. Letρk​(s)\rho_{k}(s)denote the rank of candidatessunderσk\sigma_{k}, with rank 1 indicating the highest similarity. Candidates are sorted lexicographically by

(mink∈{1,2,3}⁡ρk​(s),∑k=13ρk​(s)),\Bigl(\min_{k\in\{1,2,3\}}\rho_{k}(s),\;\sum_{k=1}^{3}\rho_{k}(s)\Bigr),(14)with remaining ties resolved by addition order. This rule favors candidates that any single measure ranks highly and breaks ties by the sum of ranks. The first three candidates form𝒢t\mathcal{G}_{t}. Gemini 3.5 Flash-Lite then writes one short lowercase phrase per reference from its name and the first 180 characters of its description. Phrases containing a reference’s name head are dropped, and phrases are removed from the end until the revised description fitsℓmax=298\ell_{\max}=298characters.

Name clarification.

Leth⁡(n)h(n)denote the name head ofnn, which is the lowercased first segment ofnnafter splitting on spaces, hyphens, or em dashes. We seth(n)=⊥h(n)=\botwhen this segment has at most three characters. Name heads come from the original names of earlier skills, andztz_{t}in Eq. (9) flags a conflict. Containment is false whenh(ns)=⊥h(n_{s})=\bot. Gemini 3.5 Flash-Lite reads up to 1,400 characters of the body together withntn_{t}andngtn_{g_{t}}, and proposes a name that adds a qualifier, such as a subtopic or type of guidance. The call is repeated up to three times until it returns a parsable proposal, which is used only if it has 4 to 60 characters. Otherwise the original name is kept.

Overall procedure.

Algorithm1combines the three components into the procedure thatSkill++runs each time a skill is added (Sec.3.2). In the algorithm,PPlists the exclusion phrases in the order of𝒢t\mathcal{G}_{t}, after phrases that contain a reference’s name head are dropped. The clausee⁡(P)e(P)joins them afterDoes not coverand is empty whenPPis empty. The symbolℓmax\ell_{\max}denotes the length threshold for appending exclusion phrases. The algorithm first sets every output to its default (line 1). If earlier skills exist, it selects the reference skillgtg_{t}and writes the capability description (lines 3–4). It then ranks related skills and writes one exclusion phrase for each (lines 5–6). The incoming skill is renamed only when its name contains the head of an earlier name (lines 7–8). Exclusion phrases are dropped from the end until the metadata fitsℓmax\ell_{\max}(lines 11–13). Finally, the algorithm assemblesr~t\tilde{r}_{t}and stores the revised skill in the library and the original in the records (lines 14–16).

Algorithm 1Skill++at addition steptt1:incoming skill

ct=((nt,dt),bt)c_{t}=((n_{t},d_{t}),b_{t}); original-skill records

ℋt−1\mathcal{H}_{t-1}; skill library

ℒt−1\mathcal{L}_{t-1}; length threshold

ℓmax\ell_{\max} 2:updated library

ℒt\mathcal{L}_{t}; updated records

ℋt\mathcal{H}_{t} 3:

d^t←dt\hat{d}_{t}\leftarrow d_{t};

P←[]P\leftarrow[\,];

n~t←nt\tilde{n}_{t}\leftarrow n_{t}⊳\trianglerightdefaults

4:if

ℋt−1≠∅\mathcal{H}_{t-1}\neq\varnothingthen

5:

gt←g_{t}\leftarrowmost similar earlier skill by Eq. (7)

6:⊳\trianglerightreference skill for description and name

7:

d^t←ℳD​(nt,bt,ngt,bgt)\hat{d}_{t}\leftarrow\mathcal{M}_{D}(n_{t},b_{t},n_{g_{t}},b_{g_{t}}) 8:⊳\trianglerightcapability description,dtd_{t}if checks fail

9:

𝒢t←\mathcal{G}_{t}\leftarrowup to three earlier skills ranked by Eq. (14)

10:⊳\trianglerightreference set from synthetic queries

11:

P←ℳE​({(ns,ds)}s∈𝒢t)P\leftarrow\mathcal{M}_{E}\bigl(\{(n_{s},d_{s})\}_{s\in\mathcal{G}_{t}}\bigr) 12:⊳\trianglerightone exclusion phrase per reference skill

13:if

zt=1z_{t}=1by Eq. (9)then⊳\trianglerightshared name head

14:

n~t←ℳN​(nt,bt,ngt)\tilde{n}_{t}\leftarrow\mathcal{M}_{N}(n_{t},b_{t},n_{g_{t}})⊳\trianglerightntn_{t}if checks fail

15:endif

16:endif

17:while

|d^t⊕e⁡(P)|>ℓmax|\hat{d}_{t}\oplus e(P)|>\ell_{\max}and

|P|>0|P|>0do

18:remove the last phrase from

PP⊳\trianglerightlength threshold

19:endwhile

20:

et←e⁡(P)e_{t}\leftarrow e(P);

r~t←(n~t,d^t⊕et)\tilde{r}_{t}\leftarrow(\tilde{n}_{t},\ \hat{d}_{t}\oplus e_{t})⊳\trianglerightEq. (10)

21:

ℒt←ℒt−1∪{(r~t,bt)}\mathcal{L}_{t}\leftarrow\mathcal{L}_{t-1}\cup\{(\tilde{r}_{t},b_{t})\}⊳\trianglerightEq. (2)

22:

ℋt←ℋt−1∪{ct}\mathcal{H}_{t}\leftarrow\mathcal{H}_{t-1}\cup\{c_{t}\}⊳\trianglerightoriginal kept for later steps

23:return

ℒt,ℋt\mathcal{L}_{t},\ \mathcal{H}_{t}

Appendix BExperimental Setup

This appendix details the benchmark, the routing protocol and the baselines of Sec.4.1.

Table A1:FC@5 is the share of queries whose required skills all reach the final selection, and Recall@5 is the share of each query’s required skills that reach it, averaged over queries. The table gives both for every approach at every checkpoint of the main study with Claude Haiku 4.5. Fig.4a plots the FC@5 block, and -CFT results average three training seeds. Bold marks the best value per column and block, and underline the second.### B.1Benchmark Construction

SessionSkills in the library / evaluated queriesSRA-BenchSkillRetSkillRouterS187/4083/1282/8S2152/60200/18207/11S3224/80319/24339/15S4305/100483/30535/19S5387/120725/36758/23S6470/140996/421,015/27S7556/1601,242/481,316/30S8644/1791,552/541,610/33S9731/1981,954/601,982/37Table A2:This table gives the library size and the number of evaluated queries at every checkpoint, to compare how the three benchmarks grow. The evaluated queries are all queries released so far.Incoming skills come from the 25,626 web-collected skills of SRA-Bench and must pass three checks.

• •Similar.The name and description lie close to those of the required skill in the embedding space of all-MiniLM-L6-v2, with a cosine similarity between 0.35 and 0.95.
• •Confusable.Gemini 3.5 Flash-Lite reads only names and descriptions and ranks the candidate among the two most relevant of four skills for at least one of two queries written for the required skill.
• •Not a substitute.GPT-5.5(OpenAI, 2026a)reads a query and both bodies and never judges that the candidate can replace the required skill.

Near-duplicate candidates are then removed. We keep the BigCodeBench queries that need three or more skills and have at least 20 such candidates for every required skill, which gives 198 queries.

The 198 queries are shuffled once and released in ten sessions of 19 or 20 queries. Each session first installs the required skills of its new queries and then adds up to two candidates for every required skill installed earlier, so the library grows from 27 skills at S0 to 731 at S9 (Tab.A2), and 679 of them are incoming skills. Each skill class starts with one required skill, and every incoming skill joins the class of the required skill it resembles. For example, the guide to Python’smathmodule is joined bymath-toolsandmathat S1 and bymath-helpanddiscover-mathat S2. The library also holds seven skills that only 15 diagnostic queries outside the 198 need.

Within a session, skills are added one at a time, so each addition is one stepttof Sec.3.1. A session thus spans many steps, and each refinement also sees the skills added earlier in the same session.

B.2Routing Protocol and Metrics

All routers run at medium effort. They read up to 1,500 characters of the query and the first 300 characters of each description, in a fixed display order per query and checkpoint, and retrieval pipelines show their 50 candidates in the same order. The first call returns a shortlist of ten skills, and the second reorders it into the final ranking, which we score against the required skillsS⋆​(q)S^{\star}(q)of each queryqq.

• •FC@KKis 1 if all ofS⋆​(q)S^{\star}(q)are intopK\mathrm{top}_{K}.
• •Recall@KKis the fraction ofS⋆​(q)S^{\star}(q)intopK\mathrm{top}_{K}.

Metrics are averaged over queries, count annotated skills and give no credit to substitutes. Confidence intervals (CIs) come from a paired bootstrap(Koehn, 2004)over queries with 10,000 resamples at the 95% level unless stated otherwise. Differences and averages use unrounded values.

B.3Baselines

This section gives the inputs, models and settings of each baseline. The rewriting baselines use the generator ofSkill++, Gemini 3.5 Flash-Lite, keep the original names, and see no evaluation queries or labels.

• •Body-distilled.Rewrites the description of each incoming skill from its own name and body and sees no other skill.
• •Neighbor-contrastive.At each addition, finds the three earlier skills whose metadata is most similar to the incoming skill and rewrites their descriptions to contrast with the incoming skill, whose body the generator reads. The incoming skill keeps its original metadata. The rewrites change the descriptions of 42 of the 45 required skills.
• •R&R.Keeps the original metadata and narrows the library before the first call of the router. Qwen3-Embedding-0.6B embeds the query and the original name and description of every skill and retrieves the top 100 skills. Qwen3-Reranker-0.6B(Zhang et al., 2025c)reorders them, and the first call reads the top 50. Neither model reads skill bodies. Two kinds of variants change this pipeline, and Hybrid R&R-CFT combines both. - –Hybrid R&R.Also ranks the top 100 skills by BM25(Robertson and Zaragoza, 2009)over names and descriptions. Weighted reciprocal rank fusion(Cormack et al., 2009)withk=0k=0gives weight 0.8 to the embedding ranking and 0.2 to BM25, and the reranker then reorders the fused top 100. - –R&R-CFT.Fine-tunes the embedding model at every checkpoint on synthetic queries for the newly added skills, drawn from a pool of 6,008 queries that excludes all evaluation queries. Training uses an InfoNCE loss(van den Oord et al., 2018)with hard negatives and a replay memory of 512 earlier queries, and each update runs one epoch with batch size 16 and learning rate10−510^{-5}. Results average three training seeds within each query. The reranker stays frozen, because fine-tuning it as well lowers FC@5.
• •CC-Pages.We use the pages that the authors of this method(Wang et al., 2026b)released for SRA-Bench, unchanged. Each page adds positive triggers, negative boundaries and a discriminative body to a skill, compiled against the other skills of its cluster. Following the released code, Qwen3-Embedding-8B retrieves the ten closest skills of the current library, and Claude Haiku 4.5 reorders them in one call from their original names and descriptions with the negative boundaries. The pages were compiled over the full corpus, so they contrast skills that a session has not yet added, which favors this baseline before S9.

Appendix CEvidence for the Research Questions

This appendix gives the evidence for each RQ in the order of Sec.4.2and ends with checks of the routing protocol.

C.1RQ1: Stability and Plasticity as the Library Grows

Full results.

Tab.A1lists FC@5 and Recall@5 of every approach at every checkpoint, and its FC@5 block is plotted in Fig.4a. At S9,Skill++exceeds Vanilla by 39.9 pp and the strongest baseline, R&R-CFT, by 8.4 pp, with 95% CIs of 32.3 to 47.5 and 2.4 to 14.5. CC-Pages stays belowSkill++at every session and reaches 60.1% at S9. Most of its loss occurs at retrieval, where only ten skills reach the router.

Figure A2:Each bar splits the S9 queries of one approach by the stage at which they first lose a required skill. The skill is not among the 50 candidates from retrieval, which applies only to the retrieval baselines, or it is dropped from the shortlist or at reranking. The gray remainder, labeled with its value, holds the queries with all required skills selected and equals FC@5. Most failed queries lose a required skill before reranking.

Where required skills are lost.

Fig.A2shows that most losses under Vanilla occur when the router selects its shortlist. At S9, 58.1% of queries lose a required skill at this stage and 5.6% more at the rerank. The loss affects queries that previously succeeded, since 62 of the 115 queries routed correctly when their required skills first became available fail by S9, against 33 of 177 underSkill++. Retrieval baselines only change which candidates the router reads. Fine-tuning raises the share of queries whose 50 candidates contain every required skill from 77.8% to 91.8%, yet the router, reading the same original metadata, still misses a required skill for about a quarter of them.

Missing required skills (% of the 200 Vanilla errors)↓\downarrowComponentsSubstitutionCrowdingDiff.Excl.NameFC@5↑\uparrowAllSimilarSamenameDesc.ScopeNameAllDuplicateGenericOthersTotal36.446.028.519.09.52.06.041.518.023.512.5100.0✓53.5+17.219.0−-27.08.07.02.55.03.531.0−-10.515.016.09.5−-3.059.5✓49.5+13.139.0−-7.019.515.08.03.08.527.5−-14.010.017.510.5−-2.077.0✓42.9+6.631.5−-14.512.06.08.03.58.035.5−-6.016.519.010.0−-2.577.0✓✓61.6+25.314.5−-31.55.05.01.04.04.528.5−-13.012.016.55.5−-7.048.5✓✓64.6+28.313.5−-32.55.53.51.53.53.023.0−-18.513.010.07.0−-5.543.5✓✓56.6+20.217.5−-28.59.06.03.03.02.530.0−-11.512.018.06.0−-6.553.5✓✓✓76.3+39.96.5−-39.51.51.00.02.52.520.0−-21.58.511.54.5−-8.031.0Table A3:This table routes all eight combinations of the three components at S9 with Claude Haiku 4.5, to show how they interact. A check mark turns a component on, so the first row is Vanilla and the shaded row isSkill++. The error columns count the missing required skills by the forms and types of Fig.5, as a share of the 200 Vanilla errors. Gray numbers give the change from Vanilla in points. Bold marks the best value per column and underline the second. Diff.: description differentiation. Excl.: scope exclusions. Name: name clarification, or Name Confusion among the error types. Desc.: Description Inconsistency. Same name: Similar-Skill Confusion errors in which the incoming skill has the name of the required skill. All configurations reuse the frozen outputs ofSkill++, and the exclusions-only row appends its clause to the original description.

Incoming skills.

To test plasticity, we route 1,864 queries from the bodies of 673 refined incoming skills over the 731-skill library. The incoming skill ranks first on 56.9% of its queries withSkill++and on 51.9% with Vanilla (+5.1 pp, 97.5% CI 2.1 to 8.1).

C.2RQ2: Error Types and Counts

Error types.

Each required skill missing from the final selection at S9 receives one type. Possible substitutes go to Others first, and the remaining errors receive the first matching type below. The types fall into two forms. Insubstitution, a selected incoming skill takes the place of the missing skill. Incrowding, no selected skill resembles the missing skill, but other skills fill the slots.

• •Similar-Skill Confusion(substitution). An incoming skill for the same work, usually with the same name, takes its place, for example an incomingmatplotlibskill instead of the matplotlib guide that the query needs.
• •Scope Overreach(substitution). A broader skill, such as a toolkit or a general guide, takes the place of a dedicated skill, for exampledata-viz-plotswhile matplotlib and seaborn are left out.
• •Name Confusion(substitution). An incoming skill that matches only by name takes its place, for example amathskill that connects to a math tool instead of Python’s math module.
• •Description Inconsistency(substitution). An incoming skill that resembles the missing skill by function takes its place, and its description misstates its own body. The description may overclaim, advertising work or a scope that the body does not support, or underclaim, omitting the main purpose of the body. For example, an incomingmatplotlibskill promises animation that its body never covers. This type is checked before Similar-Skill Confusion. GPT-5.4-mini(OpenAI, 2026c)and DeepSeek-V4-Flash read the full body, and GPT-5.5 settles disagreements.
• •Duplicate Crowding(crowding). Two selected skills cover the same other part of the query and push the required skill out. This includes a broader skill selected next to the skill responsible for the same work.
• •Generic-Skill Crowding(crowding). A general-purpose skill that the query does not need, such aspython-best-practices, takes a slot.
• •Others.A possible substitute, an incoming skill that some judges consider a substitute, takes its place, or no type above applies.

Table A4:This table reports FC@5 (%) of the four other routers at every checkpoint and their mean over S1–S9 (Avg), to test whether the results of the main router hold. Each router routes the approaches of Tab.A1except Body-distilled and CC-Pages, on the same inputs. -CFT results average three training seeds. Bold marks the best value per column within each router, and underline the second. At S9,Skill++exceeds the strongest other approach in this table by 21.7, 13.6, 7.1 and 7.4 pp with GPT-5.4-mini, GPT-5.6 Luna, GPT-5.6 Sol and Qwen3.7-Flash.Table A5:This table reports Recall@5 (%) of the four other routers at every checkpoint and its mean over S1–S9 (Avg), to show how many required skills each approach keeps with other routers. The routing runs are those of Tab.A4, and -CFT results average three training seeds. Bold marks the best value per column within each router, and underline the second.

Judging.

Model judges assign the types in three steps. First, for every failed query, Gemini 3.5 Flash-Lite and DeepSeek-V4-Flash judge whether each selected incoming skill resembles a missing required skill. They read the query and both skills but not the routing result, and GPT-5.4-mini settles their disagreements. Second, the same judges decide from the skills alone whether a skill is broader or general-purpose. Third, a strict check asks whether a selected skill can in fact replace the missing one. GPT-5.6 Sol and Claude Opus 4.6(Anthropic, 2026)judge each such pair, and the skill counts as a verified substitute only if both consistently find that its body documents everything the query needs. A missing skill with a verified substitute is not counted as an error.

Counts.

In Fig.5and Tab.A3,Skill++reduces the errors from 200 to 62.

• •Name clarification.Name clarification alone reduces same-name Similar-Skill Confusion from 38 to 12 errors (19.0% to 6.0%). Changing only the names of the 81 colliding incoming skills to the clarified names raises the number of fully covered queries by 11, whereas a meaningless unique suffix lowers it by 1.
• •Description Inconsistency.Description Inconsistency accounts for 19 of the 200 Vanilla errors, 5 with differentiation alone and none underSkill++. An audit of 85 incoming skills selected under Vanilla finds 18 descriptions that misstate the body, all by overclaiming.

C.3RQ3: Other Benchmarks, Routers and Agent Harness

Other benchmarks.

We rebuild library growth on two public multi-skill benchmarks with the recipe, router and protocol of the main study.

• •Benchmarks.SkillRet(Kang et al., 2026)contributes 60 developer queries that each need three skills, andSkillRouter(Zheng et al., 2026)contributes 42 multi-skill queries. FC@5 on SkillRouter covers the 37 queries with at most five required skills. Under three addition orders, each session adds as many incoming skills per required or diagnostic skill as the main study. Because SkillRet has 139 and SkillRouter 141 required skills, against 45 required and 7 diagnostic skills in the main study, their libraries grow to 1,954 and 1,982 at S9 on average (Tab.A2). The incoming skills pass the main study’s checks.
• •Results.Vanilla falls from 88.9% FC@5 at S1 to 15.6% at S9 on SkillRet and from 80.1% to 19.8% on SkillRouter (Tab.A6).Skill++is higher at every session and ends at 30.0% and 38.7%, 14.4 and 18.9 pp above Vanilla.

Table A6:This table reports FC@5 (%) at every session on SkillRet and SkillRouter, to test whether the gains hold on other benchmarks as their libraries grow to about 2,000 skills. Values are means over three addition orders, with Claude Haiku 4.5 as the router. Bold marks the better value per column.Δ\Delta:Skill++minus Vanilla.

Random skills.

Three streams each add 679 skills sampled uniformly from the other skills of the SRA-Bench corpus to the 52 required and diagnostic skills. Vanilla then falls only from 97.0% to 84.3% FC@5, averaged over the streams. At S9, Body-distilled reaches 89.6% andSkill++93.3%, 8.9 pp above Vanilla.

Other routers.

Fig.4b–e and Tab.A4repeat the main comparison with GPT-5.4-mini, GPT-5.6 Luna, GPT-5.6 Sol and Qwen3.7-Flash(Qwen Team, 2026)at every checkpoint, on the same inputs. With all five routers,Skill++stays above Vanilla at every checkpoint (Tab.A1and Tab.A4). At S9 it gains 39.9, 22.7, 27.3, 14.1 and 11.6 pp with Claude Haiku 4.5, Qwen3.7-Flash, GPT-5.4-mini, GPT-5.6 Luna and GPT-5.6 Sol, ordered by Vanilla FC@5. This gain averages 23.1 pp, and all five 95% paired CIs exclude zero. Body-distilled, routed at S9 with Claude Haiku 4.5, GPT-5.4-mini, GPT-5.6 Luna and GPT-5.6 Sol, trailsSkill++by 31.9, 23.8, 12.2 and 9.6 pp in the order just named, 19.4 pp on average. With all four other routers,Skill++also has the highest Recall@5 at every checkpoint (Tab.A5). The approaches rank in the same order by average Recall@5 as by average FC@5, except that R&R-CFT and Hybrid R&R-CFT tie with Qwen3.7-Flash. The gaps are smaller in Recall@5, because a query that fails usually loses only some of its required skills. At S9,Skill++leads Vanilla by 11.4, 13.5, 5.6 and 4.2 pp in Recall@5 with Qwen3.7-Flash, GPT-5.4-mini, GPT-5.6 Luna and GPT-5.6 Sol, against 22.7, 27.3, 14.1 and 11.6 pp in FC@5.

Agent harness.

We repeat the growth of the main study inside Codex CLI with GPT-5.6 Luna and GPT-5.6 Sol at medium effort.

• •Setup.Each library is installed as native skill files, and the agent sees Codex CLI’s own skill list of names and descriptions, its default tools and the original task prompt. We change no tools, prompts or routing logic and only raise the skill-list budget so that all 731 skills fit. At every session, each released query starts a fresh session, and we score the first five skills the agent names with FC@5.
• •Selection.With GPT-5.6 Luna,Skill++leads Vanilla by 32.3 pp at S9 (95% CI 25.8 to 38.9) and by 34.3 pp on average over S1–S9 (Tab.A7and Fig.A3). With GPT-5.6 Sol, which already selects well over the original metadata,Skill++is higher at every session, by 11.1 pp on average and by 3.0 pp at S9.
• •Task success.We check task success on the 87-skill S1 library with 150 queries. There a workflow prompt asks the agent to name five skills before any tool call, and the hidden tests run after it writes its solution.Skill++raises FC@5 from 33.3% to 77.3% with GPT-5.6 Luna and from 82.0% to 88.0% with GPT-5.6 Sol. Hidden-test pass rates also rise, by 4.0 and 0.7 pp.

Figure A3:This figure shows FC@5 at every session in Codex CLI with GPT-5.6 Luna and GPT-5.6 Sol, to test whether the gains reach an agent harness as the library grows (values in Tab.A7).Skill++stays above Vanilla at every session with both models.Table A7:This table reports FC@5 (%) at every session in Codex CLI with GPT-5.6 Luna and GPT-5.6 Sol, to test whether the gains reach an agent harness as the library grows. FC@5 scores the first five skills that the agent names for the queries released so far, on the libraries of Tab.A2. Bold marks the better value per column.Δ\Delta:Skill++minus Vanilla.

C.4RQ4: Ablation Study

All combinations.

Tab.A3routes all eight combinations at S9, and adding a missing component raises FC@5 in all twelve cases, by 6.6 to 21.7 pp. Differentiation and exclusions together gain 25.3 pp over Vanilla, about 83% of the sum of their separate gains of 17.2 and 13.1 pp, because differentiation mainly removes substitution and exclusions mainly remove crowding (Fig.5c).

Reference choice.

With all other inputs fixed, writing differentiation against the nearest earlier skill outperforms a random earlier skill by 9.5 pp (95% CI 4.2 to 14.8) and an independent summary without references by 8.7 pp (95% CI 3.0 to 14.4).

C.5Robustness

Table A8:This table rerunsSkill++at S9 with GPT-5.6 Luna under three protocol changes and reports FC@5 before and after each change.Δ\Delta: After minus Before. Every change shifts FC@5 by at most 3.0 pp, so routing noise stays small.To check that the gains are robust to the routing protocol, we rerunSkill++at S9 with GPT-5.6 Luna under three changes to the routing protocol (Tab.A8). Shuffling the display order tests whether the router favors skills listed early. Repeating identical inputs measures the randomness of the router itself. Permuting the addition order within each checkpoint changes the earlier skills that each refinement sees, so we rebuildSkill++in both orders with GPT-5.6 Luna as the generator. The changes range from−-3.0 to +1.0 pp. These shifts are small next to the 14.1 pp by whichSkill++outperforms Vanilla with the same router (Tab.A4).