🤖 AI

SkillMOO: Multi-Objective Optimization of Agent Skills for Software Engineering

SkillMOO is a multi-objective optimization framework that automatically evolves LLM-based agent skill bundles using an iterative process of failure analysis and NSGA-II selection, achieving significant improvements in coding task success rates and cost efficiency while revealing that minimal, focused instructions outperform accumulated ones.

Original authors: Jingzhi Gong, Ruizhen Gu, Zhiwei Fei, Yazhuo Cao, Lukas Twist, Alina Geiger, Shuo Han, Dominik Sobania, Federica Sarro, Jie M. Zhang

Published 2026-04-13

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Jingzhi Gong, Ruizhen Gu, Zhiwei Fei, Yazhuo Cao, Lukas Twist, Alina Geiger, Shuo Han, Dominik Sobania, Federica Sarro, Jie M. Zhang

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 brilliant but slightly chaotic personal assistant (an AI coding agent) who is trying to fix bugs, translate code, or update software for you. To help this assistant do a better job, you give them a "toolbox" filled with instruction manuals, cheat sheets, and scripts. These are called Agent Skills.

However, there's a problem:

The Toolbox is Cluttered: Sometimes the manuals contradict each other or contain outdated advice.
It's Expensive: Reading through a huge, messy toolbox takes time and costs money (since AI usage is billed by the word).
Manual Tuning is Hard: Trying to manually pick the perfect combination of instructions for every single job is like trying to fix a watch with a sledgehammer. It's slow, fragile, and requires a master watchmaker.

Enter SkillMOO. Think of SkillMOO as a smart, automated "Toolbox Refiner" that uses two specialized AI robots to constantly upgrade your assistant's toolbox.

How SkillMOO Works: The "Solver" and the "Optimizer"

The system runs a loop involving two AI agents working together:

The Solver (The Worker): This robot tries to do the actual coding job using the current toolbox. It reports back: "Did I succeed? How much did it cost? Where did I fail?"
The Optimizer (The Editor): This robot looks at the Solver's failures and the current toolbox. It says, "Ah, this instruction is confusing," or "We don't need this 5-page guide on something we never use." It then edits the toolbox:
- Pruning: Cutting out useless pages (like deleting a manual for a tool you never use).
- Substitution: Swapping a bad instruction for a better one (like replacing a blurry map with a GPS).
- Rewriting: Clarifying confusing steps.

The "Multi-Objective" Magic: The Tightrope Walk

The tricky part is that you want two things at once, and they often fight each other:

Goal A: Get the job done perfectly (High Success Rate).
Goal B: Do it as cheaply and quickly as possible (Low Cost/Time).

Usually, if you add more instructions to help the AI, it might succeed more often, but it becomes slower and more expensive. If you cut too much to save money, the AI might fail.

SkillMOO uses a mathematical strategy called NSGA-II (think of it as a smart filter). It doesn't just look for one perfect toolbox. Instead, it finds the "Pareto Front"—a set of "Goldilocks" toolboxes where you can't improve the success rate without making it more expensive, and you can't make it cheaper without risking failure. It evolves these toolboxes over several generations, keeping only the best versions.

What Did They Find? (The Results)

The researchers tested this on three tough software engineering tasks (fixing build errors, translating Python to Scala, and updating old software frameworks).

The Big Win: In one task, SkillMOO doubled the success rate (from 16% to 37%) while saving money and speeding up the process.
The Secret Sauce: The most successful toolboxes weren't the ones with more instructions. They were the ones where the AI cut out the noise.
- Pruning (removing useless info) and Substitution (fixing bad info) were the winners.
- Adding new instructions rarely helped and often made things slower.
- Analogy: It's like a chef realizing that removing a confusing, unnecessary ingredient makes the dish taste better and cook faster, rather than adding more spices.

The Bottom Line

SkillMOO is a system that automatically "trims the fat" off AI instruction manuals. Instead of a human spending hours trying to guess which instructions work best, this system uses AI to experiment, fail, learn, and refine the instructions until it finds the perfect, lean, and efficient set of rules.

It proves that for AI agents, less is often more: a focused, clean set of instructions works better than a massive, cluttered library of advice.

1. Problem Statement

Large Language Model (LLM)-based coding agents utilize "skills" (portable folders containing instructions, scripts, and resources) to improve performance on specialized software engineering (SE) tasks. However, current approaches face significant challenges:

Inefficiency of Manual Tuning: Manually curating and tuning skill bundles to balance success rates, inference costs, and runtime is expensive, fragile, and requires domain expertise that often does not transfer across tasks.
Suboptimal Performance: Existing benchmarks (e.g., SkillsBench) show that while skills can improve performance, gains are often modest (+4.5%), and poorly constructed bundles can waste agent overhead.
Lack of Systematic Optimization: There is a gap in automated frameworks that can evolve skill bundles to simultaneously optimize for pass rate (quality) and cost (efficiency) without human intervention.

