Skill evolution 88 papers

Agent skills aren't single prompts — they're multi-field specs bound by hard platform limits: a description field truncated at 1,024 characters for routing, an instruction body capped at 5,000 characters and chopped down further via progressive disclosure , and a context budget shared with whatever other skills are co-resident. Optimizing a skill means hitting several of these targets at once, not just raising one accuracy score. Prior prompt optimizers dodge that reality — they either ignore the constraints outright or collapse performance and compliance into a single weighted number, which throws away any solution sitting in a non-convex fold of the trade-off surface. MOCHA replaces that weighted sum with Chebyshev scalarization : minimize the worst weighted gap to an ideal point, a formulation that reaches every point on the Pareto front , non-convex regions included. An exponential annealing schedule rides on top, letting the search roam broadly early and lock onto a specific trade-off direction as the budget runs out.

HASP turns each stored agent skill into a small executable module called a Program Function (PF): a should_activate() check that watches the agent's current state and proposed next action, paired with an intervene() step that either rewrites the action outright or injects corrective context back into the reasoning trace. An external agent harness wraps the base policy (Qwen2.5-7B-Instruct throughout), retrieves candidate PFs at every step, and lets them fire before the action executes — no fine-tuning required to see a benefit. The same interface does double duty: each firing logs the original action, the repair, and the downstream effect, which becomes training signal for post-training via SFT, rejection sampling , or on-policy distillation , and recurring failures get mined into new candidate PFs that must clear executable validation plus a teacher's review before joining the shared skill library.

SkillsVote treats the full lifecycle of an agent skill — collection, recommendation, attribution, and evolution — as one governance problem instead of four separate ones. The starting point is a million-scale open-source skill corpus, profiled for what environment each skill assumes, how well-formed it is, and whether its claims can actually be checked; only skills that clear the verifiability bar get synthetic tasks built against them. At use time, an agent skips flat similarity lookup and instead runs agentic library search over structured skill folders, surfacing the instructional context a task needs before execution starts.

SkillTTA treats skill-building as test-time adaptation : instead of shipping one skill per task family, it keeps a pool of past training trajectories, both successes and failures, tagged with lightweight, answer-free task metadata. At test time it embeds the incoming task and does trajectory retrieval , pulling a small top-k set of the most similar past runs by cosine similarity. A synthesis model then turns the current task plus that retrieved evidence into a one-off skill file, covering when to use it, likely failure modes, and non-prescriptive procedure notes, that a fixed solver conditions on for that single task; no weights change. Benchmarks pit this against a static skill library baseline that synthesizes one skill per trajectory cluster and reuses it as-is, plus a memory-learning baseline that updates through repeated interaction, across spreadsheet editing (SpreadsheetBench), household tasks (ALFWorld), and code generation (BigCodeBench).

LLM agents that keep a library of reusable skills eventually run into a problem invisible at the single-skill level: skills get added, patched, reused in new contexts, and wired to shifting dependencies until the library itself degrades. Call it skill technical debt — library-level defects (near-duplicate skills, stale interfaces, missing validators, broken dependency chains) that don't break any one skill locally but quietly corrode future retrieval, composition, and execution. SkillOps is the maintenance layer built to catch it, and it's method-agnostic: every skill gets formalized as a typed Skill Contract — preconditions, operation, output artifacts, validators, known failure modes — and the whole library sits inside a Hierarchical Skill Ecosystem Graph with typed edges for dependency, compatibility, redundancy, and alternative relations. A five-dimension health scan (utility, redundancy, compatibility, failure-risk, validation-gap) drives six typed repair actions — merge, repair, retire, add_validator, add_adapter, instantiate — turning a raw library into a maintained one that any existing retrieval or planning agent can use unchanged.

