🤖 AI

EvoSkill: Automated Skill Discovery for Multi-Agent Systems

EvoSkill is a self-evolving framework that automatically discovers and refines reusable agent skills through iterative failure analysis and Pareto-based selection, significantly improving performance on specialized reasoning and search-augmented QA benchmarks while demonstrating zero-shot transferability across tasks.

Original authors: Salaheddin Alzubi, Noah Provenzano, Jaydon Bingham, Weiyuan Chen, Tu Vu

Published 2026-03-04

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Salaheddin Alzubi, Noah Provenzano, Jaydon Bingham, Weiyuan Chen, Tu Vu

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 hire a brilliant, hyper-intelligent intern who can write code, solve math problems, and browse the web. This intern is incredibly flexible—they can do almost anything if you give them the right instructions. However, there's a catch: they don't know the specific "tricks of the trade" for your particular job.

If you ask them to analyze complex financial reports, they might know how to read a spreadsheet, but they might miss the subtle rules about how to calculate inflation or where to look for hidden data. If you ask them to research a news story, they might stop searching too early because the first search result looks good enough, even if it's wrong.

Currently, to fix this, humans have to manually write "cheat sheets" or "standard operating procedures" (called skills) for these AI agents. But writing these cheat sheets by hand is slow, boring, and doesn't scale well.

Enter EvoSkill: The AI that teaches itself how to be an expert.

The Core Idea: Learning from Mistakes

Think of EvoSkill not as a teacher, but as a relentless coach who watches an athlete practice, spots exactly where they stumble, and then writes a new drill to fix that specific weakness.

Here is how the process works, using a simple analogy:

1. The Three-Act Play

EvoSkill uses three different AI "characters" working together in a loop:

The Runner (Executor Agent): This is the main AI trying to solve the problem. It runs the task using whatever "cheat sheets" (skills) it currently has.
The Coach (Proposer Agent): This agent watches the Runner fail. It looks at the mistake, the ground truth (the right answer), and the Runner's thought process. It asks: "Why did we mess up? Did we skip a step? Did we misread a number?" Then, it writes a description of a new rule or drill needed to fix this.
The Architect (Skill-Builder Agent): This agent takes the Coach's description and turns it into a real, usable "cheat sheet." It writes the actual instructions, creates the necessary code scripts, and organizes everything into a neat folder that the Runner can use next time.

2. The "Pareto Frontier" (The Hall of Fame)

