💬 NLP

AlignEvoSkill: Towards Knowledge-Aware and Task-Aligned Agent Skill Evolution

AlignEvoSkill is a novel framework that enhances LLM-based agent performance by evolving reusable skills through a joint optimization of knowledge coverage and task alignment, achieving state-of-the-art results with lower computational costs.

Original authors: Dingzirui Wang, Xuanliang Zhang, Keyan Xu, Qingfu Zhu, Wanxiang Che, Yang Deng

Published 2026-05-27

📖 4 min read☕ Coffee break read

CC0 1.0

Original authors: Dingzirui Wang, Xuanliang Zhang, Keyan Xu, Qingfu Zhu, Wanxiang Che, Yang Deng

Original paper dedicated to the public domain under CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are teaching a very smart robot assistant how to do complex jobs, like planning a meeting or writing a poem. Instead of hard-coding every single instruction, you give the robot a "toolbox" of reusable skills (like "extract dates from emails" or "check rhyme schemes").

The problem is, when the robot fails at a task, the old ways of fixing its toolbox often make things worse. They might:

Miss the point: They grab a skill that's almost right but misses a crucial piece of knowledge (like forgetting to check if someone is actually free).
Get too specific: They create a skill that only works for that one specific mistake, rather than teaching the robot a general rule for the future.

The paper introduces ALIGNEVOSKILL, a new method to upgrade the robot's toolbox. Think of it as a smart, double-checking editor that fixes the robot's skills in two specific ways.

The Two-Step "Smart Editor" Process

