Skill evolution 88 papers

Skillware is Fan and Lan's name for what an agent skill actually is once you stop treating it as a prompt: a three-layer object. The Skill Artifact is just the natural-language task spec. Wrapped around it sits the Skillware Unit — an independent software identity with its own addressable name, version, compatibility record, and provenance trail. The Agent Host is whatever runtime discovers, activates, and interprets the thing. Membership in the category isn't just declared; it's tested — three necessary conditions (behavioral primacy, independent software identity, compatible host execution) checked against 15 boundary cases, 12 that should count and 3 deliberately chosen not to. The evidence behind it is a frozen corpus, SkillMD-138K: 138,133 content-deduplicated SKILL.md files pulled from 20,556 repositories, plus 13 fixed-revision case studies of real implementations.

SPyCE trains multimodal agents that think with images by distilling every successful multi-step trajectory into a two-tier hierarchical skill library , rather than collapsing it into a scalar reward or dumping it into a static memory store. Execution skills capture local visual operations as condition-action-effect rules (rotate this, crop that, zoom on this region); workflow skills capture higher-level orchestration as a bottleneck description plus a sketch for which tools to call and in what order. A separate large model (Qwen3-VL-235B) mines both tiers out of the policy's own rollouts, merging near-duplicate skills by embedding similarity and pruning execution skills whose tracked success rate drops, while workflow skills stay largely fixed once established. During reinforcement learning , the policy first retrieves a matching workflow skill, decomposes the task conditioned on it, then retrieves execution skills that fit — so what gets retrieved directly shapes the next rollout, and that rollout regenerates the library for the round after.

Self-evolving agent loops assume a reliable evaluator already exists to grade each attempt. This paper drops that assumption and evolves the evaluator itself. The metric takes shape as an expression tree of small, single-purpose drawback detectors — deterministic checks, sandboxed executions, narrow LLM judge calls — combined through AND/OR/K-of-k voting. Candidates are selected for their agreement with a tiny ten-item anchored reference set (soft labels from a teacher model), then reweighted by consensus across detectors on a much larger pool of unlabeled outputs. The final score comes from a held-out locked set that no training loop ever touches. This metric loop runs alongside a skill-evolution loop — the authors' own prior system — in a paired setup they call Double Ratchet : the evolved metric grades the skill loop's training attempts, while the skill loop's actual held-out score is measured only against the untouched locked anchor.

This survey audits 124 papers on agent skill systems published between 2023 and 2026 (2 from 2023, 19 from 2025, 103 from 2026, cutoff May 31, 2026) and builds three shared tools for comparing them. A six-sense taxonomy splits what papers loosely call a "skill" into six structurally different artifacts — executable code, natural-language instructions, SKILL.md-style packages, learned adapters, memory traces, and capability labels — each with its own edit and verification behavior. An eight-stage lifecycle architecture (evidence acquisition, proposal, verification/admission, storage, retrieval/composition, maintenance, distillation, governance) maps the design decisions that recur across systems. A ten-operator vocabulary — Add, Refine, Merge, Split, Prune, Distill, Abstract, Compose, Rewrite, Rerank — gives those changes a common language, instead of treating each update mechanism a paper introduces as a novel method in its own right.

Self-evolving agents that keep accumulating skills need a curator — a mechanism that retires a skill once its observed pass rate drops to a set threshold, which is what keeps a growing library from drifting below a no-skill baseline. That non-divergence guarantee, built into the Ratchet governance recipe this paper extends, assumes the judge scoring each trial is unbiased. Reference-free tasks like long-form report writing have no ground truth to check answers against, so the only available judge is an LLM judge — and LLM judges run systematically biased, not just noisy. That bias splits into two distinct failure modes, mathematically and behaviorally: symmetric noise, where labels flip in either direction at random, and false-pass bias , where real failures get reported as passes. Both get tested on a 155-slice citation-grounded report-writing testbed — a deterministic five-check grader stands in for ground truth, with corruption injected on top — then cross-checked on MBPP+ code generation, where unit tests play the same role.

