🤖 AI

SkillSmith: Co-Evolving Skills and Tools for Self-Improving Agent Systems

SkillSmith is a novel framework that enables self-improving agents to co-evolve skills and tools through a synergy-aware process guided by an ecological utility model and anti-pattern learning, thereby outperforming existing baselines on complex, multi-skill tasks.

Original authors: Yangbo Wei, Zhen Huang, Shaoqiang Lu, Junhong Qian, Qifan Wang, Chen Wu, Lei He

Published 2026-06-02

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Yangbo Wei, Zhen Huang, Shaoqiang Lu, Junhong Qian, Qifan Wang, Chen Wu, Lei He

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 have a very smart robot assistant. This robot is great at thinking and planning, but to actually do things in the real world (like searching the web, reading a PDF, or sending an email), it needs a set of tools and a set of instructions on how to use them.

In the past, researchers tried to make these robots better by only upgrading their instructions (called "Skills"). They would say, "If you fail at this task, rewrite your plan." But they left the tools (like the search engine or the PDF reader) exactly the same, even if the tools were broken or outdated.

SkillSmith is a new system that changes this approach. Instead of just fixing the instructions, it fixes the instructions and the tools together, while also keeping a diary of what went wrong so it doesn't make the same mistake twice.

Here is how SkillSmith works, using simple analogies:

1. The "Atomic Bundle": Fixing the Recipe and the Knife Together

Imagine a chef trying to make a soup.

The Old Way: If the soup tastes bad, the chef only rewrites the recipe. But what if the knife they are using is dull? No matter how good the recipe is, the vegetables won't chop right. The chef might try to write a complicated recipe that says, "Chop the vegetable very slowly because the knife is dull," which makes the process messy and prone to errors.
The SkillSmith Way: When the soup tastes bad, SkillSmith looks at the whole picture. It realizes the knife is dull. So, it creates a single, unified "fix package" (an Atomic Bundle). This package does two things at once:
1. It sharpens the tool (the knife).
2. It updates the skill (the recipe) to use the sharp knife properly.

This ensures the robot doesn't just patch over a broken tool with a complicated workaround; it actually fixes the root cause.

2. The "Ecosystem": Skills as Animals in a Jungle

Imagine the robot's skills are like animals living in a jungle.

The Old Way: Researchers looked at each animal (skill) individually. They asked, "Is this lion good at hunting?" They didn't care if the lion was fighting with the tiger next to it.
The SkillSmith Way: SkillSmith treats the skills like a living ecosystem. It uses a mathematical model (inspired by how animals compete or help each other in nature) to see how skills interact.
- Competition: If two skills do the exact same thing, they waste energy. SkillSmith might retire one.
- Conflict: If two skills try to do things that cancel each other out (like one trying to search broadly while another tries to block all searches), SkillSmith sees this "negative energy" and fixes the conflict.
- Cooperation: If two skills work better together than apart, SkillSmith encourages them to team up.

This keeps the robot's brain organized, preventing it from getting cluttered with useless or conflicting instructions.

3. The "Anti-Pattern Memory": The "Do Not Do This" List

Imagine you are learning to drive.

The Old Way: If you crash, you learn from it, but if you forget, you might crash the same way again next week.
The SkillSmith Way: SkillSmith keeps a detailed diary of failures. When the robot crashes, it doesn't just fix the crash; it writes down why it happened and what caused it.
- It creates a "fingerprint" of the mistake (e.g., "Trying to open a file that doesn't exist").
- Before the robot tries a new plan, it checks this diary. If the new plan looks like a past mistake, SkillSmith says, "Stop! We tried that before, and it failed."
- This stops the robot from wasting time trying the same broken ideas over and over again.

Why Does This Matter?

The paper tested SkillSmith on three different types of difficult tasks (like reading complex financial documents, answering tricky questions, and doing multi-step digital chores).

It gets better as the robot gets smarter: When they used bigger, more powerful AI models, SkillSmith's advantage grew. The smarter the robot, the better it was at using these new tools and skills together.
It handles complexity: When tasks got harder and required using many skills at once, SkillSmith kept improving, while other methods stopped getting better (they hit a wall).
It's more efficient: By fixing the tools directly, SkillSmith solved problems faster and with fewer tries than methods that only tried to rewrite the instructions.

In short: SkillSmith is like a master mechanic who doesn't just tell the car how to drive better; they also tune the engine, fix the tires, and keep a log of every breakdown so the car never breaks down the same way twice.

Technical Summary: SkillSmith – Co-Evolving Skills and Tools for Self-Improving Agent Systems

1. Problem Statement

Recent advancements in Large Language Model (LLM) agents have shifted focus from isolated tool calls to structured Skills—packages comprising workflows, scripts, and metadata that serve as external, non-parametric state. While existing frameworks enable the discovery and refinement of skills, they suffer from three critical limitations that hinder robust self-improvement:

Fixed Tool Layers: Most systems treat the tool layer as immutable. When failures occur due to missing, brittle, or mis-specified tools, the system is forced to overcompensate by creating bloated and error-prone skill workflows, rather than repairing the root cause at the tool level.
Isolated Skill Evaluation: Current evolution methods typically mutate and evaluate skills independently. This ignores the reality that agents often retrieve, compose, and apply multiple skills simultaneously, failing to account for synergies or conflicts (interference) between them.
Lack of Failure Retention: Failed trajectories are often consumed once for reflection and then discarded. Without a mechanism to retain "failure signatures" (anti-patterns), agents risk repeatedly diagnosing the same errors or regenerating retired configurations, wasting computational resources and stalling evolution.

2. Methodology: The SkillSmith Framework