SkillFlow trains a single orchestrator (a "Supervisor" that calls a frozen executor and a growing library of reusable skills) with Tempered Trajectory Balance (TTB), a regression-style flow-matching loss borrowed from GFlowNets in place of a REINFORCE-style policy gradient. TTB pushes each trajectory's sampling probability toward being proportional to its reward, rather than collapsing onto one dominant path, so multiple distinct winning strategies survive under the same loss. Training TTB also produces a backward policy for free: it re-scores each action once execution feedback is known, giving per-step credit assignment at no extra inference cost. Two by-products fall out of this. A training-residual signal flags when the current skill library is capping performance, and a per-step flow signal shows where credit actually belongs. Together they drive an automatic curation loop that keeps, refines, or prunes skills, and mines new ones from matched success/failure trajectory pairs on the same query.

MMSkills packages each reusable procedure as more than a script. Alongside a compact descriptor and text procedure, it attaches state cards — when to apply the skill, when not to, and which visual cues confirm progress or failure — plus multi-view keyframes captured at different crops and points in the task. An agentic trajectory-to-skill generator builds this library automatically: it clusters public, non-evaluation interaction trajectories by workflow, drafts a procedure per cluster, grounds each step in the screenshots where it actually happened, and audits the result before it enters the library. At inference time, branch loading keeps the main agent's context clean. Candidate state cards and keyframes get checked against the live screen in a disposable side branch, and only a distilled decision — what applies, what to do, what to avoid, how to verify — passes back to the agent doing the task.

SkillEvolver treats skill-authoring as a closed loop, not a one-time artifact — and it never touches model weights; the update target is the skill's own prose and code. A meta-skill , loaded through the same CLI interface as any domain skill, drives an authoring agent through repeated cycles of exploring, patching, and auditing a candidate skill. Unlike trace-distillation methods that mine hundreds of pre-collected trajectories per domain, it works from a handful of trials on one newly arrived task. Each cycle spawns several trials built around genuinely different high-level strategies rather than resampled temperature, runs a contrastive skill update that isolates missing guidance by comparing traces that succeeded against ones that failed, and patches the artifact directly. The refinement signal comes specifically from watching a separate, fresh Domain-Skill Agent try to use the already-shipped skill and fail — not from the authoring agent grading its own exploration. Before a revision ships, an independent auditor session with no access to validation data runs nine mechanical checks for overfitting and deployment failure, including a silent-bypass check for skills that read as valid content but are never actually invoked at runtime.

SkillMAS couples two adaptation loops that agent frameworks usually run separately: skill evolution (refining a library of reusable procedures) and MAS restructuring (changing which executor handles what). Both loops draw on the same evidence surface — verified execution traces — rather than retrieval frequency. Utility Learning credits only skills and executors that were actually exercised in a verified trace, not ones merely pulled into context, and tracks a separate Executor Utility signal per team member. Skill edits stay bounded: clean successes turn into reusable motifs, failures enter a patch pool only when analysis isolates one dominant editable cause, and proposals get deduplicated and pruned instead of piling up. Restructuring is evidence-gated too — it fires only when retained failures and Executor Utility point to a genuine organizational mismatch, capped at one edit per round. Testing spans ALFWorld (embodied manipulation), the OS task from Lifelong Agent Bench (command-line execution), and τ-Bench (retail workflows).

Skill-R1 leaves the task-solving model frozen and trains something else entirely: a lightweight editor that rewrites the agent skill itself, generation after generation. Each round, the current skill induces a batch of rollouts from the frozen model (GPT-4o-mini here), a verifier scores them, and the editor reads those rollouts plus their pass/fail outcomes to write the next revision. Training uses a bi-level GRPO objective — an intra-generation term does the standard group-relative comparison among rollouts that share a skill, while an inter-generation term only rewards a revision if the population's mean reward actually climbed from the last round. Gradients never touch the task model, which is why the method works identically on open-weight or closed-source models — the paper calls this black-box compatibility .