MetaSkill-Evolve doesn't stop at letting an agent revise its own skills — it lets the agent revise the machinery that does the revising. Each search branch pairs a task skill with a meta-skill : five components (Analyzer, Retriever, Allocator, Proposer, Evolver) that define how rewriting happens in the first place. Task skills update every iteration; the meta-skill updates only every H iterations, on a slower clock, and it does so by running that same five-agent pipeline on itself — one level of recursion, no separate model or training objective. Frontier selection then decides which branch to expand next, weighing the skill's current utility against an estimate of meta-productivity (how much gain the meta-skill has recently been producing) and a cooling term that keeps any one branch from dominating the search.

Skill optimization here becomes a form of zeroth-order optimization : treat a skill document as a text parameter that execution feedback nudges, no gradient required. The authors map existing self-evolution methods — single-trace reflection, contrastive diagnosis, coordinate-wise edits, edit-budget decay — onto the classical zeroth-order toolbox, then note what separates an agent rollout from blind numerical perturbation: a rollout is a readable trajectory, planning steps and tool calls and error messages all visible, which turns optimization into targeted debugging rather than random search. Working from PAC-learning theory and an "everything is a file" systems philosophy, they distill the requirements for a skill-optimization loop that actually generalizes down to three: store each rollout as its own flat file instead of folding it into a pooled batch, mine consensus across several failures instead of patching from one (skip this and a stability coefficient in their analysis inflates the generalization error), and gate every candidate edit against a validation set that never overlaps the training failures. Strip out everything else — mini-batch reflection pooling, textual learning-rate decay, rejected-edit buffers — and what's left is SkillOpt-Lite: stage the trajectory, explore with shell tools, mine consensus and write a minimal patch, validate and gate. Four steps, run by a standard coding agent.

ComfyClaw treats ComfyUI workflow construction as typed graph editing, not prompt rewriting. An agent inserts and connects nodes, tunes samplers, attaches LoRAs, and applies regional conditioning; invalid edits get reverted automatically. A region-level VLM verifier decomposes each prompt into a checklist of binary requirements, scores the image against them plus a holistic 1-10 detail score, and turns any failures into localized repair instructions — regional prompting to isolate a specific limb, for instance — that drive the next edit pass. Successes and failures get clustered across batches of prompts and distilled through a skill evolution loop that creates, revises, reinforces, merges, or deletes entries in a library of versioned Agent Skills , with each candidate mutation tested on synthesized held-out prompts and committed only if it doesn't degrade held-out performance.

Most agent skill libraries come from one medium — hand-written instructions, or traces an agent left behind after solving a task once. Resource2Skill goes wider: it mines the tutorials, code repositories, articles, and reference files humans already produce for seven software-authoring domains — slide decks, spreadsheets, web pages, Blender scenes, Reaper audio projects, CAD drawings, Unreal Engine 5 builds — and runs each through multimodal skill distillation . A resource becomes a skill entry that keeps its structured instructions, a code snippet, a visual example, and provenance metadata bundled together. Entries land in a hierarchical Skill Wiki that an agent searches and composes from at task time. When nothing in the wiki fits, the same pipeline runs live as online skill acquisition , minting a new skill on the spot instead of leaving the agent to improvise.

