🤖 AI

VCE-Skill: Enhancing Skill Self-Evolution with Version-Change Experience

The paper proposes VCE-Skill, a novel framework that enhances agent skill self-evolution by adaptively fusing task-specific execution trajectories with distilled, structured experience from public skill version histories, resulting in significant performance improvements and stronger cross-model transfer capabilities.

Original authors: Jianming Chen, Xuanbin Ye, Yawen Wang, Junjie Wang, Qing Wang, Fanjiang XU

Published 2026-08-18

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jianming Chen, Xuanbin Ye, Yawen Wang, Junjie Wang, Qing Wang, Fanjiang XU

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.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

In the rapidly evolving world of artificial intelligence, researchers are teaching computer programs to act more like human assistants. These programs, often called agents, do not just answer questions; they perform tasks by using tools, following instructions, and managing files. To make these agents reliable, developers give them "skills." Think of a skill as a portable toolbox containing a set of instructions, scripts, and resources that the agent can pick up and use whenever it faces a specific type of problem. However, just as a human learns from mistakes, these tools are rarely perfect when first created. As the world changes and new challenges arise, the instructions inside these toolboxes need to be updated, patched, and improved. The central question for scientists is how to automate this improvement process so that the agents can teach themselves to become better over time.

For some time, the standard approach to this self-improvement has been to let the agent try a task, watch where it fails, and then rewrite the instructions based on that specific failure. This method relies entirely on the evidence gathered during the current attempt. While this works, it has a blind spot: it only sees the mistakes that happen right now. It misses the broader lessons that other developers have learned over years of maintaining similar tools. A team of researchers from the Chinese Academy of Sciences and the Beijing University of Post and Telecommunications realized that this narrow focus was leaving a vast library of knowledge untapped. They set out to see if the history of changes made to public software tools could teach an agent something that its own immediate experience could not.

The researchers began by comparing two different sources of information. The first source was the agent's own recent attempts at a task, which provided a detailed but narrow view of what went wrong. The second source was the public history of changes made to similar tools by human developers over time. When they analyzed these two sources side by side, they discovered a clear and useful difference. The agent's own attempts mostly focused on fixing immediate, specific errors in how it called tools or read instructions. In contrast, the public history contained a much wider variety of improvements, including changes to how data was organized, how scripts were structured, and how the tool handled unexpected situations. The public records offered a broader perspective, while the agent's own records offered a grounded, task-specific reality. The two sources did not repeat each other; instead, they filled in each other's gaps.

To put this insight to work, the team developed a new system called VCE-Skill. This system acts as a bridge between the agent's current experience and the collective wisdom of the past. The process happens in two main stages. First, the system takes the raw, messy history of changes from public repositories and cleans them up. It strips away the specific details that only apply to one project and distills them into general, reusable lessons. For example, if many developers have added a check to ensure a file exists before trying to open it, the system learns this as a general rule rather than a single fix. These distilled lessons are stored in a structured library of experience.

In the second stage, the agent attempts a task and generates its own ideas for improvement based on what happened. The system then looks at its library of distilled lessons and selects the ones that are most relevant to the current problem. It does not simply copy the old lessons or ignore the agent's own ideas. Instead, it carefully blends the two. If the agent is struggling with a common issue that the public history has solved many times before, the system leans heavily on that external wisdom. If the agent is facing a unique, strange error that has never been seen before, the system trusts the agent's own observation more. This balance is not fixed; the system constantly adjusts how much it trusts the external library versus the agent's own experience, depending on whether the changes are actually making the agent perform better.

The results of this approach were tested across five different types of tasks, ranging from answering complex questions and managing spreadsheets to controlling robots in virtual environments. The researchers used four different large language models to act as the agents. In every case, adding this external experience to the agent's self-improvement loop led to better performance. The agents scored higher on average, with improvements ranging from about three to five points across the various tests. More importantly, the skills that were improved using this method proved to be more robust. When the researchers took a skill that had been evolved with this new method and tested it on a different computer model than the one it was trained on, it performed significantly better than skills that had only learned from their own immediate mistakes. This suggests that by incorporating the broader lessons from public history, the agents learned more general principles that could be applied in new situations, rather than just memorizing how to fix a specific error.

The study does not claim that the old way of learning from mistakes is useless. The agent's own experience remains essential for understanding the specific details of the task at hand. The new method simply adds a layer of context that the agent could not find on its own. By treating the history of public software changes as a valuable source of prior knowledge, the researchers have shown that agents can learn to evolve more effectively. They have demonstrated that the path to a smarter, more reliable agent is not just about watching what happens in the moment, but also about understanding the long story of how similar tools have been improved over time. This approach offers a practical way to make artificial intelligence more adaptable, ensuring that the tools it uses are not just functional for today, but robust enough for the future.

Technical Summary: VCE-Skill

Problem Statement

Agent systems increasingly rely on reusable skills—portable bundles of instructions, scripts, and configurations—to solve classes of tasks. While recent work has automated skill self-evolution through a trajectory-driven paradigm (executing agents, diagnosing failures, and revising skills), this approach faces inherent limitations. Updates are strictly bounded by the quality and coverage of execution trajectories collected during the current run. Noisy or low-quality trajectories can obscure failure causes, while incomplete coverage of failure modes may lead to updates that overfit to limited observations. Consequently, trajectory-driven evolution often overlooks broadly useful update knowledge that is not revealed by current executions.