2. Methodology: SkillMOO Framework

SkillMOO is a Multi-Objective Optimization (MOO) framework designed to automatically evolve task-specific skill bundles. It employs a solver-optimizer loop involving two distinct agents:

Task Solver Agent: Executes the coding task using a candidate skill bundle. It evaluates the bundle based on three metrics:
- Pass Rate: The percentage of tests passed.
- Cost: The LLM inference cost (USD).
- Runtime: Execution time (tracked as a secondary metric).
- Output: Pass rate, cost, and error traces.
Skill Optimizer Agent: Analyzes the failure traces from the Solver and proposes edits to the skill bundle. It uses an internal "optimizer skill" (which evolves over generations) to suggest operations such as:
- Pruning: Removing irrelevant skill blocks.
- Substitution: Swapping misaligned content.
- Reordering/Rewriting: Adjusting the sequence or phrasing of instructions.
Optimization Algorithm (NSGA-II):
- The framework treats the problem as a bi-objective minimization: $\min [-pass(b), cost(b)]$ .
- It uses NSGA-II (Non-dominated Sorting Genetic Algorithm II) for survivor selection. Candidates are ranked via non-dominated sorting and crowding-distance tie-breaking to maintain a diverse Pareto front of optimal solutions.
- Guardrails: A "pass-preservation guard" rejects any child candidate where the pass rate drops by more than 0.05 compared to its parent, ensuring quality does not degrade significantly during search.

3. Experimental Setup

Datasets: Three complex SE tasks from SkillsBench were selected, focusing on scenarios with large original skill bundles where manual tuning is most difficult:
1. fix-build-agentops: Repairing Python build failures.
2. python-scala-translation: Translating pipeline logic between languages.
3. spring-boot-jakarta-migration: Migrating Spring Boot apps to Jakarta APIs.
Enhancements: The original test suites (3–10 tests) were expanded to 40 tests per task using GPT-5.4 to ensure denser behavior and safety assertions.
Models: Both the Solver and Optimizer agents utilized GLM-5.
Configuration: The search ran for 5 generations with a population size of 1. Each method was executed 10 times to calculate statistical significance (Scott-Knott ESD ranks).

4. Key Results

The study compared SkillMOO against two baselines: ori_skill (original static bundles) and no_skill (no guidance).

Effectiveness (RQ1)

SkillMOO consistently outperformed the best static baseline across all three tasks, achieving simultaneous improvements in pass rate and cost:

Task 1 (Build Repair): Pass rate increased by 131.2% (0.16 $\to$ 0.37) while reducing cost by 31.7% and runtime by 23.6%.
Task 2 (Translation): Pass rate increased by 30.8% (0.39 $\to$ 0.51) with a 5.4% cost reduction.
Task 3 (Migration): Pass rate increased by 2.1% (0.97 $\to$ 0.99) with a 19.4% cost reduction.
Statistical Significance: SkillMOO achieved the top Scott-Knott ESD rank for pass rate in all tasks.

Optimization Efficiency (RQ2)

The framework proved highly cost-effective. The cost to achieve a 1% improvement in Hypervolume (HV) was minimal:

Task 1: $0.0011 per %HV gain.
Task 2: $0.0043 per %HV gain.
Task 3: $0.0059 per %HV gain.
Conclusion: The optimization overhead is negligible compared to the gains in multi-objective quality.

Pattern Analysis (RQ3)

Analysis of successful edits revealed specific drivers of improvement:

Pruning and Substitution: These were the most frequent successful operations (7 edits each). They consistently reduced costs (7/7 cases) and improved pass rates (5/7 cases).
Expansion (Adding Content): Adding new skill blocks rarely improved pass rates (0/5 cases), suggesting that "more instructions" is not the solution.
Key Insight: Effective bundles favor minimal, focused content over accumulated instructions. Success often came from removing irrelevant guidance (e.g., unused RestTemplate mentions) or substituting misaligned structural guidance.

5. Significance and Contributions

Novel Framework: SkillMOO is the first framework to combine LLM-proposed skill edits with NSGA-II for multi-objective optimization of agent skills in SE.
Empirical Validation: It provides strong evidence that automated skill evolution can simultaneously maximize task success and minimize economic cost, outperforming static, manually curated bundles.
Design Principles: The study shifts the paradigm of skill design from "accumulating instructions" to "pruning and refining," offering actionable insights for building efficient AI agents.
Reproducibility: The authors released a full replication package (data, scripts, and artifacts) to support further research in SE4AI and AI4SE.

Conclusion

SkillMOO demonstrates that treating agent skills as an evolvable resource via multi-objective search is a viable and highly effective strategy. By automating the refinement of skill bundles, it resolves the trade-off between performance and cost, suggesting that future SE agents should rely on dynamic, optimized skill sets rather than static, hand-crafted instructions.