Skill Self-Evolution in Agent Systems

• Skill self-evolution is a design pattern where agents improve external, explicit skill artifacts through closed-loop updates rather than solely relying on static model parameters.
• It follows a lifecycle of creation, revision, consolidation, and reuse, employing rigorous validation and modular operations to optimize performance.
• Empirical studies in robotics, web automation, and coding demonstrate significant gains in task success, underscoring its practical impact on agent capabilities.

Searching arXiv for papers on skill self-evolution and related agent skill frameworks. Skill self-evolution denotes a family of mechanisms in which an agent improves its reusable procedural layer from execution experience rather than relying only on fixed skill libraries or model-parameter updates. Across recent systems, the evolving object is not uniform: it may be a robotic skill repository, a bank of SKILL.md procedures, a library of Playwright APIs, a set of memory skills, a filesystem of skill folders, or even a task-specific rubric for judging correct skill use. What unifies these systems is the conversion of trajectories, failures, verifier outputs, or interaction traces into explicit artifacts that can later be retrieved, revised, merged, deleted, composed, or routed at inference time (Xie et al., 3 Mar 2026, Ouyang et al., 7 May 2026, Zhu et al., 2 Jul 2026, Zhang et al., 2 Feb 2026).

1. Conceptual scope and evolving artifacts

Recent work uses the term “skill” for reusable execution modules, procedural memories, workflows, APIs, and evaluation procedures, but the common move is to make those objects explicit, persistent, and revisable. In Uni-Skill, the evolving object is a robotic skill repository grounded in a hierarchical taxonomy and large-scale demonstrations. In COMFYCLAW, an “Agent Skill” is a SKILL.md procedure for editing a ComfyUI workflow graph. In SkillOS, a skill is a simplified SKILL.md-style Markdown file with YAML frontmatter and Markdown instructions. In CODESKILL, the bank contains task-level and event-driven procedural skills. In SkillWeaver, a skill is a Python function containing Playwright code for a browser automation. In SkillCoach, the evolving object is not the skill document itself but a skill-grounded process rubric. In MemSkill, the skills are memory-management routines rather than external-task procedures (Xie et al., 3 Mar 2026, Li et al., 2 Jul 2026, Ouyang et al., 7 May 2026, Li et al., 25 May 2026, Zheng et al., 9 Apr 2025, Zhu et al., 2 Jul 2026, Zhang et al., 2 Feb 2026).

System	Evolving artifact	Characteristic operations
Uni-Skill	Hierarchical robotic skill repository	request new skill, retrieve demonstrations, expand repository
COMFYCLAW	SKILL.md workflow procedures	create, revise, reinforce, merge, delete
SkillOS	Markdown skills in SkillRepo	insert, update, delete
CODESKILL	Task-level and event-driven skills	generate, evolve, add, merge, drop
SkillWeaver	Playwright APIs	discover, practice, synthesize, hone
EmbodiSkill	Skill body plus appendix	targeted body revision, appendix reinforcement
MemSkill	Memory skills	select, refine, add
SkillCoach	Skill-grounded rubrics	patch, validate, accept or reject

This diversity clarifies that skill self-evolution is not a single algorithmic template. It is a design pattern in which reusable behavioral knowledge is externalized into inspectable artifacts and then improved under downstream evidence. A recurrent implication is that long-term improvement is pushed into a layer that is more transparent and easier to revise than latent model weights. AutoSkill makes this explicit by defining self-evolution as external capability evolution through explicit skill artifacts, and MUSE-Autoskill similarly treats skills as long-lived, experience-aware, and testable assets rather than isolated static artifacts (Yang et al., 1 Mar 2026, Lin et al., 26 May 2026).

2. Canonical lifecycle: creation, revision, consolidation, reuse

