Skill evolution 88 papers

SkillFlow introduces 166 tasks across 20 workflow families spanning five domains — finance and economics, operations and supply chain, healthcare and life sciences, governance and strategy, and data and document intelligence. Every family runs on a shared Domain-Agnostic Execution Flow (DAEF), an abstract workflow skeleton that holds a task's operational structure constant while individual tasks within the family escalate in difficulty. Agents operate under an Agentic Lifelong Learning protocol: they start with an empty skill library, work through a family's 8-9 tasks in sequence, and after each one they receive the execution trace plus a verifier-written rubric describing what was missing or wrong. From that feedback they write a skill patch — adding, revising, or deleting entries in the library — before the next task begins. The domain never changes under them; only the skill library they carry forward does.

SkillMOO treats a coding agent's agent skill bundle as something to search over, not a fixed asset written once. An LLM optimizer agent proposes edits — pruning a skill, substituting one, reordering the bundle, rewriting content — while a separate solver agent runs the edited bundle against a task. NSGA-II ranks the resulting candidates each generation on two objectives at once, pass rate and inference cost, keeping only the Pareto-efficient ones. Both agents run on GLM-5, evolving a population of 4 over 3 generations. The pipeline goes up against all 16 SkillsBench software-engineering tasks — build repair, code migration, data engineering, performance debugging, ML reproduction among them — each one repeated across 10 independent runs.

Most agent skills ship once and sit still. The same tool-usage mistake, the same brittle workaround, the same failure mode gets rediscovered independently by every user who hits it, because nothing carries that experience back into the skill itself. SkillClaw closes the loop by treating every session as signal: it pools the trajectories — what an agent tried and how it went — across every user of a skill, then runs an autonomous evolver over that pooled history. The evolver hunts for behavioral patterns that recur across different people's sessions, then decides whether the fix is tightening an existing skill or adding a new one. Updated skills land in a shared skill repository that syncs to every user automatically — nobody has to notice a fix shipped, let alone go pull it.

SkillForge builds and maintains agent skills for cloud technical-support agents at Alibaba Cloud, closing a loop that most skill-authoring setups leave open. A Domain-Contextualized Skill Creator writes the initial skill by mining historical support tickets, tool-usage logs, and internal documentation — not a generic prompt working blind. From there, a three-stage pipeline (Failure Analyzer, Skill Diagnostician, Skill Optimizer) batches failed task executions, traces each one back to a specific section of the skill file, and rewrites only that section. The team ran it across five real cloud-support scenarios — Account, Domain, DNS, OSS, ECS — spanning 1,883 tickets and 3,737 tasks, with Qwen3-Max as the backbone and an LLM judge (validated at over 90% agreement with human experts) scoring each response against what a human engineer actually used to resolve the ticket.

SkillX turns an agent's raw trajectories into a three-tier skill knowledge base : strategic plans that sequence a task end to end, functional skills that package a tool-based subroutine, and atomic skills that encode a single tool call's constraints. Two automated passes then work the library. An iterative skill refinement loop merges near-duplicate skills and screens survivors through a general quality check plus a tool-schema check. An exploratory skill expansion step targets tools the agent under-uses or keeps failing on, generating and validating new skills to close the gap. Everything runs off a single backbone, GLM-4.6, with each training task rolled out four times, on small seed sets of 50 to 90 training tasks per benchmark, and no human editing in the loop.

SkillFoundry turns scientific papers, repos, notebooks, and docs into a maintained skill library, not a one-time scrape. It maps a target domain as a domain knowledge tree , then mines the branches with the most resources and the weakest verified coverage. Each artifact gets reduced to an operational contract — scope, inputs/outputs, execution steps, environment assumptions, provenance, and tests — and compiled into an executable skill package . A closed-loop validation pass then expands, repairs, merges, or prunes entries as new results come in, so the library keeps evolving instead of going stale.

CoEvoSkills leans on a distinction Anthropic drew when it introduced agent skills : a tool is a single self-contained function, but a skill is a structured bundle of interdependent instructions, scripts, and reference files. Today those bundles are still hand-authored, and it shows — human-curated skills post uneven results on SkillsBench , helpful in most domains but actively degrading performance in others, such as Natural Science. The likely culprit is human-machine cognitive misalignment : a gap between how a person explains a task and how an agent actually needs to execute it. CoEvoSkills replaces manual authoring with two co-evolving LLM sessions: a Skill Generator that rewrites the skill bundle each round, and a Surrogate Verifier — an informationally isolated session that never sees the generator's reasoning or code — which writes and escalates its own test assertions. A held-out ground-truth oracle returns only a pass/fail bit, no test content; that opacity is the mechanism, not a limitation. When the surrogate's own tests pass but the oracle still fails, the blank signal is what forces the verifier to write harder tests, not any direct exposure to what actually went wrong.