EvoClawBench asks a narrow, closed-loop question: can an agent turn evidence from its own task runs into a reusable skill that makes a fresh run better, after paying the cost of authoring it? The benchmark spans 100 tasks (502 sub-problems) across coding, data, office, security, operations, and domain-document workflows — finance, legal, healthcare, procurement and more. Every task runs through three conditions: a direct baseline with no skill involved, PreSkill (write a skill before ever attempting the task, then solve using only that skill), and PostSkill (attempt the task once, then summarize a skill from that run's evidence and solve again in a fresh workspace). Two agent runtimes, OpenClaw and nanobot, each ran five model backends — GPT-5.4, GPT-5.4 mini, Qwen3.6-Plus, DeepSeek-V4-Pro, and MiniMax-M2.7 — through all three conditions on identical tasks.

RATs (Robotics Agent Teams) gives a robot a practice stage before it's ever handed a task — a multi-agent Code-as-Policy system built around three coordinating roles. A task proposer invents exploratory goals, an execution team writes and runs candidate robot code with step-level verification and retry-on-failure, and a memory team distills what worked into a persistent skill library . Task selection isn't random: a "Goldilocks" score multiplies novelty (how rarely a given object-skill pairing has been attempted) by learnability (how close the agent's current success rate on that skill sits to 50%), pushing practice toward the edge of what the agent can already half-do. It's intrinsic motivation from developmental psychology, rebuilt as a computable scoring function instead of a vague heuristic.

OpenClaw-Skill builds a searchable tree of skills instead of a flat library. Its construction method, Collective Skill Tree Search (CSTS), breaks a long-horizon agentic task into an ordered chain of subtasks. For each one, several heterogeneous LLMs attempt it independently, and each resulting trajectory gets distilled into a candidate skill node. Every candidate is scored twice. A collective quality score averages judgments across multiple judge models; a transferability score hands the skill to models that never produced it and checks how well those outsiders perform using it as guidance. Only the top-scoring node per subtask survives into the tree, and the surviving path becomes supervised training data. Collective Skill Reinforcement Learning (CSRL) then layers a GRPO -style policy update on top: rollouts conditioned on different candidate skills for the same subtask are normalized against each other as one group, so the policy learns to prefer whichever skill actually worked, not whichever one it happened to sample.

SkillWiki treats an agent skill as a governed, versioned asset, not a stored prompt or memory snippet — the same move Wikipedia made for articles and Git made for code. The system ingests five kinds of raw material (trajectories, documents, API specifications, scripts, and historical skill files), then runs them through a knowledge-grounded construction pipeline that extracts reusable actions and workflows while keeping every skill linked back to its originating evidence via a Skill Provenance Graph . Each skill carries a lifecycle state — one of eight, from Raw Experience and Candidate through Verified, Released, Degraded, Deprecated, and Archived — and sits in a three-tier taxonomy of atomic, functional, and strategic skills. Nothing changes directly: edits pass through a Git-style governance workflow of candidate diffs, review, and release, run largely by autonomous self-management agents that flag breaking changes, with humans holding override authority at every step.

SkillAudit evolves an agent skill with no labeled outcomes to train against. The core mechanism, paired trajectory auditing , runs the same task twice per iteration — once with the candidate skill injected, once without — and treats whatever diverges between those two runs as the entire training signal. Twelve evaluators, bundled under the name Process-Aligned Contrastive Evaluation (PACE), read that divergence along four axes: procedural adherence, artifact correctness, format consistency, and where the skill measurably helped. Each verdict cites a specific passage in the skill document, quoting it directly rather than gesturing at it. A separate, frozen structural verifier — compiled once from the task spec and never touched again — checks hard constraints like file existence and format compliance, and can veto or roll back an edit that makes things worse. From there, edits split into two modes: Refine strips noise from a skill that's already broadly working; Repair replaces passages that actively fight what the task needs.

E-commerce visual assistants take one uploaded photo and have to route it to wildly different behaviors — product search, style advice, an encyclopedia lookup, a plain utility call — and each one needs its own response shape, tool calls, and domain constraints. SkillChain takes the hand-authored behavioral spec for each intent (a "Skill") and makes it evolve on its own, through three linked stages. A Skill Creator bootstraps an initial Skill Bank from task specs and real user trajectories behind a human reflection gate. A Route Optimizer mines live routing failures — ambiguous intent boundaries, missing skills, parsing errors — and updates, merges, or discards Skill descriptions, with a provable guarantee that routing F1 never regresses round over round. A Body Refiner closes the loop on content quality: a dual-path evaluator pairs rule-based structural checks with an LLM-as-judge that scores every response on four axes — tool-call rationality, card-composition compliance, content quality, constraint adherence — then aggregates that signal across many queries before rewriting the Skill body.

Notes2Skills runs lab notebooks through two stages before any of it reaches an agent. Stage 1, epistemic directive extraction (EDE), scans free-text notes and tags each statement as FACT, JUDGMENT, or SUGGESTION, then sorts it into one of five directive types: flag data for review, note a condition change, suggest an analysis step, revise a protocol, or adjust a parameter. Stage 2, MetaSkill compilation , turns those labeled directives into agent-loadable Markdown skills, where each one keeps its certainty tag plus a SHA-256 hash pointing back to the exact source excerpt. They validated the pipeline against 461 hand-annotated segments across three corpora — informal free-form lab notes on one end, formal wet-lab protocols on the other.

This survey traces how agent skills — packaged, reusable procedures that let LLM agents execute domain tasks — move from one-off authoring to systematic evaluation and revision. Skill-improvement methods sort into four paradigms: execution feedback (single-run signals, where systems like SkillForge and CoEvoSkills compare executed behavior against a reference and separate failure diagnosis from rewriting), trajectory distillation (patterns pulled from many runs, as in SPARK and Trace2Skill), library-level compression that merges or prunes redundant skills, and reinforcement learning that scores skill value against task-level reward. The same survey catalogs six families of skill-centric benchmarks — utility, generation, retrieval and routing , safety auditing, software engineering, and real-world deployment — noting what each one measures and how large it is.

SkillAxe treats skill quality as a diagnosis problem, not a rewriting problem. It runs each task twice — once with a skill injected, once without — and scores the gap along four axes. An LLM judge calls the direction and magnitude of the quality shift. Trigger precision checks how cleanly a skill's description separates tasks that should activate it from ones that shouldn't, measured as embedding-space distance between positive and negative trigger phrases. Instruction compliance gets a fault attribution pass that splits a broken rule into two diagnoses: the agent ignored good guidance, or the guidance itself was bad. And solution-path coverage asks how much of the space of valid approaches a skill's content actually supports. None of this needs ground-truth labels, hand-written test suites, or environment reward signals — the improvement brief comes entirely from comparing agent behavior with and without the skill.

SkillHone treats agent skill maintenance as a logging problem, not an editing one. Every development step — probe run, diagnosis, candidate revision, accept or reject — gets written down as a structured record, and the growing chain becomes a persistent decision history that later sessions query instead of re-deriving from scratch. Two role-separated subagents split the actual work: an evaluation team sees the full oracle targets, validators, and execution traces for a probe but can never touch the skill file, while an optimization team can rewrite the skill but only ever reads a redacted report of what evaluation found. A dispatcher just routes messages between the two and logs outcomes; it holds no repository-write authority of its own.

The working assumption behind skill-augmented agents — write a reusable procedural note into a retrievable skill bank , retrieve it on a later task — is that a stronger model writes a more trustworthy skill. Zhang and coauthors test that assumption directly, and it fails: skills GPT-5.4 writes while training agents on ALFWorld and WebShop carry a mean marginal utility near zero, even though a real subset of them helps and the rest actively hurts. The catch is that once a skill lands in the bank, its effect on later rollouts tangles up with every other skill retrieved alongside it — there's no clean signal for what any single skill contributed. Their framework, SAPO (Skill-Augmented Policy Optimization), tests each candidate before it reaches long-term memory. For a given task and its currently retrieved skills, SAPO splits the normal rollout budget into two matched halves: base rollouts run under the existing skill context alone, skill-augmented rollouts run under that same context plus one new candidate drawn from the base trajectories. The reward gap between the two halves is the candidate's marginal value in that exact context, computed from rollouts the training loop was already generating — validation costs nothing extra.