💻 computer science

SkillEvo: Self-Renewing Evolution Gradients from Multi-Turn Interaction Feedback

SkillEvo is a framework that enables sustained agent skill evolution by transforming multi-turn user simulations into continuous feedback generators for targeted improvements and introducing an active governance layer to repair structural degradation, thereby outperforming existing single-turn or self-reflection-based approaches.

Original authors: Qianxi Yan, Chunrong Chen, Jiuzhou Zhao, Min Zhang, Yongzhou Xu, Xiaochuan Xu

Published 2026-08-14

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Qianxi Yan, Chunrong Chen, Jiuzhou Zhao, Min Zhang, Yongzhou Xu, Xiaochuan 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

Imagine you are teaching a robot how to fix a broken toaster. In the old days, you would have to write down every single step by hand: "Check the plug," "Look for burnt wires," "Press the reset button." If the robot made a mistake, you'd have to find the error, rewrite the manual, and start over. This is slow, expensive, and the robot never really learns from its own failures on the fly.

Recently, scientists started letting robots try to fix things and then asking them, "How did you do that?" The robot would look at its own work, realize it missed a step, and try to rewrite its own instructions. This is called "self-evolution." But there's a catch: most of these robots only get one chance to explain themselves. They try to fix the toaster, get a quick "good job" or "bad job" score, and then stop. They miss the subtle mistakes that only show up when you ask, "Wait, what if the plug is loose and the wire is burnt?" They get stuck because they can't see the deeper layers of the problem.

This is where a new idea called SkillEvo comes in. It's a framework designed to help AI "agents" (smart computer programs) get better at their jobs by learning from long, back-and-forth conversations, rather than just a single quick check. The researchers behind this work, from Tencent Cloud and Zhejiang University, wanted to solve a specific problem: how do you keep an AI's knowledge base growing and improving without it getting messy, confused, or full of lies? They found that the secret isn't just having a smart editor; it's having a smart teacher who keeps asking follow-up questions to uncover hidden mistakes, and a strict inspector who makes sure the robot doesn't accidentally delete the right answers while trying to add new ones.

The Problem: The Robot That Stops Learning

Imagine you are playing a video game with a new character. In the first round, the character tries to jump over a pit and fails. You tell them, "You need to jump higher." They fix it, and in the next round, they jump fine. But then, they try to jump over a pit while dodging a fireball, and they fail again. If your teacher only gave you feedback on the first jump, the character would never learn to handle the fireball. They would hit a "ceiling" where they can't get any better because they aren't being tested on the hard stuff.

This is exactly what happens with current AI skills. Most systems use a "single-turn" check. The AI tries to solve a problem, gets a score, and tries again. But once the obvious mistakes are fixed, the feedback stops being useful. The AI hits a wall. It's like trying to learn a language by only answering "Yes" or "No" to simple questions; you'll never learn how to have a complex conversation.

Furthermore, when these AIs try to fix themselves, they often break things. They might add so much new information that their instructions become a messy, 100-page novel full of contradictions. They might forget the original rules they were supposed to follow. This is called "degradation." The more they try to evolve, the worse they get at being reliable.

The Solution: SkillEvo's Two-Part Magic

The authors of this paper propose a new system called SkillEvo (Skill Evolution). They argue that the key to making AI better isn't just giving it more time to edit its own code, but giving it better feedback and better rules. They built a system with two main parts: a Trustworthy Feedback Generator and a Controllable Governance Layer.

Part 1: The Curious Simulator (Trustworthy Feedback)

Instead of just asking the AI a single question, SkillEvo uses a "Simulator" to act like a real, slightly difficult human customer. This simulator doesn't just ask one question and leave. It plays a game of "20 Questions."

The Setup: The simulator reads a real, messy customer complaint (a "ticket") and creates a realistic scenario. It knows what the customer wants, what they already tried, and even how they might get frustrated.
The Conversation: The AI tries to help. The simulator asks follow-up questions: "Okay, but what if I tried that and it didn't work?" or "Wait, I have a different error code now."
The Reveal: This back-and-forth peels back the layers of the problem. Just like in the video game, the first round of conversation might fix the easy stuff, but the second and third rounds reveal the hidden, complex mistakes.
The Filter: Not every mistake is the AI's fault. Sometimes the simulator is being weird, or the tool the AI uses is broken. SkillEvo has a special "Attributor" that checks: "Is this a gap in the AI's knowledge, or is it something else?" Only the real knowledge gaps get turned into feedback.

This creates a "self-renewing" gradient. Every time the AI fixes a mistake, the simulator gets to ask a harder question, revealing the next layer of defects. The AI never runs out of things to learn.

Part 2: The Strict Inspector (Controllable Governance)