SKILL0 trains an agent to stop needing its own skill files. That's skill internalization — procedural knowledge migrates from context into weights instead of getting reloaded every time the agent runs. The recipe starts with reinforcement learning (GRPO) on Qwen2.5-VL backbones, and it renders skill files and interaction history together as a single compact visual context — an image, not a wall of prepended text — which trims token overhead before any curriculum even kicks in. Then comes the actual mechanism: a training schedule that hands every rollout the full skill file at first and slowly takes it away. An offline pass groups skills by category and pairs each with matched validation sub-tasks; a Dynamic Curriculum then rechecks every few steps how much each file is still worth — accuracy with it minus accuracy without — and keeps only the ones still earning their keep, inside a budget that shrinks on a fixed linear schedule until it hits zero and the policy runs fully zero-shot .

Trace2Skill turns a pile of raw agent execution traces into one consolidated skill file, not a growing memory store, not an order-dependent chain of edits. A frozen agent runs a batch of tasks first and produces labeled trajectories, successes and failures both. Failures go to an interactive error analyst that inspects the actual output artifacts, checks them against ground truth, and validates a candidate fix before writing a patch; successes go to a lighter single-pass analyst that pulls out reusable behavior patterns. A hierarchical merge step then folds every patch in the pool together at once — deduplicating, resolving conflicts, keeping only what recurs across independently analyzed trajectories — into one updated skill document. The same model generates the trajectories, analyzes them, and merges the result, so there's no separate teacher model, no fine-tuning, no test-time retrieval. The pipeline runs in two modes: deepening an existing human-written skill, and building one from scratch out of a weak LLM-drafted seed, across spreadsheet editing, math reasoning, document QA, and office-file tasks.

ContractSkill converts a draft web-agent skill into a contract artifact — a structured record of the goal, preconditions, an ordered list of steps (each carrying a selector, action, optional arguments, and post-assertions), postconditions, recovery rules, and termination checks. A deterministic verifier walks that structure against the live page and returns one of five typed error codes — element not found, wrong page state, an unmet postcondition, a step-budget timeout, or an invalid input — pinpointing exactly which step broke and why. That code drives fault localization . Five narrow patch operators then swap a brittle selector, insert a missing precondition or postcondition, add a recovery fallback, or correct an argument — touching only the broken step instead of regenerating the whole procedure.

Memento-Skills flips who designs the agent: instead of a human hand-building a task-specific system, a generalist LLM builds and refines its own sub-agents through experience — an agent-designing agent . Capability lives in reusable skills : structured markdown files that serve as external, persistent memory, encoding both the behavior and the context it applies to. The agent starts from a small seed — web search, terminal operations — and grows the library from there. Growth runs on Read-Write Reflective Learning , a two-phase loop from a companion system, Memento 2. A read phase lets a trained skill router pick the most relevant skill for the current stateful prompt ; a write phase lets the agent update and expand its own library based on what just happened. None of it touches the base LLM's weights. Every bit of adaptation gets externalized into the skill files and prompts themselves.

ARISE trains a single policy to play two roles inside the same reinforcement-learning loop: a Skills Manager and a Worker. Before attempting a problem, the Manager scores every skill sitting in its cache by summing the policy's own log-probability of that skill's text conditioned on the query — no separate retriever model — and only prepends a skill to the Worker's prompt if the top score clears a confidence-gate threshold (0.35 by default). After the Worker's rollout, a dedicated extra rollout distills any successful trace into a compact five-field skill document — name, problem type, key insight, 2-3 step method, verification check — hard-capped at 220 characters. That document enters a two-tier cache-and-reservoir library through one of five operations: Add, Update, Evict, Load, Delete. A three-level reward — 2 for a correct answer that used a skill, 1 for a correct answer without one, 0 for any wrong answer regardless of skill use — biases GRPO 's group-relative advantage toward skill-augmented rollouts whenever both appear in the same batch, so the same gradient step that improves reasoning also curates which skills survive.

XSkill splits a multimodal agent's reusable memory into two separate structures instead of one. A skill library holds stable, task-level workflows and tool templates in Markdown. A companion experience bank holds short, disposable condition-action notes in JSON, each capped at a few dozen words. Both are built and retrieved from the agent's actual screenshots rather than text logs alone. A rollout summarization step reads each image alongside the trajectory and records which visual cue — an inverted photo, a washed-out region — triggered which action. A cross-rollout critique then contrasts successful and failed attempts on the same task to decide what gets added or rewritten in the experience bank. A periodic consolidation pass merges near-duplicate entries and prunes the weak ones, so the knowledge base doesn't bloat over time. At inference, a task decomposition retrieval step breaks a new query into sub-needs and retrieves matching skill sections and experiences for each. It rewrites them against the current images and folds the result into the system prompt — a reference the agent can deviate from, not a fixed script.

