Skill$^{\infty}$: Recursive Self-Improvement for Agent Skill Optimization

AI summary

Overview

Research area: Artificial intelligence — language-model agents, recursive self-improvement (RSI), and automatic optimization of agent “skills” (portable packages of procedural knowledge).

Technical level: Intermediate. The paper assumes familiarity with LLM agents, tool use, and prompt/instruction optimization, but its central idea — writing the optimizer itself as an editable skill — is explained in accessible terms.

Scope (one sentence): The paper introduces Skill∞, a framework in which a meta agent follows a meta-skill to optimize task skills and applies that same procedure to improve the meta-skill itself, then evaluates it on 83 SkillsBench tasks and three KernelBench problems.

What This Paper Is About

Agent skills are reusable directories of instructions, scripts, and reference files that a language agent can load when it judges them useful. Existing methods that automatically improve such skills follow a procedure designed by humans, and whatever the optimizer learns while fixing one skill does not carry over to the next. The paper’s goal is to make that optimization procedure itself a skill, so the same agent-led loop that improves task skills can also rewrite the procedure — achieving recursive self-improvement — and then reuse the refined procedure across many different tasks.

Key Contributions

1. A recursively self-improving skill optimizer. Skill∞ encodes the optimization procedure as a meta-skill that the meta agent follows, and the same agent-led procedure is applied to the meta-skill itself, so the system improves both task skills and the way it improves them.
2. An agent-led optimization loop with independent review and adaptive budgeting. Each iteration inspects an archive, diagnoses rollouts, proposes one or two candidates, evaluates them, submits each to an isolated reviewer, and decides whether to continue — with the meta agent allocating the search budget itself rather than following a fixed schedule.
3. Decoupling of the meta-skill from task skills. The meta-skill is refined on a set of skill optimization tasks from different domains and then reused to optimize diverse task skills, amortizing the cost of self-improvement across them.
4. Evaluation under deployment-like skill loading. Both the meta-skill and task skills are standard packages loaded through native skill discovery — never injected into a prompt and never forced on the agent — and the method is tested across two harnesses and two backbone models.

Main Findings

• SkillsBench main result: Skill∞ reaches an overall pass rate of 60.7% (avg@5) on 83 tasks, compared with 56.4% for human-curated skills, 54.5% for SkillEvolver, 48.0% for SkillCreator, 42.9% for self-generated skills, and 45.5% with no skill.
• Per-domain leadership: Skill∞ leads in software engineering (65.7%), media and content production (84.4%), and mathematics (92.0%). It does not lead everywhere — for example, it scores 26.7% in finance and economics, below human-curated skills.
• Self-improvement ablation: Replacing the refined meta-skill with its seed lowers the pass rate from 60.7% to 55.9%, which is still above SkillEvolver and the other automatic baselines. The largest gains from self-improvement appear in mathematics (24.0 points), media (22.2 points), and software engineering (11.4 points).
• KernelBench: Skill∞ achieves a mean correctness-weighted speedup of 1.62, versus 1.18 for SkillEvolver and 1.02 with no skill; on the deep narrow MLP and ShuffleNet problems it reaches 1.87 and 1.97, against 1.12 and 1.39 for SkillEvolver.
• Generality: With GPT-5.6 Luna as the backbone, Skill∞ reaches 66.5% against 61.2% for human-curated skills; with the OpenCode harness, 56.9% against 53.3%.
• Where the gains come from: On tasks that neither the agent alone nor human-curated skills solve (category D, 19 tasks), Skill∞ reaches 30.5% versus 22.1% for SkillEvolver. On tasks only human-curated skills solve at 40% or above (category C1, 13 tasks), it reaches 29.2% versus 15.4% for SkillEvolver.
• Budget scaling: On a task subset where the default budget substantially helps, the pass rate rises from 47.5% with one candidate to 82.5% with eight; even one candidate far exceeds the agent without a skill (12.5%).
• Cost: Optimizing a task skill with the refined meta-skill uses 8.7M input and 66k output tokens on average, close to SkillEvolver’s 8.1M and 76k. Self-improvement costs roughly as much as eleven task skill optimizations, adding less than 15% to each optimization when spread over the 83 task skills.
• Behavioral change, not just wording: Self-improvement changed the meta agent’s selection rule. The refined meta-skill selected 54% of tied candidates, versus 83% for the seed meta-skill, because it now requires evidence that a tied candidate addresses the targeted failure. A candidate meta-skill raised the meta score from 0.55 to 0.83.
• Task-skill case study: On a 3D scene export task where the seed skill failed all test trials, the optimized skill added an exporter script and passed all five test trials.

Methodology in Plain English

The researchers define a skill as a directory centered on a SKILL.md file whose front matter gives a name and description, with instructions in the body and optional scripts and references. Agents see only the name and description first, then load the full skill if they judge it useful — a mechanism the paper calls native skill discovery.