SkillSmith is a synergy-aware framework that jointly evolves Skills, Tools, and failure memory. It models the agent's external state as a triple $\Sigma_t = (S_t, T_t, F_t)$ , where $S_t$ is the skill library, $T_t$ is the tool library, and $F_t$ is the anti-pattern memory. The system operates through an iterative loop comprising four stages:

A. Unified Reflection and Atomic Bundle Proposals

Instead of generating isolated edits, SkillSmith's reflector ( $R$ ) produces atomic proposal bundles ( $L_t$ ). These bundles simultaneously update skills and tools.

Tool Lifecycle Primitives: To prevent the search space from exploding, tool evolution is restricted to five typed operations: WRAP (add pre/post-processing), EDIT (modify implementation or signature), COMPOSE (chain tools), SPLIT (decompose complex tools), and RETIRE (remove obsolete tools).
Atomicity: Changes are applied simultaneously. For example, if a tool is wrapped to handle a new input format, the skills invoking that tool are updated in the same bundle to match the new interface, ensuring valid intermediate states.
Veto Mechanism: Before submission, proposals are checked against the anti-pattern memory to ensure they do not replicate known failure modes.

B. Synergy-Aware Skill Ecosystem Dynamics

SkillSmith treats the skill library as a shared ecosystem, utilizing Lotka–Volterra dynamics to model interactions:

Interaction Matrix: Based on execution traces, the system estimates a pairwise interaction matrix ( $\hat{\beta}_{ij}$ ). Positive values indicate complementarity (synergy), while negative values indicate interference (conflict).
Dynamic Utility: A skill's utility is not just its isolated performance but is adjusted based on its interactions with other active skills. This guides retrieval, mutation prioritization, and retirement. Skills that suppress useful neighbors or duplicate capabilities are deprioritized.
Pareto Management: The system maintains a Pareto front of non-dominated system states at the instance level, ensuring that specialized configurations for specific task families are not lost to general averages.

C. Anti-Pattern Memory

The component $F_t$ stores structured failure records ( $\phi = \text{signature}, \text{attribution}, \text{remedy}$ ).

Diagnostic Acceleration: When a new failure occurs, the system retrieves similar past failures to accelerate root-cause analysis.
Proposal Veto: If a proposed bundle resembles a known failure pattern, the system vetoes the proposal, preventing "amnesic regression" where the agent re-discovers and re-fails on the same issue.

D. Validation and State Update

Proposed bundles undergo progressive validation:

Tool Unit Testing: Ensures new/modified tools function correctly in isolation.
End-to-End Integration Testing: Verifies the bundle on a task batch.
Regression Checking: Ensures the update does not degrade performance on previously mastered tasks.
Only validated bundles are admitted to the Pareto front, and the ecological model is updated.

3. Key Contributions

Skill-Tool Co-Evolution: The paper introduces a unified framework that moves beyond skill-only optimization, allowing agents to repair tool-level bottlenecks directly. This addresses the "fixed tool" limitation of prior work.
Ecological Utility Modeling: It proposes a novel method for estimating skill interactions using Lotka–Volterra dynamics, enabling the system to reason about complementarity and conflict rather than treating skills as independent modules.
Anti-Pattern Memory: The framework formalizes the retention of failure diagnostics and remedies, creating a "negative knowledge base" that prevents repetitive errors and accelerates diagnosis.
Theoretical Guarantee: The authors provide a proof demonstrating that joint skill-tool optimization has a strictly higher theoretical upper bound than skill-only optimization when task distributions contain hard subsets requiring capabilities absent in the initial tool set.

4. Experimental Results

The framework was evaluated on three benchmarks: OfficeQA (structured document reasoning), SealQA (noisy search-based QA), and WildClawBench (complex, multi-step interactive tasks). Experiments were conducted across five Qwen3.5 model scales (9B to 397B).

Performance Gains: SkillSmith consistently outperformed strong baselines (Base Agent, EvoSkill, SkillClaw). On the 397B scale, it achieved 80.1% on OfficeQA (+18.3% over Base) and 49.5% on SealQA (+18.9% over Base).
Scaling Effects: The performance advantage of SkillSmith grew monotonically with model size and task complexity. On WildClawBench, while skill-only baselines plateaued by Day 2–3 due to tool bottlenecks, SkillSmith continued improving through Day 6.
Ablation Studies:
- Locking the Tool Layer: Removing tool updates caused the largest performance drop (−6.8% on WildClawBench), confirming the necessity of co-evolution.
- Removing Ecological Dynamics: This led to library bloat (21+7 components vs. 14+6) and reduced retrieval accuracy.
- Removing Anti-Pattern Memory: This tripled the regression rate, as the system repeatedly proposed configurations known to fail.
Cost Efficiency: Despite higher per-iteration costs due to tool validation, SkillSmith converged faster (13 iterations vs. 18 for EvoSkill on OfficeQA), resulting in lower total computational cost and higher final accuracy.

5. Significance and Claims

The paper claims that SkillSmith represents a shift from local strategy patching to sustainable capability evolution. By jointly evolving skills and tools, the system can address root causes of failure (e.g., a tool's inability to parse a specific format) rather than applying brittle workarounds at the skill level.

The authors emphasize that their approach enables agents to:

Repair Tool-Level Bottlenecks: Directly fix or compose tools when they are the source of failure.
Manage Complexity: Use ecological dynamics to maintain a lean, non-redundant skill library that adapts to task complexity.
Learn from Failure: Systematically accumulate negative experience to avoid repeating mistakes, a capability often missing in self-improving systems.

The work concludes that while current limitations exist (dependence on LLM reflection quality, cold-start noise in sparse data), the framework provides a robust foundation for building agents capable of long-term, self-sustaining improvement in complex, tool-rich environments.