MIND-Skill turns skill-writing into a closed loop with two roles instead of one static write-up. An induction agent abstracts a successful task trajectory into a skill document; a separate deduction agent then tries to redo the task using nothing but that document, and the gap between the original run and the blind reconstruction becomes the training signal. Three losses score that gap. A reconstruction loss checks whether the reconstruction follows the same procedural steps; an outcome loss checks whether it actually succeeds against the live environment; a rubric loss scores the write-up itself on five axes — ground-truth independence, actionability, transferability, completeness, conciseness. All three are optimized together with TextGrad , natural-language gradient descent over the skill text, with the outcome loss as the primary objective and the other two breaking ties. The setup is tested on AppWorld (90 training tasks held out against 168 normal and 417 harder "challenge" test tasks) and BFCL-v3 (50 training / 150 held-out multi-turn tool-call instances). Baselines span ReAct, in-context learning, a single-pass "skill-extract" ablation of their own induction agent, and two concurrent methods — ACE and trajectory distillation -based Trace2Skill.

Most agent-skill generation pipelines get the order backwards: a model plans a solution before it ever touches the environment, and that plan becomes the skill. That's the wrong sequence — a skill is only as trustworthy as the evidence behind it, and a pre-execution plan encodes untested assumptions, not verified facts. The Posterior Distillation Index (PDI) is the fix: a trajectory-level score, a z-scored and equally-weighted combination, that rewards execution grounding and penalizes plan copying and "memo ossification" — belief stagnation across repeated attempts. Generating the trajectories PDI scores runs through SPARK (Structured Pipelines for Autonomous Runnable tasKs and sKill generation): a teacher agent repeatedly attempts a task inside a Dockerized environment, keeps a running exploration memo, and distills the successful run into a SKILL.md file. PDI isn't only a post-hoc grade — a memo-based proxy of it also intervenes online, during exploration, before a weak skill ever gets written.

Agent skill libraries decay quietly. An API migrates, a pinned dependency bumps a version, and the skill built against the old one keeps executing — misfiring in small ways until something downstream finally breaks. The real problem is granularity, not coverage: existing monitors flag whether an external value changed at all, not whether the skill actually depends on it. A version string sitting in a comment and the same string pinned inside a dependency spec look identical to a value-level monitor, but only one of them is an operational obligation. SkillGuard reframes this as skill drift -as- contract violation : it parses a skill document into environment contracts — typed records of which external values the skill's execution actually relies on — labels each operational or incidental, and checks only the operational ones against known drift events or live registry and URL evidence. Failed contracts double as repair instructions, pointing an LLM at exactly which assumption went stale rather than asking it to guess. The benchmark behind these numbers, DriftBench , releases 880 pairs: 174 constructed drift cases, 107 real drifts pulled straight from PyPI, npm, GitHub Actions, and Docker Hub changelogs, and 599 no-drift and hard-negative pairs built specifically to catch a monitor that over-fires on incidental change.

SkillMaster gives an LLM agent the right to edit its own skill bank instead of treating skills as content pushed in by an external teacher. After every training episode the agent enters a review phase and must call exactly one of three tools — propose a new skill, revise an existing one, or leave the bank alone — grounded in the trajectory that just played out. Whether an edit is worth keeping is decided by a counterfactual utility reward : the system reruns four related probe tasks under the old skill bank and the candidate-edited version, and only rewards edits that raise success rates or cut wasted steps across those probes. A modified GRPO variant, DualAdv-GRPO , keeps this skill-editing signal from destabilizing the task-execution signal by normalizing advantages for action tokens and skill-editing tokens separately before merging them into one policy update.

SkillGen turns an agent's own rollouts into a single, human-readable skill file instead of asking a person to write one. It collects successful and failed trajectories from a base agent, then runs contrastive induction over both: failures are clustered, each is matched to its nearest successful neighbor, and the behavioral gap between the two is extracted as the reusable signal — not a paraphrase of what happened, but the specific delta that explains why one run succeeded and a similar one didn't. Candidate skills are written into a fixed three-part schema (task context, success pattern, failure-avoidance pattern) and pushed through a generation-verification-refinement loop before anything ships.