Even with great feedback, an AI can get messy. If you let a student rewrite their textbook every day, they might accidentally delete the chapter on math while adding a chapter on art. They might make the book 1,000 pages long with repetitive nonsense.

SkillEvo adds a "Governance" layer to stop this. Think of this as a strict editor who has two rules:

Don't Delete the Truth: The AI must keep all the stable, correct facts it started with. If it tries to delete a known fact, the system says "No!" and fixes it immediately.
Don't Let the Book Get Bloated: The system checks if the AI is adding unnecessary fluff or breaking the links between different parts of its knowledge. If the AI's "knowledge graph" gets tangled or too big, the system actively repairs it, pruning the dead ends and tightening the structure.

This ensures that as the AI gets smarter, it doesn't get messy. It stays organized and reliable.

What They Found: The Numbers

The researchers tested this system on 9 real-world skills used in cloud services (like fixing database issues or managing servers). They compared SkillEvo against three other methods:

Original Skills: The starting point, never updated.
Self-Reflection: The AI tries to fix itself without any outside feedback.
Single-Turn QA: The AI gets feedback from just one question-and-answer session.

The results were clear. The "Self-Reflection" method barely improved; it just spun its wheels. The "Single-Turn QA" method got better at first, but then hit a wall, stopping around a 66.4% success rate.

SkillEvo, however, kept climbing. By using the multi-turn conversation to find deeper problems and the governance layer to keep things clean, it reached an 81.8% success rate. That is a 15.4-point improvement over the single-turn method and a massive 51.8-point improvement over the original, un-updated skills.

They also measured how much the AI's "knowledge book" grew. Without the governance layer, the book grew by 16.2% in size, becoming bloated and messy. With the governance layer, it only grew by 2.8%, proving that the AI was learning efficiently without adding unnecessary junk.

Why This Matters

This paper suggests that the future of AI isn't just about making bigger models or letting them edit themselves more. It's about how we talk to them and how we check their work. By turning a simple "test" into a long, revealing conversation, and by adding a strict "governance" system to keep the AI from getting confused, we can create AI that truly learns and improves over time.

The authors tested this in a real production environment at Tencent Cloud, meaning this isn't just a theory; it's a system that actually works when real customers are involved. They showed that if you give an AI a teacher who asks the right follow-up questions and a strict editor who keeps it honest, the AI can evolve into a much more capable and reliable helper.

Technical Summary: SkillEvo – Self-Renewing Evolution Gradients from Multi-Turn Interaction Feedback

1. Problem Statement

Current Agent Skills—portable modules encapsulating domain knowledge and handling procedures—are predominantly hand-authored or generated in a single LLM pass. Consequently, they lack a closed-loop mechanism to improve from the interaction failures they cause. While recent work has attempted to close this loop, it relies on single-turn question-answering (QA) evaluation. This approach creates a sharp asymmetry: once the first round patches gaps visible in a single exchange, the evolution gradient decays. Defects that only surface across multiple turns remain invisible, causing evolution to stall.

Furthermore, existing governance mechanisms rely on an end-to-end scalar verification score. While this score can reject a degraded candidate, it cannot localize or repair the structural causes of degradation (e.g., factual over-generalization, reference breakage, or knowledge bloat). The authors argue that the binding constraint on sustained skill evolution is not editing capability or iteration count, but whether the evaluation feedback continuously supplies trustworthy evolution gradients.

2. Methodology: The SkillEvo Framework

SkillEvo is a skill-evolution framework built on two pillars: Trustworthy Feedback Generation and Controllable Skill Governance. It operates as a closed loop: Scenario Synthesizer → User Agent → Verifier → Collective Attribution → Skill Optimizer → Skill Governor.

2.1 Trustworthy Feedback Generation

The framework recasts multi-turn user simulation from a mere evaluation endpoint into a continuous feedback generator. This component ensures the feedback signal is trustworthy by satisfying three conditions: coverage, accuracy, and attributability.

Constrained User Reconstruction: Instead of generic simulation, the system extracts an intent agenda, behavior facts, and an emotion trajectory from real human-handled tickets. An Intent State Machine tracks whether key intents have been raised and substantively addressed, preventing premature termination or redundant turns.
Dual-Sided Orthogonal Evaluation: To ensure accuracy, the system evaluates the simulator and the agent separately.
- Simulator Side: Measures intent coverage ( $c_U$ ). If key intents are not raised, the failure is attributed to simulation distortion (Evaluation Noise), not the agent.
- Agent Side: Measures exposed-intent response accuracy ( $s_C$ ) against human reference solutions. This isolates genuine knowledge gaps from simulation artifacts.
Collective Attribution: Failures are classified into three categories:
1. Knowledge Gap: Repairable by the Skill (e.g., missing facts).
2. Capability Limit: Unrepairable by the Skill (e.g., permission/tooling restrictions).
3. Evaluation Noise: Simulation distortion or false negatives.
  Only Knowledge Gaps are projected into the feedback signal ( $L_t$ ). Multiple similar gaps are merged semantically to focus revision on cross-sample commonalities rather than per-instance noise.