Although public skill version histories (e.g., from GitHub or ClawHub) contain a rich source of evolution knowledge adopted by developers during maintenance, this resource remains largely untapped for skill self-evolution. It is unclear whether these public changes merely duplicate strategies found in trajectory-based evolution or if they offer complementary knowledge. Furthermore, raw version diffs are fine-grained and repository-specific, making them difficult to apply directly to current task failures without abstraction.

Methodology: VCE-Skill

The authors propose VCE-Skill (Version-Change Experience Skill), a framework designed to enhance skill self-evolution by integrating external experience from public skill version histories with internal evidence from execution trajectories. The method operates in two primary stages:

1. Experience Distillation

This stage transforms raw, noisy version diffs from public repositories into reusable, structured guidance.

Change Abstraction: Raw diffs between adjacent skill versions are decomposed into update events. Each event is structured as $u_j = \langle d_j, \{c_j\}, o_j, i_j \rangle$ , representing the raw diff ( $d_j$ ), affected components ( $c_j$ ), semantic operation ( $o_j$ ), and update intent ( $i_j$ ).
Experience Generation: These events are distilled into three hierarchical levels of knowledge:
- Update Patterns: Groups of related events within a skill's history, summarized to remove repository-specific details.
- Evolution Insights: Synthesized strategies characterizing recurring update patterns for a specific skill.
- Domain Insights: Generalized principles capturing transferable optimization strategies across skills in the same task domain.
Experience Bank: The distilled knowledge is aggregated into a structured bank ( $B$ ) serving as an external knowledge corpus.

2. Optimization with Adaptive Experience Attention

This stage integrates the distilled external experience with the base evolver's trajectory-derived proposals.

Experience Selection: At each iteration, a selection context is constructed from the target task, current skill, and feedback from the previous update. An LLM-based selector retrieves the top- $K$ relevant experiences from the bank.
Self-Proposal Generation: In parallel, a base evolver (e.g., SkillOpt, EvoSkill) generates a self-proposal ( $p^{self}_t$ ) based solely on the current execution trajectory.
Adaptive Attention Fusion: The system fuses the external experience guidance ( $p^{exp}_t$ $p_{t}^{e x p}$ ) and the self-proposal ( $p^{self}_t$ $p_{t}^{se l f}$ ) using adaptive attention weights ( $\lambda^{exp}_t, \lambda^{self}_t$ $λ_{t}^{e x p}, λ_{t}^{se l f}$ ).
- The weights are initialized equally but are dynamically adjusted based on Adaptation Feedback.
- Feedback Mechanism: After an update, the system analyzes the provenance of the realized changes (whether they stemmed from external experience or the self-proposal) and the validation performance change. This unified feedback ( $f_t$ ) adjusts the attention weights for the next iteration, increasing reliance on the source that contributed to successful improvements and shifting away from sources associated with non-improving updates.

Key Contributions

Motivation Study: The authors conducted a pilot study comparing public skill changes with trajectory-derived changes. They revealed complementary coverage: trajectory-derived changes are highly concentrated on instructions and narrow intents, whereas public histories cover broader components and introduce unique intents and patterns not observed in current rollouts.
VCE-Skill Framework: The introduction of a method that distills raw version changes into structured, reusable experience and adaptively fuses this external prior with trajectory-derived proposals during iterative optimization.
Empirical Validation: Extensive experiments demonstrating the effectiveness and generality of VCE-Skill across multiple benchmarks and models.

Experimental Results

The authors evaluated VCE-Skill on five benchmarks (SearchQA, OfficeQA, ALFWorld, Spreadsheet, BFCL-v4) using four LLMs (Qwen3.5-27B, GPT-5.2, DeepSeek-v3.2, Claude Sonnet 5) and three base self-evolution methods (EvoSkill, SkillClaw, SkillOpt).

Performance Improvement: VCE-Skill consistently improved the performance of all base evolvers. The mean scores increased by 3.20 to 4.98 points across different configurations. For instance, SkillOpt+VCE achieved an average score of 60.27 on Qwen3.5-27B (a +3.47 improvement over SkillOpt) and 70.84 on GPT-5.2 (a +3.78 improvement).
Ablation Study: Removing experience distillation (using raw diffs directly) caused significant performance degradation, often falling below the baseline. Replacing adaptive attention with fixed equal weights also underperformed, confirming the necessity of both abstraction and dynamic weighting.
Cross-Model Transferability: Skills evolved with VCE-Skill demonstrated stronger transferability when applied to different models than those evolved without it. When transferred from a source model to target models, VCE-enhanced skills improved average scores by 5.15 to 6.04 points, a gain that exceeded the improvements seen in the source model's own evaluation. This suggests the distilled experience reduces model-specific overfitting.

Significance and Claims

The paper claims that public skill version histories represent a previously underexplored yet effective source of prior knowledge for agent skill evolution. By highlighting the complementarity between external version changes and internal trajectory evidence, VCE-Skill advances the trajectory-driven paradigm.

The authors position their work not as a replacement for existing self-evolution methods, but as a modular enhancement that allows any base evolver to leverage external experience. The significance lies in shifting the focus from solely relying on current execution evidence to incorporating a broader, historically grounded set of evolution priors, thereby producing skills that are more robust, generalizable, and capable of cross-model transfer.