Skill∞: an agent improves its own skills and its own meta-skill, 60.7% on SkillsBench

A team from the National University of Singapore has proposed a way to close the self-improvement loop at the level where it's easiest to do in practice — the skills of language agents. The Skill∞ system uses a meta-agent: it follows a meta-skill to optimize skills for specific tasks, then applies the same procedure to the meta-skill itself. On the 83-task SkillsBench benchmark, the method achieved a 60.7% pass rate. Human-authored skills score 56.4%, while the closest automated competitor, SkillEvolver, scores 54.5%. The gap over humans is 4.3 percentage points; over SkillEvolver, 6.2 points.

Why skills are suited to recursion

Recursive self-improvement (RSI) — where a system improves both itself and the way it improves — has long been seen as a possible path to AGI. The authors approach this from a practical angle. Language agents increasingly store procedural knowledge as reusable skills: packages of instructions that an agent loads for a given task. If the optimization procedure is itself framed as a skill, it can be improved using the same tools as any other skill.

Existing skill optimizers don't work this way. They follow a procedure designed by a human. Even methods that evolve the meta-skill lock it into a fixed pipeline and retrain it from scratch for every task. Skill∞ removes both constraints: the meta-skill isn't tied to a pipeline, and it isn't retrained from zero.

What the meta-agent does

Optimization in Skill∞ is carried out by the agent itself, not by an external script. The meta-skill describes four actions, and self-improvement can rewrite any of them:

• diagnosing execution traces: the agent analyzes where and why a skill failed on tasks;
• generating candidates: based on the diagnosis, the agent proposes new versions of the skill;
• independent review: the agent requests evaluation of candidates from separate reviewers;
• allocating search budget: the agent decides for itself where to direct limited resources.

Another feature is level decoupling. The meta-skill is separated from task-level skills. It's refined on several skill-optimization tasks and then reused across different domains without retraining. Skills at both levels remain standard packages, loaded through the regular skill-discovery mechanism, just as in a real deployment. No separate infrastructure is needed to implement it.

The SkillsBench numbers

The comparison was run on 83 SkillsBench tasks, measured by task pass rate:

• Skill∞ — 60.7%;
• human-authored skills — 56.4%;
• SkillEvolver — 54.5%.

The key takeaway isn't the absolute number. Automatically optimized skills beat hand-written ones, and the procedure that optimized them was itself a product of optimization. The authors of the paper are Wangcheng Tao, Zhanglu Yan, Han Wu, and Weng-Fai Wong. The preprint was published as arXiv 2610.35434 and made it into Hugging Face Papers' daily digest.

Takeaways for teams building agents

If your stack already uses skills packaged in a standard format, two ideas from this work are worth a closer look. First: the procedure for improving skills can itself be described as a skill rather than hard-coded into pipeline logic. That way it's edited with the same tools and over the same traces. Second: independent review of candidates and search-budget management are better left to the agent itself, since these are steps the meta-skill can redesign for the task at hand.

For now this is a result on a single 83-task benchmark, and transfer to real-world workloads still needs to be verified. But the direction is clear: skill libraries are ceasing to be static folders of instructions and starting to pull themselves up to a level that used to require manual tuning. Automated optimizers are already outpacing human-authored baselines, and built-in self-improvement of the procedure has added them a few more percentage points.