MetaSkill Evolve: Agents are starting to learn how to learn, how far is recursive self-improvement from reality? ---This unpopular paper may be the most interesting one this month, apart from the popular nvda paper Red Queen G ö del Machine Recently, LMU Munich、MCML、 The Chinese University of Hong Kong has jointly released a paper MetaSkill-Evolve: Recursive Self-Improvement of LLM Agents via Two-Timescale Meta-Skill Evolution。 This paper raises a new question: Agents should not only learn how to complete tasks (skills) and improve their skills, but also learn how to continuously enhance and improve their skills (Meta Kill). This means that for the first time, the optimization object of the agent has expanded from "how to do well" to "how to improve the ability to continuously do well". 1、 From Skill Evolution to Meta Kill Evolution In the past six months, Self Improving Agents have become a hot topic. Whether it's Reflexion, SkillWeaver, GEPA, or EvoSkill, they all follow a similar process in essence: Execute the task ↓ Failure Analysis ↓ Modify Skill ↓ Re-execute Skill is constantly evolving, but the entire improvement process remains unchanged. For example: How to analyze failure? How to search for historical experience? How many modification plans can be generated at once? How to truly modify skills? These processes are almost all manually designed. MetaSkill Evove believes that this is the real limitation on the long-term ability growth of agents. The paper proposes that since Skill can continuously evolve, why can't the evolution mechanism of Skill continue to evolve? 2、 What exactly is Meta Skill? The paper breaks down the entire Skill Evolution Pipeline into five independently evolving modules: Analyzer (ψ): Analyze the reason for the failure. Retriever (σ): Searching for historical experience. Allocater (α): determines the search budget and how many candidates are generated. Proposer (π): Propose specific modification plans. Evolver (ε): Truly modify the Skill file. The traditional method fixes these five modules, while MetaSkill Evolve also represents them as Markdown Skill files, using the same form as regular Skills, so they can also be modified by Agents. So the system forms two layers of loops: Fast Loop Task ↓ Skill Evolution Responsible for continuously optimizing Task Skills. Slow Loop Meta Skill Evolution ↓ Modify the working mode of Fast Loop Responsible for continuously optimizing the entire Skill Evolution Pipeline. The paper is called Two Temporal Evolution. This is actually increasing inference power, not model parameters There is another noteworthy feature of this paper: The entire system always uses the same frozen Gemma-4 31B. No training, no fine-tuning, no new models added. All performance improvements come from: More Agent Calls More Reasoning Tokens More searches More Skill Evolution Therefore, it belongs to typical Inference Time Scaling. let me put it another way: It's not about making the model bigger, but about making the reasoning more complex. This trend is highly consistent with recent work by AlphaEvolve, Deep Research, Darwin G ö del Machine, Red Queen G ö del Machine, and others. The improvement of future agent capabilities is likely to increasingly rely on inference computation rather than continuing to increase model parameters. 3、 The difference between Reflection and MetaSkill Many people would understand it as an upgraded version of Reflection. In fact, the two are not the same. Reflection： Execute ↓ Reflection ↓ Re-execute Token consumption roughly increases linearly with the number of reflections. If Reflection N times: Cost ≈ O(N) MetaSkill Evolve not only adds Reflection, but also adds multiple new computational dimensions. A Skill Evolution includes: Analyzer Retriever Allocator Proposer Evolver Subsequently, the allocator may also generate multiple Candidates, each of which needs to re execute the benchmark. Every H times, the Meta Loop needs to be run again to analyze and modify the entire Evolution Pipeline itself. Therefore: Task Compute + Skill Evolution Compute + Meta Evolution Compute + Retrieval Compute All become part of the cost of reasoning. Essentially, this is a Loop of Loop. Will tokens grow exponentially? Intuitively, it seems to be possible. Because each Evolution may generate multiple Children: Skill0 ├──Skill1 ├──Skill2 └──Skill3 If each Child generates three more: three ↓ nine ↓ twenty-seven ↓ eighty-one Theoretical complexity is: O(K^Depth) That is, exponential growth. But the paper does not allow for infinite expansion of the search tree. The reason lies in its other core design: Frontier Search。 4、 Frontier Search: Pushing Index Search Back to the Computable Range Frontier Selection is one of the most important engineering designs in the entire paper. Its idea is very simple: Always expand only the few branches that are most worth exploring. The paper saves all skills to SQLite DAG. For example: Skill0 ├──Skill1 │ ├──Skill4 │ └──Skill5 ├──Skill2 │ ├──Skill6 │ └──Skill7 └──Skill3 The entire DAG will continue to grow larger. However: Only Frontier will truly continue to expand. Paper default: Frontier Size = 3 in other words: Whether a DAG has dozens or hundreds of nodes, there are always only three branches that continue to evolve simultaneously. How to choose Frontier? The paper is evaluated using three indicators: Utility How good is the current skill. For example, the current accuracy. Meta Productivity The biggest innovation of the paper. It's not about looking at today's best, but about looking at: Does this branch continue to produce better and better offspring. For example: Branch A： eighty ↓ eighty-one ↓ eighty-two ↓ eighty-three Continuously growing. Branch B： ninety-five ↓ ninety-five ↓ ninety-five Although the score is high, evolution has stopped. The paper suggests that computing resources should continue to be invested in Branch A. Novelty Prevent all computing resources from being concentrated in the same branch. Branches that have been extensively expanded will have a lower score. Final rating: Score = Utility + Meta Productivity + Novelty Then select Top-K as the new Frontier. Therefore, Frontier actually controls the search that could have grown exponentially within an approximately linear computational budget. Why does the entire DAG still need to be saved? Although Frontier only extends a small number of nodes, the entire DAG will not be deleted. The reason is Retriever. For example: The current Branch has encountered: Table Parsing Error Retriever can search for: Was there a branch in the past Have you solved similar problems before? Even though that Branch had already exited Frontier a long time ago, its experience can still be reused. This is the Cross Branch Retrieval emphasized in the paper. The search has stopped. Experience has not stopped. How is the experimental effect? All experiments in the paper are based on the same frozen Gemma-4 31B. 5、 Final result: Benchmark improves OfficeQA+23.54SelQA+16.09ALFWorld+1.92 compared to the original model Compared to regular Skill Evolution: Meta Skill brings additional benefits: OfficeQA：+6.38 SealQA：+8.05 ALFWorld：+1.92 The paper also conducted a complete ablation experiment. As a result, it was found that: The most important aspect of OfficeQA is the allocator. The most important aspect of SealQA is the proposer. ALFWorld mainly relies on Cross Branch Retrieval. The Meta Skills that truly determine performance for different tasks are not the same. 6、 Personal opinion The truly important aspect of this paper is not how much performance has been improved, but rather the proposal of a new paradigm for agent evolution. past times: Model ↓ Answer Later on: Model ↓ Reflection ↓ Answer Now it starts to become: Model ↓ Skill ↓ Meta Skill ↓ Frontier Search ↓ Retriever ↓ Verifier ↓ Answer The model has not changed. Reasoning is becoming increasingly complex. The future capabilities of agents are likely to increasingly rely on Inference Time Scaling rather than continuing to rely on larger parameter scales. If we look at the recent popular nvda paper Red Queen G ö del Machine and MetaSkill Evove together, we can see a common trend: Agents are gradually evolving from 'one-time inference' to 'continuous evolution'. What truly determines the upper limit of capability is no longer just the model itself, but how much computing resources the model can schedule and how much search space it can continuously search for a better version of itself.