General-purpose computer-use agents train on demonstrations from roughly 100 digital environments, then get thrown at whatever unfamiliar interface a real task requires — and the skills don't transfer. OSExpert's fix is to have the agent explore before it's ever asked to perform. A GUI-DFS (depth-first search) procedure pushes candidate UI targets onto a stack, resets the environment, replays the action sequence needed to reach each one, and coordinates three modules — planner, action executor, feedback classifier — to expand, terminate, or retry each branch. Any state the feedback module marks terminal becomes a verified unit-function skill with a short usage description; the agent then chains unit skills into composite tasks and folds those in too. A separate database of fine-grained action primitives — calling an external segmentation tool, extracting boundary coordinates, clicking a sequence of points along an object's contour — gets pulled in whenever the feedback module flags an error needing pixel-level precision, and a primitive only survives if it succeeds under verification. Once exploration wraps, a LoRA-tuned lightweight model trained on the resulting plan-skill pairs serves as a fast planner , producing a full plan in one forward pass instead of re-planning at every step, and a skill-boundary check lets the agent recognize tasks resembling past repeated failures and bail early instead of burning its inference-time-scaling budget.

EvoSkill discovers and edits agent skills — structured folders of instructions and helper scripts — by watching a coding agent fail, then testing fixes at the skill level instead of touching prompts or model weights. The system splits into three roles: an executor runs tasks under the current agent program, a proposer diagnoses the failures and drafts skill edits, and a skill-builder writes the result into a reusable folder. Whether an edit survives comes down to a Pareto frontier of three competing agent programs — a candidate only replaces the frontier's weakest member if it beats it on a held-out validation split the proposer never saw. The base model, Claude Code running Opus 4.5, never changes; every gain has to come from the skill folder, not the weights.

AutoSkill is a training-free plug-in layer that turns repeated user requests into versioned skill artifacts instead of treating them as disposable chat history. Two loops run in tandem. A serving loop rewrites the incoming query, ranks stored skills with a hybrid BM25+dense retrieval score, and injects only the ones that clear a similarity threshold. A background evolution loop extracts a candidate skill from the user's own queries — never the model's replies — and hands it to an LLM judge that compares it against its single nearest neighbor and decides add, merge, or discard. A merge doesn't concatenate text: it bumps the existing skill's version number and folds in only the new, non-conflicting constraints, so a skill like a writing-style preference accumulates as one evolving artifact rather than a pile of near-duplicate prompts.

SkillRL splits an LLM agent's raw rollouts into two streams and distills each differently: successful trajectories become demonstrations, failed ones get compressed by a teacher model (OpenAI o3) into short failure lessons — the point of failure, the flawed reasoning, and the general principle to avoid repeating it. Both feed a two-tier SkillBank : general skills that apply across an entire environment, and task-specific skills retrieved by embedding similarity to the task at hand. Before reinforcement learning starts, a cold-start SFT phase teaches the Qwen2.5-7B-Instruct backbone to actually retrieve and apply skills — handing skills to an untrained model turns out to buy almost nothing on its own. During GRPO training the library keeps growing through recursive skill evolution : after each validation epoch, failures in weak task categories get fed back to the teacher model, which proposes new or refined skills, so the SkillBank and the policy improve in tandem instead of the library staying frozen.

CoWork-X splits agent cognition into two clocks. A Skill-Agent handles every in-episode decision by retrieving from a structured skill library built as hierarchical task networks (HTN) — state queries, operators, and method decompositions compiled into an editable Python file — with zero LLM calls during play. After each episode, a separate Co-Optimizer LLM reads the trajectory logs (runtime failures, 100-timestep stagnation flags, action-type breakdowns) and patches the library under explicit budget constraints and drift regularization , keeping a best-performing historical version on hand for rollback. The setup runs on a two-agent, symmetric version of the DPT-Agent Overcooked-AI -style burger-preparation benchmark, starting from a deliberately broken skill library — syntactically valid HTN rules whose operators skip precondition checks entirely — across 30 episodes.

Agents built on chain-of-thought reasoning treat every episode as new — even when the underlying subtask has been solved dozens of times, the reasoning chain gets thrown away the moment the episode ends. Skill-Pro converts finished trajectories into explicit, executable procedures instead of discarding them, formalized as a Skill-MDP : each stored skill bundles an activation condition (when to fire), an execution procedure (the ordered action sequence), and a termination condition (when to hand control back to the base policy). Improving that library without touching model weights is handled by Non-Parametric PPO . Hindsight attribution over a trajectory produces semantic gradients — natural-language descriptions of how a skill should change — and a PPO Gate reruns PPO's clipped-surrogate trust-region check against historical trajectories to decide whether the edited candidate is actually accepted into the library. Score-based maintenance , which scores each skill by its average advantage whenever it's active, prunes it back out the moment it stops paying its way.

MemSkill treats the four hard-coded memory operations — insert, update, delete, skip — that most LLM agent memory systems run on as a starting point, not the final word. It organizes them into a shared skill bank , a set of structured, reusable routines for extracting, consolidating, and pruning information from interaction history. Three learned components run that bank: a controller, trained with reinforcement learning (PPO) and Gumbel-Top-K sampling, picks a small set of relevant skills for each turn without replacement; an executor applies whichever skills got picked to write memory in a single pass over a span of history, rather than turn by turn; and a designer periodically reviews the hard cases — where selected skills produced wrong or incomplete memories — clusters similar failures, and proposes refinements or entirely new skills. That closes the loop: the selection policy and the skill set itself both keep improving over time.