SkillOS splits the self-evolving agent into two roles: a frozen executor that solves tasks and retrieves skills via BM25 retrieval , and a separately trained curator that edits an external SkillRepo of skills stored as Markdown files (the same SKILL.md format Anthropic uses). The curator issues insert/update/delete function calls after every task, but training doesn't grade each edit in isolation — training instances are groups of related tasks, so a skill written after task 1 gets its verdict from whether it actually helps solve tasks 2 through N in that same group. A composite reward (future task success, function-call validity, an LLM-judged content-quality score, and a compression term penalizing verbatim trajectory copying) trains the curator with GRPO while the executor stays frozen.

Skill1 trains one policy, via reinforcement learning, to run all three stages of a skill library lifecycle end to end: it writes a text query and re-ranks candidates to pick a skill, solves the task conditioned on that pick, then distills a new skill out of its own trajectory. The departure from prior work sits in credit assignment . Prior systems wire each stage to its own reward source — a heuristic match score for selection, a self-assessed quality score for distillation, task outcome for utilization — training three objectives that never talk to each other. Skill1 derives every signal from one binary task-outcome value instead, split into a low-frequency trend (an exponential moving average of each skill's success rate that supervises re-ranking through an NDCG-style ranking reward) and a high-frequency variation (current outcome minus the best retrieved skill's trend, which only pays out when a distilled skill beats the library's existing ceiling). One GRPO update per rollout batch trains query generation, re-ranking, and distillation together.

Ctx2Skill builds a skill file straight from a raw, unlabeled context using a five-role self-play loop — no human-written skills, no external verifier. Each round, a Challenger agent writes probing tasks and pass/fail rubrics from the context and its own skill set, a Reasoner agent tries to answer them guided by its current skill set, and a neutral Judge scores every rubric pass or fail. Failed cases go to a Reasoner-side Proposer–Generator pair that diagnoses the missing knowledge and rewrites the Reasoner's skill file; cases the Reasoner solves too easily go to a matching Challenger-side pair that tightens the next round's tasks. Left unchecked, a loop like this drifts toward increasingly narrow, extreme tasks — the authors call it adversarial collapse — so a Cross-Time Replay mechanism keeps two small probe sets, the hardest failure and easiest success seen each round, and picks whichever historical skill file scores best on both, rather than defaulting to the final round.

Skills-Coach puts a skill through a four-stage self-improvement loop. First, a task generator reads the skill's own specification and writes a test suite of standard, advanced, and boundary-case tasks. Then a Training-Free GRPO optimizer rewrites the skill's instructions and code in parallel — generating multiple variants and scoring them against each other, with no gradient updates and no backprop through model weights. A Comparative Execution Module runs the original and the optimized version on identical tasks inside isolated environments; a Traceable Evaluation Module then grades both against 51 explicit criteria spread across 8 dimensions, with the pass line set at 70% of the maximum score. Execution comes in two modes — a fast 'virtual' mode that estimates completion from keyword matches and hash-seeded pseudo-randomness, and a 'real' mode that actually runs the skill and inspects its output files, logs, and errors. To test the whole pipeline, the authors built Skill-X , a 48-skill benchmark drawn from the Anthropic, Clawhub, and Vercel Labs skill libraries — 29 instruction-only, 19 shipped with code.

COSPLAY runs two roles inside one system: a decision agent that plays a game by drawing on a skill bank , and a skill-pipeline agent that mines the decision agent's own unlabeled rollouts, extracting new skills and refining the ones already banked — each one shipped with a skill contract instead of a bare snippet. The two roles co-evolve : a better bank improves play, and better play produces better rollouts to mine next. The proving ground is long-horizon tasks — game environments where success depends on chaining skills across many timesteps under delayed reward and partial observability . Six such environments were tested, split between single-player and multiplayer social-reasoning games, with an 8B base model measured against four frontier LLM baselines.