Imagine a gym with a limited number of lockers (let's say 3). Only the top 3 athletes get to keep their lockers.

Every time the Coach and Architect create a new "cheat sheet," they test it.
If the new cheat sheet helps the Runner get a better score than the worst person currently in the Hall of Fame, the new one gets in, and the worst one gets kicked out.
If the new cheat sheet doesn't help, it's thrown in the trash.

This ensures that the AI only keeps the skills that actually make it smarter, and it never forgets its best tricks.

Real-World Examples from the Paper

The researchers tested this on two very different "jobs" to see if it worked:

Job 1: The Treasury Analyst (OfficeQA)

The Task: The AI had to read massive, boring government financial reports (hundreds of pages of tables) and answer specific math questions about them.
The Problem: The AI kept misreading numbers or picking the wrong row in a table.
The EvoSkill Fix: The system discovered a skill called "Data Extraction Verification." It's like a rule that says: "Hey, before you write down a number from a table, double-check the row and column headers. If the numbers look weird, re-read the whole section."
The Result: The AI's accuracy jumped by 7.3%.

Job 2: The Investigative Journalist (SealQA)

The Task: The AI had to search the messy, chaotic internet to find the truth about a fact, often dealing with fake news or conflicting reports.
The Problem: The AI would see one search result, get excited, and stop searching. It would give an answer based on incomplete info.
The EvoSkill Fix: The system created a "Search Persistence Protocol." This is a rule that says: "Never stop at the first result. You must find at least three different sources that agree before you give an answer. If the sources disagree, keep digging."
The Result: The AI's accuracy jumped by 12.1%.

The Magic Trick: Zero-Shot Transfer

Here is the most exciting part. The researchers took the "Search Persistence Protocol" (the rule about not stopping too early) that was learned while doing the Journalist job.

They gave this exact same rule to a different AI agent doing a completely different job (answering trivia questions on a benchmark called BrowseComp). They didn't change the rule at all.

Result: The AI got 5.3% better at the new job just by using the old rule.

Why is this a big deal?
Usually, if you teach a student how to do long division, they don't automatically get better at writing essays. But EvoSkill teaches habits of mind (like "verify your sources" or "double-check your math") that are useful everywhere. It's like teaching a student how to study rather than just memorizing the answers to one specific test.

Summary

EvoSkill is a system that lets AI agents evolve their own expertise. Instead of humans manually writing thousands of rules, the AI:

Tries a task.
Fails.
Analyzes the failure.
Writes its own new rule to prevent that failure next time.
Keeps the best rules and discards the bad ones.

It's a self-improving loop that turns a general-purpose AI into a specialized expert, and the skills it learns are so fundamental that they can be used to solve problems it has never seen before.

1. Problem Statement

Coding agents (e.g., Claude Code, OpenHands) have emerged as powerful general-purpose problem solvers due to their ability to execute code and interface with tools. However, they lack domain-specific expertise required for specialized tasks.

Current Limitations: Existing solutions rely on hand-crafted skills (reusable workflows, prompts, and code), which are labor-intensive, do not scale, and require significant domain knowledge.
Limitations of Existing Automation: Previous evolutionary approaches (e.g., AlphaEvolve, GEPA) optimize low-level artifacts like prompts or specific code snippets. These are often tightly coupled to specific models and tasks, failing to produce reusable, transferable components that generalize across different settings.

The core challenge is to automatically discover and refine structured, reusable agent skills that improve performance without modifying the underlying frozen language model.

2. Methodology: EvoSkill Framework

EvoSkill is a self-evolving framework that operates at the skill abstraction level rather than optimizing raw prompts or code directly. It uses iterative failure analysis driven by textual feedback to discover and refine skills.

Core Components

The framework employs three collaborating agents:

Executor Agent ( $A$ ): Executes tasks using the current agent program (system prompt + accumulated skills).
Proposer Agent ( $P$ ): Analyzes execution traces, predicted answers, and ground-truth answers to diagnose failures. It determines whether to create a new skill or edit an existing one. Crucially, it maintains a feedback history ( $H$ ) to avoid redundant proposals and learn from past successes/failures.
Skill-Builder Agent ( $S$ ): Materializes the Proposer's high-level textual proposal into a concrete structured skill folder. This folder includes:
- SKILL.md: Procedural instructions and trigger metadata.
- Helper scripts (Python/TypeScript) or reference materials.
- Constraint: Only the Skill-Builder has write permissions to the skills directory.

The Evolutionary Loop

EvoSkill maintains a Pareto frontier ( $G$ ) of the top- $k$ performing agent programs. The process follows these steps:

Selection: A parent program is selected from the frontier (round-robin).
Failure Collection: The parent is evaluated on a training batch. Examples scoring below a threshold are collected into a failure set ( $F$ ).
Proposal: The Proposer analyzes $F$ and $H$ to generate a textual proposal ( $\pi$ ) for a new or edited skill.
Materialization: The Skill-Builder converts $\pi$ into a candidate program ( $\tilde{p}$ ) by adding the new skill folder to the parent's repository.
Evaluation & Selection: The candidate is evaluated on a held-out validation set. If its score exceeds the lowest-scoring member of the frontier, it enters the frontier, displacing the weakest member.
Iteration: The loop continues for $T$ iterations, accumulating skills while the underlying LLM remains frozen.

3. Key Contributions

Skill-Level Abstraction: EvoSkill introduces a framework that optimizes structured, reusable skills rather than low-level prompts or code, resulting in interpretable and composable capabilities.
Iterative Failure-Driven Discovery: It utilizes a feedback descent mechanism where agents analyze execution failures to propose specific skill enhancements, maintaining a history to prevent regression.
Zero-Shot Transferability: The framework demonstrates that skills evolved on one task can transfer to unseen tasks without modification, proving that skill-level optimization yields generalizable capabilities.

4. Experimental Results

The authors evaluated EvoSkill on two distinct benchmarks using Claude Code with Opus 4.5.

Benchmark 1: OfficeQA (Grounded Reasoning)

Task: Reasoning over U.S. Treasury Bulletins (complex tables, charts, text).
Setup: Trained on small subsets (5%, 10%, 15%) of the data.
Results:
- Exact Match Accuracy: Improved from 60.6% (baseline) to 67.9% (+7.3%) using a skill-merge configuration.
- Observation: Performance plateaued after 10% training data, suggesting diminishing returns. Combining skills from independent runs yielded the best results, indicating complementary failure modes.
- Discovered Skills: Included "Data Extraction Verification" (preventing table misreads) and "Quantitative Analysis Methodology" (enforcing validation checkpoints).

Benchmark 2: SealQA (Search-Augmented QA)

Task: Fact-seeking questions with noisy, conflicting, or unhelpful web search results.
Results:
- Accuracy: Improved from 26.6% to 38.7% (+12.1%).
- Discovered Skill: "Search-Persistence-Protocol," which enforces exhaustive search strategies, multi-source verification, and term expansion before concluding.

Zero-Shot Transfer Experiment

Setup: The "Search-Persistence-Protocol" skill evolved on SealQA was applied zero-shot (no modifications) to BrowseComp, a challenging browsing benchmark.
Result: Accuracy improved from 43.5% to 48.8% (+5.3%).
Significance: This provides direct evidence that EvoSkill discovers generalizable capabilities (e.g., "search persistence") rather than overfitting to specific training data.

5. Significance and Future Directions

Paradigm Shift: EvoSkill moves the optimization target from "prompt engineering" to "skill engineering," creating modular, persistent, and transferable agent capabilities.
Efficiency: It achieves significant performance gains using very small training subsets (5–15% of data), making it data-efficient.
Interpretability: Unlike black-box prompt optimization, EvoSkill produces human-readable SKILL.md files and scripts, allowing for inspection and manual refinement.
Future Work: The authors plan to explore multi-modal tasks (vision + code), build shared skill libraries across different agents, and further investigate transferability across diverse domains and model architectures.

In summary, EvoSkill demonstrates that automated, iterative refinement of structured agent skills is a viable and powerful method for enhancing coding agents, offering a scalable path to domain expertise without retraining the underlying foundation models.