2.2 Controllable Skill Governance

To prevent the accumulation of degradation during multi-round revision, SkillEvo introduces an independent governance layer that shifts from passive rejection to diagnosis-driven active repair.

Fact Consistency (Hard Constraint): A revised Skill must retain stable facts from the production baseline ( $S_0$ ). The system uses dual anchors ( $S_0$ and the previous round $S_{t-1}$ ) to distinguish between lost stable facts and newly introduced errors. Any violation triggers immediate same-round repair.
Structural Consistency (Soft Constraint): The system diagnoses three types of structural degradation that scalar scores miss:
1. Knowledge Bloat: Redundancy diluting routing precision.
2. Reference Breakage: Dangling references or orphan files.
3. Factual Over-generalization: Concrete values decaying into vague statements.
  Instead of rejecting the candidate, the governance layer emits recommendations to repair these structural issues in the next round, ensuring the gradient direction does not drift.

2.3 Bounded Editing

The Skill Optimizer performs bounded updates ( $S_{t+1} = \text{BoundedEdit}(S_t, L_t, S_0)$ ). Updates are constrained by an evidence boundary (only verified gaps are patched) and a reference boundary (revision is anchored to the production baseline to prevent overwriting stable facts).

3. Key Contributions

Formalization of Trustworthy Feedback: The paper defines three necessary conditions (coverage, accuracy, attributability) and introduces a multi-turn simulation framework that recasts interaction from an endpoint into a feedback generator. This includes an intent state machine, dual-sided orthogonal evaluation, and collective attribution.
Structured Governance for Skills: The authors identify Skills as structured knowledge systems prone to specific degradations (bloat, breakage, over-generalization). They propose a governance mechanism using dual anchors for fact consistency and graph-structural diagnosis for active repair, moving beyond scalar-gated rejection.
Empirical Validation: The framework is deployed and tested across six categories of cloud services, involving 9 production Skills and 98 skill-reference files.

4. Experimental Results

The evaluation was conducted on Tencent Cloud production technical-support scenarios, using a dataset of escalated tickets (failure cases). The results were measured against three baselines: Original Skill (hand-authored), Self-Reflection (no evaluation), and Single-turn QA-driven evolution.

Performance Gains: SkillEvo improved the Task Success Rate (TSR) by 51.8 points over the original Skills. It surpassed Self-Reflection-based evolution by 23.0 points and Single-turn-QA-driven evolution by 15.4 points.
Gradient Sustainability: While Single-turn QA showed diminishing returns (TSR plateauing around 66.4% after the first round), SkillEvo demonstrated a self-renewing gradient, with TSR climbing steadily from 59.4% (R1) to 81.8% (R4).
Degradation Control:
- Regression Rate: The governance layer significantly reduced cross-round regression, with the rate of tickets failing after previously passing dropping from 28.2% (R1→2) to 21.1% (R3→4).
- Knowledge Bloat: Without governance, cumulative knowledge bloat reached 16.2%. With SkillEvo's governance, bloat was limited to 2.8%, stabilizing after the first round. This indicates capability gains were derived from correcting existing knowledge rather than expanding text volume.
Ablation Studies: Removing multi-turn interaction (replacing with Single-turn QA) eliminated the 15.4-point lead, confirming the feedback source as the primary driver. Removing the governance layer caused a smaller drop in TSR (3.2 points) but a massive increase in bloat, highlighting governance's role in structural integrity rather than immediate score maximization.

5. Significance and Claims

The paper claims that the bottleneck for sustained skill evolution is not the ability to edit text or the number of iterations, but the quality and continuity of the evaluation feedback signal.

Self-Renewing Gradients: By utilizing multi-turn interaction, SkillEvo ensures that every round of revision consumes feedback while simultaneously generating new, deeper feedback by exposing latent defects layer by layer.
Active Governance: The framework demonstrates that treating a Skill as a structured knowledge system allows for the diagnosis and repair of structural degradation (bloat, broken references) that scalar metrics cannot detect.
Production Viability: The framework has been deployed in the Tencent Cloud production environment, evidencing its effectiveness under real operating conditions where manual maintenance is costly and latency-sensitive.

The authors emphasize that their approach provides a necessary condition for deploying self-evolving knowledge in user-facing systems: a high-quality feedback loop that isolates simulation distortion and a governance mechanism that actively maintains the Skill's structural and factual integrity.