A common lifecycle begins with extraction or creation from trajectories, followed by revision, consolidation, and later reuse. SkillComposer makes this structure explicit by decomposing skill construction into three learnable operations—create, improve, and merge—thereby separating the pressures of specification and generalization (Zhang et al., 4 Jun 2026). SkillOS casts long-horizon curation as repository editing with insert, update, and delete, while COMFYCLAW uses the mutation space $\{create, revise, reinforce, merge, delete\}$. CODESKILL operationalizes a similar lifecycle through extraction, evolution, and maintenance decisions add, merge, and drop (Ouyang et al., 7 May 2026, Li et al., 2 Jul 2026, Li et al., 25 May 2026).

The lifecycle is often formalized as an explicit update over a skill bank. AutoSkill gives the update rule

$$\mathcal{B}_u^{t+1} = \begin{cases} \mathcal{B}_u^t \cup \{z_t\}, & a_t = add,\ (\mathcal{B}_u^t \setminus \{s_t^\ast\}) \cup \{s_t'\}, & a_t = merge,\ \mathcal{B}_u^t, & a_t = discard. \end{cases}$$

where a candidate skill $z_t$ is extracted from recent user queries, compared to nearby existing skills, and either added, semantically merged, or discarded (Yang et al., 1 Mar 2026). This same add-or-refine logic reappears in coding, memory, and workflow agents, even when the local mutation names differ.

Several systems extend creation into on-demand synthesis during execution. Uni-Skill’s planner reasons over an expandable action vocabulary and outputs

$$(O_t, I_t, \{L_\text{base}, L_\text{ext}\}) \overset{\mathcal{P}}{\Longrightarrow} \{\pi_i, p_i\}_{i=1}^N,$$

so the planner may request a new skill $\pi_i \in L_\text{ext}$ when the current base library is insufficient (Xie et al., 3 Mar 2026). MUSE-Autoskill adopts a related runtime stance: if no existing skill is sufficient, the built-in skill_create mechanism synthesizes a new skill package, tests it, and registers it only if evaluation succeeds (Lin et al., 26 May 2026).

This suggests that “self-evolution” is best understood as a closed loop of capability gap detection, artifact synthesis, downstream testing, and repository update, rather than as one-shot extraction from isolated successful traces.

3. Representations, repositories, and structural organization

The explicit representation of a skill is central to all recent systems. Many agent frameworks standardize around SKILL.md or Markdown-like files with a name, description, trigger conditions, and procedural body. SkillOS uses YAML frontmatter plus Markdown instructions; COMFYCLAW exposes only lightweight skill metadata at startup and retrieves the full body on demand via read_skill; MUSE-Autoskill stores each skill as a directory rooted at a kebab-case skill name with SKILL.md and optional scripts/, tests/, resources/, and references/ (Ouyang et al., 7 May 2026, Li et al., 2 Jul 2026, Lin et al., 26 May 2026).

Other systems adopt more structured repositories. Uni-Skill’s SkillFolder is a four-layer hierarchy inspired by VerbNet: $\mathcal{N}_1$ for abstract VerbNet classes, $\mathcal{N}_2$ for verb instances, $\mathcal{N}_3$ for object-centric skill descriptions, and $\mathcal{N}_4$ for fine-grained demonstration slices $\sigma$. The repository contains 106 VerbNet classes and 1,659 unique skill descriptions, and newly recognized examples are inserted by top-down alignment and tree expansion (Xie et al., 3 Mar 2026). SkillPyramid similarly organizes a skill collection $$\mathcal{B}_u^{t+1} = \begin{cases} \mathcal{B}_u^t \cup \{z_t\}, & a_t = add,\ (\mathcal{B}_u^t \setminus \{s_t^\ast\}) \cup \{s_t'\}, & a_t = merge,\ \mathcal{B}_u^t, & a_t = discard. \end{cases}$$0 into a hierarchical pyramid $$\mathcal{B}_u^{t+1} = \begin{cases} \mathcal{B}_u^t \cup \{z_t\}, & a_t = add,\ (\mathcal{B}_u^t \setminus \{s_t^\ast\}) \cup \{s_t'\}, & a_t = merge,\ \mathcal{B}_u^t, & a_t = discard. \end{cases}$$1, with lower layers holding atomic capabilities and upper layers holding abstract task schemas, while new skills are folded back through downward extraction and upward induction (Xiong et al., 2 Jun 2026).

Topology is also used to control inference-time context. SkillCAT compiles evolved skills into a routable sub-skill topology so inference loads only capability nodes relevant to the task, addressing the context-overload problem that arises when entire merged skill corpora are injected indiscriminately (Chen et al., 11 Jun 2026). A related retrieval economy appears in COMFYCLAW and MUSE-Autoskill through progressive disclosure: only names and descriptions are surfaced eagerly, and full instructions are loaded only after relevance has been established (Li et al., 2 Jul 2026, Lin et al., 26 May 2026).

Several works extend the representation with persistent experience. MUSE-Autoskill adds a sibling .memory.md per skill to store notes, lessons, and usage observations accumulated across tasks, while SkillWeaver places prior usage logs and caveats directly in API docstrings, turning the skill into a joint procedural-and-experiential artifact (Lin et al., 26 May 2026, Zheng et al., 9 Apr 2025).

4. Validation, attribution, and control of harmful updates

A major theme in recent work is that naive accumulation is unreliable. SkillCoach argues that final verifier success is too coarse because an agent may pass through trial and error while selecting distractor skills, skipping required steps, composing workflows incorrectly, or omitting final checks. It therefore separates process quality from external outcome with a rubric over four dimensions—skill selection, skill following, skill composition, and skill-grounded reflection—and evolves the rubric itself through localized patches accepted only under validation-gated constraints (Zhu et al., 2 Jul 2026).

SkillCAT makes validation explicit at the patch level. For a candidate patch $$\mathcal{B}_u^{t+1} = \begin{cases} \mathcal{B}_u^t \cup \{z_t\}, & a_t = add,\ (\mathcal{B}_u^t \setminus \{s_t^\ast\}) \cup \{s_t'\}, & a_t = merge,\ \mathcal{B}_u^t, & a_t = discard. \end{cases}$$2, replay on source-task clones yields a baseline outcome $$\mathcal{B}_u^{t+1} = \begin{cases} \mathcal{B}_u^t \cup \{z_t\}, & a_t = add,\ (\mathcal{B}_u^t \setminus \{s_t^\ast\}) \cup \{s_t'\}, & a_t = merge,\ \mathcal{B}_u^t, & a_t = discard. \end{cases}$$3 and replay outcome $$\mathcal{B}_u^{t+1} = \begin{cases} \mathcal{B}_u^t \cup \{z_t\}, & a_t = add,\ (\mathcal{B}_u^t \setminus \{s_t^\ast\}) \cup \{s_t'\}, & a_t = merge,\ \mathcal{B}_u^t, & a_t = discard. \end{cases}$$4, and the assessment score is

$$\mathcal{B}_u^{t+1} = \begin{cases} \mathcal{B}_u^t \cup \{z_t\}, & a_t = add,\ (\mathcal{B}_u^t \setminus \{s_t^\ast\}) \cup \{s_t'\}, & a_t = merge,\ \mathcal{B}_u^t, & a_t = discard. \end{cases}$$5

With threshold $$\mathcal{B}_u^{t+1} = \begin{cases} \mathcal{B}_u^t \cup \{z_t\}, & a_t = add,\ (\mathcal{B}_u^t \setminus \{s_t^\ast\}) \cup \{s_t'\}, & a_t = merge,\ \mathcal{B}_u^t, & a_t = discard. \end{cases}$$6, only patches that repair failure or preserve success are merged (Chen et al., 11 Jun 2026). COMFYCLAW adopts a related safeguard at the library level: for each cluster $$\mathcal{B}_u^{t+1} = \begin{cases} \mathcal{B}_u^t \cup \{z_t\}, & a_t = add,\ (\mathcal{B}_u^t \setminus \{s_t^\ast\}) \cup \{s_t'\}, & a_t = merge,\ \mathcal{B}_u^t, & a_t = discard. \end{cases}$$7, a proposed mutation is accepted only if held-out validation does not degrade performance, $$\mathcal{B}_u^{t+1} = \begin{cases} \mathcal{B}_u^t \cup \{z_t\}, & a_t = add,\ (\mathcal{B}_u^t \setminus \{s_t^\ast\}) \cup \{s_t'\}, & a_t = merge,\ \mathcal{B}_u^t, & a_t = discard. \end{cases}$$8, and rejected mutations are rolled back (Li et al., 2 Jul 2026). MemSkill likewise keeps snapshots of the best-performing skill bank and reverts if updated skills reduce the stabilized tail reward (Zhang et al., 2 Feb 2026).

Embodied environments make attribution especially difficult. EmbodiSkill argues that a failed embodied trajectory may reflect either a true skill defect or an execution lapse in which the agent failed to follow valid guidance. It therefore classifies reflections into Discovery, Optimization, SkillDefect, and ExecutionLapse, allowing only the first three to alter the skill body while ExecutionLapse updates an appendix that reinforces already valid guidance (Ju et al., 11 May 2026). This is a strong counterexample to the common assumption that every failure should trigger broad skill rewriting.

Taken together, these mechanisms show that self-evolution is not simply growth; it is controlled growth under replay, held-out validation, rollback, or process-aware diagnosis.

5. Domain-specific realizations and empirical record

Robotic manipulation provides one of the clearest demonstrations of dynamic skill extension. Uni-Skill was proposed precisely because fixed robotic API libraries fail on tasks such as folding cloth, stirring, unplugging, closing drawers, or rotating lids. On RLBench within-library tasks, Uni-Skill achieved an average success rate of $$\mathcal{B}_u^{t+1} = \begin{cases} \mathcal{B}_u^t \cup \{z_t\}, & a_t = add,\ (\mathcal{B}_u^t \setminus \{s_t^\ast\}) \cup \{s_t'\}, & a_t = merge,\ \mathcal{B}_u^t, & a_t = discard. \end{cases}$$9 versus $z_t$0 for CaP with GPT-4o. On 10 out-of-library RLBench tasks, CaP reached $z_t$1, MOKA $z_t$2, and Uni-Skill $z_t$3. On a Franka Emika robot across 8 task categories, Uni-Skill attained an average success rate of $z_t$4 versus $z_t$5 for MOKA (Xie et al., 3 Mar 2026).

Web and coding domains show a related pattern. SkillWeaver improved average success on WebArena from 22.6 to 29.8, a reported relative gain of 31.8%, and on real-world websites from 40.2 to 56.2, a reported relative gain of 39.8%; APIs synthesized by GPT-4o also improved GPT-4o-mini by up to 54.3% on WebArena (Zheng et al., 9 Apr 2025). CODESKILL improved average pass rate by 9.69 over the no-skill baseline and by 4.01 over the strongest prompt-based or memory baseline while keeping the skill bank at a stable size during iterative construction (Li et al., 25 May 2026). EvoSkill improved OfficeQA exact-match accuracy from 60.6% to 67.9% and SealQA from 26.6% to 38.7%, while a SealQA-evolved search skill transferred zero-shot to BrowseComp with a 5.3% accuracy gain (Alzubi et al., 3 Mar 2026).

Workflow and general agent settings likewise benefit from lifecycle-managed skills. COMFYCLAW achieved the best average image-generation evaluation score across all six agent configurations and produced 318 unique evolved skills and 4,768 skill versions; 318 evolved skills accounted for roughly $z_t$6 of later skill invocations (Li et al., 2 Jul 2026). Skills-Coach raised the average Skill-X score from $z_t$7 to $z_t$8 and pass rate from $z_t$9 to $$(O_t, I_t, \{L_\text{base}, L_\text{ext}\}) \overset{\mathcal{P}}{\Longrightarrow} \{\pi_i, p_i\}_{i=1}^N,$$0 by iteratively optimizing skill instructions and code under traceable evaluation (Tian et al., 30 Apr 2026). SkillComposer-4B improved a 27B executor by up to +4.5 on agent tasks and +3.4 on code tasks, showing that a small trained composer can evolve skills that help a larger frozen executor (Zhang et al., 4 Jun 2026). SkillOS, which learns a curator over grouped task streams, outperformed memory-free and strong memory-based baselines across ALFWorld, WebShop, and reasoning tasks (Ouyang et al., 7 May 2026).

Embodied, memory, and evaluator-centric formulations broaden the empirical picture. EmbodiSkill enabled a frozen Qwen3.5-27B executor to reach 93.28% task success on ALFWorld, outperforming GPT-5.2 used as a direct agent without skills by 31.58% (Ju et al., 11 May 2026). MemSkill improved over strong memory baselines on LoCoMo, LongMemEval, HotpotQA, and ALFWorld by learning and evolving memory skills rather than keeping a static set of memory operations (Zhang et al., 2 Feb 2026). SkillCoach showed that evolved rubrics improved gold-keypoint coverage from 71.56 to 83.70 and filtering consistency from 82.00 to 96.00, indicating that the self-evolving object can be the evaluator that supervises skill use rather than the skill artifact alone (Zhu et al., 2 Jul 2026).

6. Misconceptions, limitations, and open directions

A recurring misconception is that skill self-evolution is equivalent to online model self-improvement. Most of the recent literature explicitly keeps the executor frozen and evolves external artifacts instead: skill folders, Markdown procedures, APIs, repositories, rubrics, or memory skills. SELF is a notable exception, because it couples meta-skill learning for self-feedback and self-refinement with iterative fine-tuning on self-curated data, thereby evolving both direct task competence and the model’s critique-and-revise meta-skills (Lu et al., 2023). This suggests that “skill self-evolution” now names at least two partially distinct lines: external artifact evolution and internalized self-correction.

Another misconception is that these systems are autonomous learning from scratch. Uni-Skill’s deployment-time evolution depends on SkillFolder, which is built offline from 350 hours of DROID demonstrations plus external models such as Gemini-2.0-Flash, GPT-4o, CLIP, and a VerbNet parser (Xie et al., 3 Mar 2026). Skills-Coach is described as “training-free GRPO,” but the method is concretely a variant-generation and comparative-selection process over synthetic tasks derived from Skill.md and Readme.md, not a fully specified gradient-based RL procedure (Tian et al., 30 Apr 2026). SkillWeaver acknowledges that verification can be gamed by suppressing exceptions rather than making a browser skill truly robust (Zheng et al., 9 Apr 2025). MUSE-Autoskill reports successful self-created skills for 35 of 51 tasks, or 68.6%, which shows meaningful but incomplete generation coverage (Lin et al., 26 May 2026). AutoSkill provides large-scale extraction evidence from WildChat-1M but does not provide controlled downstream benchmarks demonstrating end-task improvement with and without evolution (Yang et al., 1 Mar 2026).

Collaboration, privacy, and heterogeneity constitute a further line of tension. FederatedSkill replaces trajectory sharing with semantic skill diffs

$$(O_t, I_t, \{L_\text{base}, L_\text{ext}\}) \overset{\mathcal{P}}{\Longrightarrow} \{\pi_i, p_i\}_{i=1}^N,$$1

and uses a server-side evolution agent to personalize library updates rather than imposing a global shared skill library. It reports up to a 44.4% increase in success rate and a 37.5% reduction in computational cost, but it also states that privacy is empirical rather than formally guaranteed, assumes honest participants, and documents negative-transfer cases under cross-model sharing (Yang et al., 2 Jun 2026). This suggests that future progress will depend not only on better extraction or refinement, but also on repository topology, selective transfer, stronger validation, and explicit governance of conflicting or stale skills.

Overall, the literature converges on a common lesson: skill self-evolution is most effective when skills are treated as first-class, testable, routable, and revisable assets. The open technical question is no longer whether trajectories can be summarized into reusable guidance, but how to do so while preserving causality, generalization, validation discipline, and deployment-time relevance.