Skill evolution 88 papers

Most Skill-authoring pipelines still turn a pile of agent traces into a single block of prose. RWSA (Routing–Workflow–Semantics–Attachments) is a representation built to stop that: it splits a skill into a routing header — when the skill applies — plus three separate runtime layers: workflow (control flow, branches, verification checkpoints), semantics (each step's objective and decision rule), and attachments (tools, validation, rollback, state management). The accompanying W2S pipeline builds this bottom-up from raw evidence. It segments traces, drafts a local skill per segment, then aligns shared structure across traces of the same task — reconciling branch cases instead of averaging them away, and compressing duplication while keeping every claim tagged back to the evidence and confidence level that produced it. Before it ships, a feedback pass hunts for holes: missing branches or criteria, steps that are vague or out of order. It also flags contradictions between the routing, workflow, and semantics layers.

MLLM agents doing 3D spatial reasoning — object counting, distance estimation, route planning — call on external tools for detection, depth estimation, and 3D reconstruction. But they default to the same one or two tools no matter what the scene needs. Ask an "object-to-object distance" question and the agent answers from reconstruction evidence that encodes relative position, not the depth grounding the question actually requires. Skill-3D fixes the mismatch with memory instead of a bigger model. Every completed tool-use trajectory gets logged into a Scene Memory , successful trajectories from similar scenes distill into reusable "skills" — a trigger condition, required evidence, tool order, argument template — and failed trajectories don't get discarded; they attach to the nearest skill as lessons. Skills come in two flavors: static ones fixed as task-level priors, and dynamic ones that keep merging new successful variants and absorbing failure-driven fallback rules. The Skill Library and the Scene Memory keep refining each other as trajectories accumulate. At inference, the agent retrieves a compact slate of candidate skills by scene signature and evidence type, then a policy narrows that down to what it will actually use — before it touches a single tool.

LatentSkill replaces the standard approach of stuffing a skill's text into the prompt at every decision step with a hypernetwork that compiles the skill document directly into weights. Given the skill's text, the hypernetwork runs one forward pass and emits a skill-specific LoRA adapter — a low-rank update mounted onto a frozen Qwen3-8B backbone — so the model conditions on task history alone, with no per-step skill tokens sitting in context. It's pretrained on 171,000 deduplicated GitHub skill documents (roughly 300 million tokens), then fine-tuned with trajectory-supervised learning against teacher agent runs on ALFWorld and a multi-dataset Search-QA suite. Every result is measured against two baselines: a vanilla agent with no skill access, and an in-context skill agent that inserts the identical skill text into the prompt at each step.

Most self-evolving agent frameworks quietly assume away the hardest case: deployment with nothing but a task prompt, no example skills, no successful past runs, no verifier to grade attempts. OpenSkill is built for exactly that gap -- what it calls open-world self-evolution -- via a three-stage pipeline. Stage 1 sends the agent out to query documentation, repositories, and the web for two separate things: knowledge for building the skill, and independently checkable verification anchors -- reference values, dataset statistics, documented output formats -- that never touch the benchmark's actual answer key. Stage 2 drafts one to four candidate skills and grades them with a virtual verifier , an isolated LLM session that writes a deterministic test suite grounded in those anchors rather than in ground truth, then runs up to three rounds of failure-diagnosis-and-rewrite until a skill clears its own self-built tests. Stage 3 freezes the winner and deploys it zero-shot to a target agent; the hidden ground-truth tests get touched only at that final step, never during construction.

DataCOPE builds data-analysis skills without ever seeing a labeled example. Instead of grading trajectories against ground-truth answers, it manufactures its own quality signal out of the agent's exploration: for open-ended report tasks, an Adaptive Checklist Verifier writes a task-specific checklist, scores each report by how much of the checklist it verifiably covers, and rewrites the checklist itself whenever the agent starts gaming it; for fixed-answer reasoning tasks, an Answer Agreement Verifier clusters trajectories by their final answer and uses self-consistency — the relative size of a trajectory's answer cluster — as a secondary confidence signal. A Data-Analytic Agent samples the trajectories, the verifier sorts them into contrastive high- and low-quality groups, and a Skill Manager rewrites a Markdown skill file from that contrast, looping through generation, verification, and distillation with no human ever touching the exploration set.

Agent skills — reusable natural-language instructions that steer a model's reasoning without touching its weights — usually get built one of two ways: hand-written by a person, or extracted whole from a single successful trajectory. SkillComposer's case against both is that skill quality has two separate axes, generalization and specification, and no one-shot extraction step can serve both. So it breaks skill-writing into three trainable edits. Create turns a raw task trajectory into a skill. Merge folds two overlapping skills into one broader skill. Improve refines an existing skill against a fresh trajectory generated under its own guidance. All three train the same way, via rejection sampling : an edit only becomes training data if it lifts the executor's pass@1 by at least 0.4 over the unedited baseline. The resulting 4B-parameter composer runs three ways. Offline, create and merge build a static skill library ahead of time. Online, create and improve refine one skill per task with no library at all. Hybrid retrieves from the offline library, then specializes it per task.

MMG2Skill formalizes guide-to-skill learning : turning human-written how-tos scraped off the web — app tutorials, wiki recipes, strategy guides — into procedures a vision-language model (VLM) agent can actually execute. MMG2Skill-Bench backs the idea with 130 success-inferable tasks spread across three domains: OSWorld-style desktop GUI control (40 tasks), Minecraft crafting and building (30 tasks), and the card games Doudizhu and Mahjong via RLCard (60 tasks), each one paired with a real multimodal guide pulled from the wild. The framework itself runs as a closed loop with four stages — compile the guide into an editable SKILL.md (procedures, when they apply, what success looks like, how to recover from failure), run a fixed VLM agent conditioned on that skill file, read the resulting trajectories for root-cause diagnoses, and rewrite the skill accordingly — all without ever touching a benchmark score.

Most skills start life one of two ways: an expert writes them by hand, or an LLM generates them in a single pass from a task description. Both are cold-start methods — neither one looks at what actually happens when an agent tries to execute the skill. SkillRevise closes that loop. It runs the current skill against a real task, captures the execution trace and verifier outcome, and turns that evidence into a structured diagnosis : what the verifier actually required, which specific behaviors caused the failure, and which parts of the skill already work and must be preserved. That diagnosis is matched against a fixed bank of seven general repair principles — reusable defect patterns like malformed schema fields or an unguarded tool failure — and only the principles whose evidence conditions are satisfied get bound to this repair. The revision itself is anchored: each edit specifies exactly what executor behavior it's supposed to change, not just what text to add.

Most reusable agent skills today are pure text — instructions, reasoning traces, summarized trajectories. For GUI manipulation, layout work, counting, and other visual-centric tasks, the knowledge worth reusing is spatial: hit regions, alignment, running state. Prose alone underspecifies or discards it, a gap this paper calls the textual bottleneck . Its fix is Visual Skill , a representation that pairs declarative text logic with explicit visual support and a binding rule for when to invoke it. Visual support comes in three forms — static priors (wireframes or annotated templates that fix a spatial convention across similar screens), dynamic priors (in-situ visual traces — anchors, counting marks, visited-region overlays — that carry state between steps), and interleaved visual skills (ordered text steps bound to the exact screenshot, frame, or region that justifies each one). AutoVisualSkill , the accompanying authoring pipeline, builds these artifacts automatically from a task trajectory — packaging textual logic, visual assets, and a binding manifest into one skill directory instead of compressing everything into prose.

COLLEAGUE.SKILL turns raw traces of a person — chat logs, work documents, email, screenshots, public research material, subtitles, plus a lightweight description — into a skill package through person-grounded trace-to-skill distillation : not a simulation of the person, but a bounded, editable artifact extracted from them. Each package splits into two coordinated tracks: a capability track for practices, mental models, and decision heuristics, and a behavior track for communication style, interaction rules, and correction history. The output is five content files — a combined SKILL.md plus independently invokable work.md/persona.md and work_skill.md/persona_skill.md — wrapped in manifest.json and meta.json for install and lifecycle state, on schema version 3. It installs across four agent hosts (Claude Code, OpenClaw, Codex, Hermes) and ships three domain presets : colleague for private workplace material, celebrity/public-figure for public evidence under source boundaries, and relationship for personal traces under consent and local-control rules.

Across four Qwen3 backbones (4B, 8B, 14B, and 32B parameters), the same skill text does not transfer cleanly from one model to another. A controlled granularity study on ALFWorld makes the point sharply: moderate-detail skills help the 4B model, more detail helps the 32B model, and all three skill variants tested actually reduce the 8B model's success rate compared to giving it no skill at all. MASA (Model-Aware Skill Alignment) is the fix for that mismatch — a two-stage pipeline that rewrites skill text for each target backbone without touching its weights. Stage one runs a hierarchical skill evolution loop: general, cross-task skills get refined by hill climbing, while task-specific skills go through UCB-driven tree search that branches and prunes candidate rewrites against environment feedback. Both stages condition on a model card — a structured profile of the backbone's architecture, training provenance, and known behavioral strengths and weaknesses. Stage two distills the search trajectories into a lightweight skill rewriter that reproduces the adaptation in a single forward pass — no further search needed at deployment.

GRASP treats agent self-improvement as edits to a small, versioned skill library , not an ever-growing memory dump. When an agent fails, the failure gets a mechanism-specific label, and a proposer drafts several candidate fixes — add, modify, or remove a skill — aimed first at whichever failure type is most common. Before anything gets written into the library, each candidate has to survive a regression gate : it runs against a held-out probe of past-failing and past-passing episodes, and only sticks if it fixes more than it breaks and stays under a hard cap on new regressions. Testing spanned five base models — gpt-oss-120b, DeepSeek V4 Flash, Gemini 3.1 Flash Lite, GPT-4.1, GPT-5.4 — on two FHIR-based clinical agent benchmarks, then checked whether the mechanism holds outside medicine.

Skill0.5 stops treating every agent skill the same way. The usual binary — full skill externalization , where skills sit in the prompt at ever-growing token cost, versus full internalization, where they're baked into weights at ever-growing risk of overfitting — gets replaced with a router that reassigns each task in real time, based on the model's measured pass rate over several sampled rollouts. Tasks with zero successes go through privileged distillation : the model is rolled out first with an enriched prompt containing general, domain-agnostic skills, its successful trajectories become a teacher target, and a token-level Jensen-Shannon divergence loss trains the ordinary skill-free policy to match that teacher's output distribution — folding general strategy into the weights without paying for it at inference. Tasks with middling success get standard GRPO to push up raw success rate. Tasks that are already succeeding often — precisely where an agent is most likely to have learned a shortcut instead of actually reading the retrieved skill — get re-run with the task-specific skill deleted from the prompt; if removing it barely hurts performance, that gap gets folded into the advantage as a penalty that suppresses the shortcut. Everything runs on Qwen2.5-7B-Instruct with GRPO (group size 8) and skill retrieval via Qwen3-Embedding-0.6B.

MUSE-Autoskill wraps an LLM agent in a five-stage skill lifecycle — creation, memory, management, evaluation, refinement — instead of treating each skill as a one-off script. New skills are built through a create tool that emits a SKILL.md interface file plus optional scripts, resources, and unit tests; code-backed skills are graded on their own tests, while procedural ones go through sandboxed execution and trajectory checks. Every skill also carries a skill-level memory file where the agent appends lessons from past use, alongside short-term task memory and persistent cross-session notes; long conversations stay within budget through a DAG-based context compression scheme that summarizes or merges old turns rather than discarding them outright. A management stage periodically merges overlapping skills and prunes ones that keep failing. That setup gets evaluated across three agent runtimes — Hermes, Codex, and Claude Code — on SkillsBench (75 tasks across four domains, 5 runs each) and SkillLearnBench (100 verified instances over 20 skill-dependent tasks).

SkillGrad treats an agent's skill package — its metadata, always-loaded skill body, and conditional resource files — as a parameter to update, not a document to hand-edit. Each task run against the skill produces a trajectory; a diagnoser model reads the failures alongside contrastive successes and writes a text-based gradient — a plain-language statement of what needs to change and why. A momentum agent tracks these diagnoses across many runs and keeps only the patterns that recur, so a single bad trajectory can't swing the skill on its own. A separate patcher model executes the update as layer-aware edits : broadly useful fixes go into the always-loaded body, narrower ones into resource files that load only when needed.

Auto-Robotist is a self-evolving LLM agent for evolutionary robot design that turns each generation's simulator results into a structured, natural-language skill library instead of discarding them once the next population is bred. Each entry pairs a structural archetype — a recurring body-plan pattern — with evidence-grounded positive and negative rules, anchored to the actual evaluated designs that produced them, so the memory stays inspectable rather than folding into model weights or a population's genome. During search, the agent retrieves relevant skills to steer LLM edits of elite robot bodies, while keeping a standard genetic algorithm mutation path open for exploration. After each evaluation round, the agent maintains that library itself — adding skills earned from the newest evidence, catching and correcting ones that no longer hold, merging entries that have drifted into duplicates.

CODESKILL treats skill-bank curation as something a model learns, not a heuristic bolted onto a frozen agent. A management policy — trained through a three-stage curriculum with GRPO — watches coding-agent trajectories and decides whether to extract a new procedural skill (a high-level task strategy, or a local event-driven reaction to something like a recurring command failure), revise an existing one against new evidence, or merge and drop entries during maintenance. Three signals shape the reward: a rubric-based reward from an LLM judge scoring grounding, reusability, and actionability; sparse execution feedback on whether injecting the candidate skill actually raised the frozen downstream agent 's pass rate on held-out tasks; and an alignment check on whether the agent's behavior matched what the skill claimed to trigger. Training uses a group size of six generations per prompt, a quality-reward weight of 0.25, and a KL coefficient of 0.02, optimized against a frozen Qwen3.5-35B-A3B coding agent.

SkillEvolBench tests something more specific than whether skills help an agent — whether an agent can turn its own one-off experience into a skill worth keeping. The benchmark spans 180 tasks across six real-world environments: code debugging, tool and API orchestration, data processing, document parsing, research synthesis, and communication/scheduling. Tasks are grouped into families that separate acquisition roles — canonical, enriched, variant — from three frozen deployment roles built to stress a skill after the fact: context shift, adversarial shortcuts, and skill composition . Agents write to and revise an external skill library during acquisition under outcome- and process-based verifier feedback ; the library is then frozen before deployment tasks run, so nothing learned during evaluation can leak back into the skill being tested. Ten model configurations across three agent harnesses — Claude Code, Codex CLI, Gemini CLI — run self-generated and curated skill-writing policies against no-skill and raw- episodic-trajectory replay controls.

A full-lifecycle test bed for model-generated agent skills — experience generation, skill extraction , skill consumption — runs across five domains (ALFWorld, SpreadsheetBench, SWE-bench-Verified, SEAL-0, BFCL-v4), with six models serving as consumers — GPT-5.4 and its mini variant, Gemini-3.1-Pro and Flash-Lite, Qwen3.5-35B and 9B — five of which (all but Qwen3.5-9B, excluded as an unreliable extractor) also act as extractors. Utility is measured directly as the performance delta a skill produces on held-out tasks versus no skill at all, rolled into an Extraction Efficacy score per extractor and a Target Evolvability score per consumer. Across every extractor-target-domain combination, skills help 75% of the time — but the other 25% show negative transfer , and the risk isn't evenly spread: ALFWorld skills backfire in 47% of pairings, while SpreadsheetBench and SWE-bench-Verified hold steady at 13%. Being a strong task performer doesn't make a model a good skill writer: on SpreadsheetBench, Gemini-3.1-Flash-Lite extracts the highest-value skills despite GPT-5.4 posting the stronger raw baseline, and the same pool of extractors pays off very differently depending on which model ends up consuming the skill.

SkillOpt is a text-space optimizer : it treats an agent skill document — the natural-language file prepended to a frozen model's context — as something you train rather than hand-write. A separate optimizer model reads batches of scored rollouts, proposes bounded add/delete/replace edits under a textual learning-rate budget, and keeps an edit only when the resulting skill strictly beats the current one on a held-out validation gate . Rejected proposals don't just vanish — they land in a rejected-edit buffer , so the optimizer stops re-proposing what already failed, and every few steps a slower 'meta' update folds cross-epoch patterns into a protected region of the file that per-step edits can't touch. None of this runs at deployment — only the resulting best_skill.md ships, alongside the still-frozen target model. Testing spans six benchmarks — search QA, spreadsheet automation, office and document QA, math reasoning, and embodied tasks — seven target models from frontier-scale GPT to small Qwen, and three execution harnesses: direct chat, Codex, and Claude Code.