Two levels of optimization sit on top of this. At the task level, a meta agent follows a meta-skill to improve a task skill: it looks at the history stored in an archive, requests rollouts, diagnoses why the current skill failed, proposes one or two revised candidates with a written proposal each, evaluates them, and hands each to an independent reviewer in an isolated context. The reviewer rejects candidates that change nothing substantive, are never activated, or are unusable as written — preventing chance gains from being mistaken for progress. The meta agent decides how many candidates to try and when to stop, guided by its reading of scores, diagnoses, and reviews rather than a score-only heuristic; it can keep a tied candidate that made targeted progress or backtrack when revisions stall.

At the meta level, the same loop is applied to the meta-skill. A “skill optimization task” pairs a seed task skill with tasks and a search budget, and a meta-skill’s score is the average gain of the task skills it produces over their seeds. The meta-skill is refined across several such tasks from different domains, then frozen and reused on new task skills. Scoring itself is deliberately kept outside the scope of self-improvement so gains cannot come from tampering with the reward.

Experiments use the Codex CLI with GPT-6 Luna at high reasoning effort, Harbor for running trials, and a search budget capped at four candidates per task skill; results are averaged over five independent runs, with KernelBench runtimes measured on an NVIDIA A100.

Why This Matters

Impact on research: The paper reframes RSI for language agents in a concrete, inspectable form. Because the optimizer is a skill package rather than a program or a trained policy, every change to the improvement procedure can be read, versioned, and carried across harnesses that support the same open skill specification. It also shows that improvements transfer across tasks instead of being relearned per task, and that evaluating skills the way they are actually deployed — discovered rather than injected — changes what gets optimized, including the skill’s description.

Real-world applications:

• Coding and software engineering assistants: automatically building and refining reusable procedures for repository-level tasks, where Skill∞ leads with 65.7%.
• GPU kernel and performance engineering: producing skills that reliably yield faster correct implementations, as measured by speedups of 1.87 and 1.97 on two KernelBench problems.
• Scientific and mathematical reasoning workflows: the domain with the largest self-improvement gain, reaching 92.0%.
• Content and media pipelines: including 3D asset export, where an optimized skill added a reusable exporter script and passed all five test trials.

Industry relevance: Teams deploying agents across different harnesses can invest once in refining a meta-skill and reuse it across many task domains, with the added cost estimated at under 15% per optimization. The portability across harnesses and backbone models — verified with OpenCode and GPT-5.6 Luna — matters for organizations that do not want their optimization pipeline tied to one vendor’s tooling. The paper also flags a deployment risk: optimized skills contain executable scripts that an agent may activate without user approval.

Future Directions

• Moving beyond a fixed backbone model. The authors note that Skill∞ improves skills while the model stays fixed, so gains are bounded by the expressiveness of skill packages; combining skill-level RSI with model or harness updates is an open question.
• Reducing reliance on automatic verifiers. The meta score is computed from task rewards, so the method applies only where rewards can be computed reliably; extending it to domains without dependable automatic verification is unresolved.
• Enforcing adherence to the meta-skill. Agent-led optimization trades enforcement for flexibility — the meta agent follows its procedure rather than executing it as code, so results depend on how reliably the model follows long instructions, with no tool enforcing compliance.
• Broadening the self-improvement evidence base. The reported case studies cover a small number of optimization runs, and the budget-scaling analysis is run on a subset of tasks; more systematic study of how far recursive refinement can go, and when it plateaus, remains open.

Target Audience

Researchers and engineers working on LLM agents, agent skill libraries, and automatic prompt or context optimization will get the most from this paper, particularly those interested in self-improving systems and in evaluation setups that mirror real deployment. It is also useful for practitioners who maintain skill repositories across multiple agent harnesses and want an automated way to improve them, and for readers tracking the practical, small-scale incarnations of recursive self-improvement.

Authors’ abstract

Recursive self-improvement (RSI), in which a system also improves the way it improves, is a long-standing aspiration on the path to AGI. Language agents increasingly store procedural knowledge in reusable skills. Optimizing skills offers a direct way to achieve RSI, because the optimization procedure itself can be encoded as a skill. Existing skill optimizers, however, follow a hand-designed procedure. Even methods that evolve a meta-skill confine it to a fixed pipeline and relearn it for each task. We present Skill$^{\infty}$, which makes skill optimization recursively self-improving: a meta agent follows a meta-skill to optimize task skills and optimizes the meta-skill itself using the same procedure. The optimization is agent-led. The meta agent diagnoses execution traces, proposes candidates, requests independent reviews, and allocates the search budget. The meta-skill defines these steps, allowing self-improvement to rewrite them. This meta-skill is also decoupled from task skills, refined on multiple skill optimization tasks and then reused to optimize task skills across diverse domains. As in deployment, skills at both levels are standard packages loaded through native skill discovery. On 83 SkillsBench tasks, Skill$^{\infty}$ reaches a pass rate of 60.7%, compared with 56.4% for human-curated skills and 54.5% for SkillEvolver.