Step 1: The "Knowledge Tag" Detective (Fixing What's Missing)
Imagine every skill in the robot's toolbox has a set of sticky notes (tags) on it describing what it does.

The Old Way: When the robot fails, the old methods might just grab the closest-looking skill or mash two skills together randomly. This is like trying to fix a leaky pipe by gluing a wrench to it—it might look related, but it doesn't actually fix the hole.
The ALIGNEVOSKILL Way: First, it looks at the failed task and asks, "What specific knowledge was missing here?" It creates a list of "required tags" (e.g., "check availability," "handle time zones").
Then, it scans the toolbox to find skills that have matching tags. If a skill is missing a tag (like "time zones"), the system knows exactly what gap needs to be filled. It then builds a new skill that combines the useful parts of the old skills but specifically adds the missing knowledge.

Step 2: The "Relevance" Filter (Fixing What's Irrelevant)
After building a new candidate skill, the system has to decide: "Is this actually good for the job?"

The Old Way: Some methods just look at the robot's failed attempt and say, "Okay, let's make a skill that avoids that specific error." This is like a student memorizing the answer to one specific math problem but not understanding the formula. If the numbers change, they fail again.
The ALIGNEVOSKILL Way: It uses a "relevance test." It asks the AI, "If you were given only the task description, how likely would you be to generate this specific skill?"
- If the skill is just a weird description of the robot's past failure, the score is low.
- If the skill is a perfect, general guide for the task, the score is high.
The system keeps only the skills that score high on this test, throwing away the "noisy" or irrelevant ones.

The Results: A Better Toolbox for Less Effort

The researchers tested this on three different "exam" sets (benchmarks) using four different types of robot brains (LLMs).

Big Win: The new method improved the robots' performance by 34.7% compared to not evolving skills at all.
Beating the Competition: It beat the previous best methods by a significant margin, setting a new "gold standard" (SOTA).
Cheaper: Surprisingly, it did all this while using less computing power and time than the other methods. It didn't just brute-force its way to success; it was more efficient because it stopped wasting time on bad ideas early.

The Bottom Line

ALIGNEVOSKILL is like a master craftsman who doesn't just throw more tools at a problem. Instead, they:

Identify exactly what tool is missing (using the "Knowledge Tags").
Build a new tool that combines old tools but fills that gap.
Test the new tool to make sure it's actually useful for the job, not just a copy of a past mistake.

The result is a robot that learns from its failures much faster, makes fewer mistakes, and gets better at its job without needing a massive amount of extra computing power.

Technical Summary: ALIGNEVOSKILL

1. Problem Statement

Large Language Model (LLM) agents rely on reusable procedural knowledge, or "skills," to enhance long-term capabilities. While existing skill-evolution methods aim to automatically refine skill libraries from past experiences, they suffer from two critical limitations that result in incomplete or irrelevant evolved skills:

Improper Knowledge Coverage: Current methods often rely on a single existing skill or simply concatenate multiple skills. This approach risks overlooking task-relevant knowledge scattered across different skills or introducing irrelevant and conflicting information, leading to noisy or incomplete skill definitions.
Weak Task Alignment: Methods that distill skills from execution trajectories often focus too heavily on the specific history of a failed run. Consequently, the evolved skill may reflect the execution path rather than the underlying task requirements, failing to guide the agent effectively toward solving the target task in future instances.

These limitations prevent evolved skills from being both comprehensive in knowledge and strictly aligned with the target task objectives.

2. Methodology: ALIGNEVOSKILL

The authors propose ALIGNEVOSKILL, a framework designed to jointly model knowledge coverage and task alignment during the skill evolution process. The framework operates on failed task trajectories and updates an external skill library while keeping the base agent parameters frozen. The process consists of three core stages:

A. Knowledge-Tag-Guided Source Skill Selection

Instead of retrieving skills based on semantic similarity alone, ALIGNEVOSKILL associates every skill with a set of knowledge tags (short phrases describing procedural capabilities, e.g., "PDF text extraction").

Tag Inference: For a failed task-trajectory pair $(x, \tau)$ , an LLM infers the target knowledge tag set $K^\star$ required to solve the task.
Optimal Selection: The system selects a subset of source skills $S^\star$ from the current library that maximizes the coverage of $K^\star$ while minimizing the introduction of irrelevant tags (tags in $S^\star$ that are not in $K^\star$ ).
Gap Identification: It identifies "uncovered tags" ( $K^\star_{un}$ ), representing knowledge required by the task but missing from the selected source skills.

B. Knowledge-Tag-Guided Skill Generation

Using the selected source skills, the failure trajectory, and the uncovered tags as input, an LLM generates candidate skills.

The generation process is conditioned to transfer useful knowledge from the selected skills and explicitly address the missing knowledge identified by $K^\star_{un}$ .
The goal is to produce a reusable skill that generalizes to a class of related tasks rather than merely describing the specific failure trajectory.

C. Skill Filtering via Coverage and Alignment

To ensure high quality, candidate skills are filtered using a joint scoring criterion:

Knowledge-Tag Coverage ( $F_{tag}$ ): Calculates the F1 score between the tags of the generated skill and the target task tags. This ensures the skill covers the necessary procedural knowledge.
Likelihood-Based Task Alignment ( $A$ ): Measures the conditional likelihood of generating the skill given the task description, normalized by the unconditional likelihood. This metric, $A(c) = \sigma(\frac{1}{|c|}(\log \hat{p}(c|x) - \log \hat{p}(c|\emptyset)))$ , ensures the skill is specifically grounded in the task requirements rather than being a generic or trajectory-specific artifact.
Final Score: The system retains the top-ranked candidates based on the geometric mean of coverage and alignment scores: $Score(c) = \sqrt{F_{tag}(c) \cdot A(c)}$ .

3. Key Contributions

Identification of Limitations: The paper formally identifies and addresses the dual challenges of improper knowledge coverage and weak task alignment in current skill-evolution paradigms.
Novel Framework: It introduces ALIGNEVOSKILL, which utilizes knowledge tags to guide source skill selection and employs a likelihood-based metric to enforce task alignment during filtering.
Comprehensive Evaluation: The method is evaluated across 3 benchmarks (SRA-Bench, SkillsBench, SkillLearnBench) and 4 diverse LLM backbones (DeepSeek-V4-Flash, Claude-Haiku-4.5, GPT-5.4-Nano, GPT-5.4).

4. Experimental Results

Performance Gains: ALIGNEVOSKILL achieves a 34.7% relative gain over the non-evolution baseline (Base) and outperforms existing state-of-the-art baselines (CoEvoSkills, Trace2Skill, SkillX) by an average of 3.3 to 3.7 points across all settings.
State-of-the-Art: The method establishes a new SOTA in skill evolution, achieving the best results on all three benchmarks and across all model backbones.
Efficiency: Despite its performance gains, ALIGNEVOSKILL demonstrates superior efficiency, reducing token usage by approximately 33.2% and wall-clock time by 28.1% compared to existing baselines.
Component Analysis: Ablation studies confirm that removing any component (sampling, generation, or filtering) significantly degrades performance, validating the necessity of the joint optimization approach.
Correlation: Analysis shows a strong positive correlation between the method's ability to improve knowledge-tag coverage (up 9.9%) and task-alignment likelihood (up 8.9%) and the resulting downstream task performance.

5. Significance and Claims

The paper claims that effective skill evolution requires explicitly modeling both the knowledge required by a task and the alignment of the skill to that specific task objective. By moving beyond simple trajectory distillation or skill concatenation, ALIGNEVOSKILL demonstrates that:

Skills can be evolved to be both knowledge-complete and task-specific.
Targeted evolution using knowledge tags and alignment filtering is more efficient and effective than broader, unguided distillation pipelines.
The approach is robust across different model families and scales, offering a practical path for improving agent capabilities without retraining the base LLM.

The authors acknowledge limitations, noting that the method relies on informative failure trajectories and reliable task feedback, and that current experiments are confined to specific benchmarks and LLM backbones. However, the results suggest that the proposed framework effectively mitigates the noise and misalignment issues prevalent in current agent skill evolution.