UCAS Researchers Teach Weak LLM Agents to Handle Skills: Up to +14.1 Points Without Fine-Tuning

Agent harnesses that accumulate experience from past runs and rewrite their own "skills" are considered a cheap way to improve LLM agents without fine-tuning model weights. Researchers from the University of Chinese Academy of Sciences (Zhihao Yang, Haojin Wang, Juncheng Wu and co-authors, with Xianpei Han as the senior author) tested whether this approach benefits all models equally. It doesn't. Across seven models and three benchmarks, they found 103 task-skill pairs where the same skill boosts GPT-5.6-luna by 31.1 points while dropping Gemma-4-E4B by 8.8.

A Skill the Weak Model Can't Execute

The intuitive explanation would be that the weak model simply lacks knowledge. The data says otherwise. In 86% of the weak model's failed runs, the requirement it violated was already explicitly written into the skill. The model saw the instruction and still couldn't apply it. The instruction was written at a level the executor isn't capable of implementing: too long a chain of actions, implicit assumptions, or overly complex tool use.

This reframes the problem. If a skill grown by a strong model is transferred to a weak model as-is, it can make results worse. And if a weak model writes its own skill from its own trajectories, it tends to lock in phrasings it can't actually execute. What's needed is adaptation of the skill to the executor: same meaning, but in a form the model is capable of carrying out.

A Meta-Skill as a Rewriting Instruction

The researchers broke down weak executors' failures into four categories:

• tool execution;
• context management;
• instruction following;
• result verification.

From these diagnoses, they assembled a fixed meta-skill — a set of principles for rewriting a skill to make it easier to execute. In the first experiment, Kimi-K3 served as the rewriter, adapting skills without access to execution traces, relying solely on the meta-skill. Three weak executors beat their original skills by 5.1 to 14.1 points.

Five Rounds of Self-Evolution

Next, the researchers embedded the meta-skill into the self-evolution cycle itself. Over five rounds, each model revises its own skill based on run trajectories and verifier feedback. They tested seven executors, from Gemma-4-E4B to Kimi-K2.5. Final scores with the meta-skill were 2.0 to 5.1 points higher than the same cycle without it. The improvement held consistently across the whole range of models, not just at the weak end.

Key figures from the study:

• 7 executor models and 3 benchmarks;
• 103 task-skill pairs with divergent effects;
• +31.1 points for GPT-5.6-luna and −8.8 for Gemma-4-E4B on these pairs;
• 86% of the weak model's failures occurred when the requirement was already written into the skill;
• 4 failure categories used to build the meta-skill;
• +5.1–14.1 points for three weak executors after rewriting by Kimi-K3;
• 5 rounds of self-evolution and a +2.0–5.1 point gain from the meta-skill.

What to Change in Agent-Based Projects

The practical takeaway for anyone building agentic systems: a skill library can't be treated as universal. If the same set of instructions is distributed to models of different classes — say, an expensive model for complex tasks and a compact local one for routine work — each executor needs its own version. Rewriting can be delegated to a strong external model following a fixed rule set, which is cheaper than running a full self-evolution cycle on a weak model.

Second, when evaluating self-learning harnesses, it's worth looking not just at average gains but at the pairs where a skill actually hurts. Those are exactly the cases that reveal an instruction has exceeded the executor's capabilities. The code and project page have been published by the authors, so the meta-skill can be tested on your own tasks and models.