// MetaSkill-Evolve //

Great paper on self-improving agents.

Most self-improving agents rewrite what the agent does and leave how it improves frozen and hand-authored. That improvement procedure never adapts.

New research closes that gap with MetaSkill-Evolve. It evolves the task skill on a fast loop and the improvement procedure itself on a slower one, both driven by the same pipeline applied to itself.

Each branch carries five pipeline agents (Analyzer, Retriever, Allocator, Proposer, Evolver) sharing one frozen backbone, so the recursion adds no new model and no new training objective.

Held-out accuracy over the raw backbone jumps +23.54 on OfficeQA and +16.09 on SealQA, with a smaller +1.92 on ALFWorld.

Paper: https://arxiv.org/abs/2607.05297

Learn to build effective AI agents in our academy: https://academy.dair.ai

Recursive Self-Improvement of LLM Agents via Two-Timescale Meta-Skill Evolution

Source: https://arxiv.org/html/2607.05297 Zefeng Wang*,1,Minxi Yan*,2,Jinhe Bi1,Sikuan Yan1,Volker Tresp1,Yunpu Ma1,3,4 1LMU Munich,2The Chinese University of Hong Kong,3MCML,4MemAgents Lab

Abstract

Recent LLM agents tackle increasingly long-horizon, open-ended tasks, and external skills, reusable procedural knowledge supplied to the agent, further extend this capability. However, a fixed, hand-authored skill is rarely optimal, and cannot adapt to the diversity of tasks an agent encounters. Self-improving agents address this by rewriting their own skill files from execution traces, yielding meaningful gains on challenging benchmarks. Yet such self-evolution remainsnon-recursive: it improves only the task skill (whatthe agent does) while the improvement procedure (howit improves) is authored once and held fixed. We introduceMetaSkill-Evolve, a two-timescale framework that makes agentic skill improvementrecursive: every branch carries both a task skillssand a branch-local meta-skillm=(ψ,σ,α,π,ε)m=(\psi,\sigma,\alpha,\pi,\varepsilon)whose five components parameterise the Analyzer, Retriever, Allocator, Proposer, and Evolver agents of the improvement pipeline. Task skills evolve on a fast loop while the meta-skill evolves on a slower one under thesamepipeline applied to itself, with no additional model or objective. With all five pipeline agents sharing a single frozen backbone, MetaSkill-Evolve outperforms no-skill, static-skill, and single-level evolution baselines on three agentic benchmarks (OfficeQA, SealQA, ALFWorld), improving held-out test accuracy over the raw backbone by +23.54, +16.09, and +1.92 points respectively.

MetaSkill-Evolve: Recursive Self-Improvement of LLM Agents via Two-Timescale Meta-Skill Evolution

Zefeng Wang*,1, Minxi Yan*,2, Jinhe Bi1, Sikuan Yan1, Volker Tresp1, Yunpu Ma1,3,41LMU Munich,2The Chinese University of Hong Kong,3MCML,4MemAgents Lab

††*Equal contribution.Figure 1:Four regimes of agent skill improvement.No-Skill: no reusable skill memory.Static Skill: a hand-authoreds0s_{0}held fixed (padlocked).Single Level Evolve: the task skill evolvess0→s1→s2s_{0}\!\to\!s_{1}\!\to\!s_{2}, but the driving meta-process stays padlocked.MetaSkill-Evolve(ours): a branch-level meta-skillm=(ψ,σ,α,π,ε)m=(\psi,\sigma,\alpha,\pi,\varepsilon)co-evolves on a slower outer ring via thesamefive-agent pipeline that rewritesss, with no extra model and no extra framework.## 1Introduction

Language model agents now tackle increasingly long-horizon, open-ended tasks, from document understanding and multi-step reasoning to tool use, yet they rarely succeed out of the box(Yaoet al.,2023). A productive remedy is to equip the agent with askill: a curated, editable Markdown specification of reusable procedures, now a portable file-system artifact in widely deployed agent harnesses(Wanget al.,2023; Zhenget al.,2025). But a fixed, hand-authored skill is rarely optimal, and cannot anticipate the diversity of tasks an agent encounters. Self-improvement systems such as EvoSkill(Alzubiet al.,2026), GEPA(Agrawalet al.,2026), and SkillWeaver(Zhenget al.,2025)address this by closing the loop with an analyze–propose–evolve pipeline that rewrites the skill after each failure trace, so that iteration by iteration the skill grows more capable.

These systems, however, evolve onlywhatthe agent does, nothow it evolves: the artifact under optimization changes while the operator that optimizes it stays fixed. In the vocabulary of self-improving machines(Good,1965; Schmidhuber,2006), they are self-improving but stop short of beingrecursivelyself-improving. The meta-level logic is hardcoded in advance and shared by every branch throughout the run: how failures are diagnosed, which edits are proposed, how much search effort is allocated, whether cross-branch experience is reused, and how an approved edit is applied to disk (Fig.1, third panel). A branch therefore cannot improve the way it diagnoses failures: it applies the same procedure to every error, whether a misread table or a faulty calculation, and when that procedure yields the wrong fix, nothing in the loop can revise it.

A closer look at this rigidity suggests that two quantities govern evolutionary skill search. The first is thecurrent skill utilityU​(s)U(s), the score of the present skill on a validation batch. The second is themeta-productivityP​(m∣s)P(m\mid s), the rate at which a branch generates stronger descendants under its current improvement policymm. These are not the same: a skill may score well today yet sit in a branch whose meta-level policy produces weak children, while a moderately-performing skill may reside in a branch whose policy reliably moves scores up, making it the more promising line to extend even though its present score lags behind. Optimizing onlyU​(s)U(s)ignores the second quantity entirely, and we hypothesize that this omission is a primary reason fixed-meta evolution stalls once repeated failures share a diagnosis style the meta-process cannot revise. This motivates the central question of our work:

Research QuestionCan the improvement procedure itself be evolved as a first-class object alongside the task skills it produces, using the same agentic pipeline?

To this end, we introduceMetaSkill-Evolve(Fig.1, rightmost panel), a two-timescale evolutionary framework that lifts the improvement procedure into a learnable object, yielding a practical, bounded form of recursive self-improvement in which the improvement operator is reflexively applied to itself. Every branch carries a stateb=(s,m,h)b=(s,m,h): a task skillss, a branch-level meta-skillm=(ψ,σ,α,π,ε)m=(\psi,\sigma,\alpha,\pi,\varepsilon), and an iteration historyhh. The task skill evolves at every iteration on the fast timescale; the meta-skill evolves everyHHiterations on the slow timescale, driven by how much the branch’s lastHHdescendants improved, i.e., a running measure of whether its current improvement policy is still productive. The five components ofmmjointly parameterise the improvement loop:ψ\psidiagnoses and tags a failure trace,σ\sigmacontrols cross-branch retrieval,α\alphasets the per-iteration child budget,π\piturns a diagnosis into a concrete edit proposal, andε\varepsilonapplies an approved proposal to the on-disk skill files and verifies that the result is coherent.

Crucially, this adds no architectural component: each component ofmmis a Markdown skill file identical in format to a task skill, so thesamefive-agent pipeline (Analyzer, Retriever, Allocator, Proposer, Evolver) that rewritesssis applied recursively to refinemmitself, closing the self-improvement loop on the very operator that performs it. The meta-skill in turn sharpens frontier selection beyond pure utility: each candidate parent is scored byη1​U​(s)+η2​P​(m∣s)+η3​N​(b)\eta_{1}U(s)+\eta_{2}P(m\mid s)+\eta_{3}N(b), whereN​(b)N(b)discounts branches already selected many times, steering the search toward branches that are at once productive and underexplored.

We evaluate the resulting system on three agentic benchmarks that stress complementary capabilities:OfficeQA(Opsahl-Onget al.,2026),SealQA(Phamet al.,2026), andALFWorld(Shridharet al.,2021). All five pipeline agents share a single frozen Gemma-4 31B(Google,2026)backbone, so any improvement is attributable to the evolved skills and meta-skills rather than to added model capacity or training. Against No-Skill, Static-Skill, and a Single-Level-Evolution baseline that ablates meta-skill updates, MetaSkill-Evolve improves held-out test accuracy by +23.54 / +16.09 / +1.92 points on OfficeQA / SealQA / ALFWorld over No-Skill, and by +6.38 / +8.05 / +1.92 points over Single-Level Evolution. On the two QA benchmarks the progression No-Skill→\toStatic→\toSingle-Level→\toOurs is monotonic; on ALFWorld the backbone is already near ceiling on the held-out split, so the margins are small and the static skill is roughly neutral.

In summary, our contributions are:

1. 1.Two-timescale frameworkseparating fast task-skill from slow meta-skill evolution, with meta-productivityP​(m∣s)P(m\mid s)as the slow objective alongside task utilityU​(s)U(s).
2. 2.Five-agent evolution pipelinethat extends the fixed analyze→\topropose→\toevolve loop with two typed stages they lack: a Retriever (σ\sigma) for cross-branch sharing and an Allocator (α\alpha) for an adaptive per-parent child budget, giving Analyzer, Retriever, Allocator, Proposer, Evolver.
3. 3.Recursive self-improvement via typed meta-skills.m=(ψ,σ,α,π,ε)m{=}(\psi,\sigma,\alpha,\pi,\varepsilon)as meta-skills, evolved by thesamefive-agent pipeline as task skills, a bounded, one-level recursion that needs no new model or objective.
4. 4.Meta-aware frontier selectionthat scores each candidate parent by utilityU​(s)U(s), meta-productivityP​(m∣s)P(m\mid s), and branch noveltyN​(b)N(b), steering search toward branches that are at once productive and underexplored.

2Related Work

Skill-based agents and skill self-improvement.

Askillis a reusable, named procedure that augments a frozen LLM agent and is now a portable artifact across agent harnesses(Wanget al.,2023; Zhenget al.,2025; Opsahl-Onget al.,2026; Liet al.,2026; Jianget al.,2026; Zhaoet al.,2026). A growing line closes the loop with execution feedback (reflection, distillation, analyze→\topropose→\toevolve and RL-driven rewrites, trajectory and memory-based methods)(Shinnet al.,2023; Zhaoet al.,2024; Alzubiet al.,2026; Xiaet al.,2026; Shiet al.,2026; Linet al.,2025; Zhanget al.,2026b; Fanget al.,2026; Niet al.,2026; Tianet al.,2026; Siet al.,2026; Huanget al.,2025; Yanget al.,2026a; Maet al.,2026a; Wanet al.,2025b), while a parallel sub-line grows a skilllibraryrather than a single artifact(Yanget al.,2026b; Liuet al.,2026; Shenet al.,2026; Wanget al.,2026; Maet al.,2026b; Zhanget al.,2026a). Throughout, theimprovement procedure(how failures are diagnosed, edits scoped, search allocated, experience reused) is authored once and held fixed. MetaSkill-Evolve makes that procedure a first-class, branch-local object, co-evolved by the same pipeline.

Recursive self-improvement.

Improving a system’s own capacity to improve traces to ultraintelligent machines(Good,1965; Wanet al.,2025a; Tianet al.,2025)and the Gödel machine, which rewrites its own code under a proof of improvement(Schmidhuber,2006). LLM-era instances drop the proof, improving a code-improvement scaffold(Zelikmanet al.,2024), co-evolving prompts and their mutation-prompts(Fernandoet al.,2023), or rewriting their own designs(Huet al.,2025; Zhanget al.,2026c). These systems recurse oncodeorpromptsunder one global policy. MetaSkill-Evolve instead recurses onskill files: the operator is a five-agent pipeline parameterised by a branch-local meta-skill that the same pipeline refines: a bounded, one-level recursion that adds no model and keeps a per-lineage rather than global policy.

Prompt, textual, and evolutionary optimisation.

Another body of work treats the agent’s prompt or context as the object of optimisation. Self-feedback, LLM optimisers, prompt compilation, textual gradients, evolutionary prompt search, and in-context search all improve the instructions seen by a fixed agent(Madaanet al.,2023; Biet al.,2025a; Yanget al.,2024; Khattabet al.,2023; Pryzantet al.,2023; Zhouet al.,2023; Yuksekgonulet al.,2024; Guoet al.,2025; Biet al.,2025c; Agrawalet al.,2026; Leeet al.,2025; Ouyanget al.,2026; Yeet al.,2026; Biet al.,2025b). Population-based program search makes the search object more executable by pairing behavioural archives with verifiers and recent extensions to coding agents and open-ended evolution(Novikovet al.,2025; Langeet al.,2025; Wanget al.,2025; Heet al.,2026; Biet al.,2026). All rewrite a single artifact under one fixed rule. We instead let the rule diverge across branches and evolve on its own timescale; our frontier scoreη1​Uv+η2​P^v+η3​Nv\eta_{1}U_{v}{+}\eta_{2}\hat{P}_{v}{+}\eta_{3}N_{v}usesP^v\hat{P}_{v}as a quality-diversity descriptor preserving improvement-policy diversity.

3MetaSkill-Evolve

This section presents MetaSkill-Evolve. We first formalise task-skill evolution and its utility objective (§3.1), then introduce the per-branchmeta-skillthat parameterises the search (§3.2). We next describe the persistent evolution graph and the score that decides which branch to expand (§3.3). The final two subsections detail the algorithm’s two timescales: afast loopthat evolves task skills on the selected parent (§3.4), and aslow loopthat, everyHHiterations, evolves the meta-skill itself by reapplying the same five-agent pipeline to the hidden meta-skill files (§3.5).

3.1Problem Formulation

Let𝒯\mathcal{T}be a task with inputsxxand expected outputsyy. Atask skillssis a Markdown-format LLM-agent program specifying procedures, tools, and heuristics for𝒯\mathcal{T}. WritingAsA_{s}for the agent that executes skillss, its utility is the expected task reward

U​(s)=𝔼(x,y)∼𝒯​[r​(As​(x),y)],U(s)\;=\;\mathbb{E}_{(x,y)\sim\mathcal{T}}\!\left[\,r\big(A_{s}(x),\,y\big)\right],(1)wherer​(⋅,⋅)∈[0,1]r(\cdot,\cdot)\in[0,1]scores a prediction against the reference output. Because𝒯\mathcal{T}is accessible only through samples,U​(s)U(s)is estimated as accuracy on a held-out validation batch.

3.2Branch State and Meta-Skill

Each task-skill iteration turns a failure into a skill edit through a fixed five-step procedure, i.e., diagnose, retrieve, allocate, propose, execute. MetaSkill-Evolve makes that procedure adaptive by attaching to each branch ameta-skillmmthat parameterises all five steps. Abranch stateisb=(s,m,h)b=(s,m,h), wherehhis the branch’s iteration history, and

m=(ψ,σ,α,π,ε).m=(\psi,\;\sigma,\;\alpha,\;\pi,\;\varepsilon).(2)Each component is itself a Markdown-format LLM-agent program (aSKILL.mdfile) consumed by exactly one specialist agent:

• •ψ\psi–diagnosis policy(Analyzer): maps failures to a tagϕ\phiand free-form analysisaa.
• •σ\sigma–sharing policy(Retriever): selects same-branch and cross-branch inspirations matchingϕ\phi.
• •α\alpha–allocation policy(Allocator): sets the child budgetK∈[1,Kmax]K\in[1,K_{\max}]per step.
• •π\pi–edit-proposal policy(Proposer): emits an editδ\deltaconditioned on the worst case, analysis, and retrieved inspirations, i.e.,(f,a,ℐ)(f,a,\mathcal{I}).
• •ε\varepsilon–edit-executor policy(Evolver): writesδ\deltato disk and verifies the result.

Since each meta-skill file uses the same Markdown representation as the task-skill files the pipeline already consumes, the same five agents that improvessalso improvemmwhen applied recursively.

A meta-skill is good insofar as it converts iterations into utility gains. We make this precise through themeta-productivityofmmat skillss, the expected per-child improvement overKKproposals,

P​(m∣s)=𝔼​[1K​∑k=1K(U​(sk′)−U​(s))],P(m\mid s)=\mathbb{E}\!\left[\tfrac{1}{K}\textstyle\sum_{k=1}^{K}\bigl(U(s^{\prime}_{k})-U(s)\bigr)\right],(3)estimated per node by the empirical meanP^v=Δ​Uchildren of​v¯\hat{P}_{v}=\overline{\Delta U_{\text{children of }v}}(zero for nodes with no children). MetaSkill-Evolve jointly maximises task utilityU​(s)U(s)and meta-productivityP​(m∣s)P(m\mid s)across all branches: the fast loop improves the task skillss, and the slow loop improves the meta-skillmmthat produces those improvements.

Figure 2:System overview. The branch stateb=(s,m,h)b=(s,m,h)(left) feeds the five-agent pipeline (centre), whose output is appended to the SQLite node graph (right). Frontier selection (Eq.4) draws the next parent from the graph.

3.3Evolution Graph and Frontier Selection

We record the entire search history as a directed acyclic graph (DAG)𝒢=(𝒱,ℰ)\mathcal{G}=(\mathcal{V},\mathcal{E})persisted in SQLite. Each nodev∈𝒱v\in\mathcal{V}is one evaluated branch state and stores(sv,mv,Uv,Δ​Uv,ϕv)(s_{v},m_{v},U_{v},\Delta U_{v},\phi_{v})together with its branch path and selection counter. Edges are directed and of two kinds: alineageedgeu→vu\!\rightarrow\!vmarksvvas the child produced by evolving its parentuu, and aninspirationedge records a cross-branch node thatσ\sigmaretrieved when proposingvv. Both edge types point from an earlier node to a later one, so𝒢\mathcal{G}is acyclic by construction: each node is created once, from already-existing nodes, and is never revised in place. Persisting𝒢\mathcal{G}rather than keeping a fixed-size beam lets us revisit previously deprioritised lineages, supports cross-branch retrieval, and preserves full provenance for any final node.

A child enters thearchive(the pool of deployable states that also serves as the candidate set for future parents) only when it strictly improves on its parent,Δ​Uv>0\Delta U_{v}>0. Accuracy-neutral or regressing children (Δ​Uv≤0\Delta U_{v}\leq 0) are not eligible to be selected as parents, but are still persisted in𝒢\mathcal{G}: they preserve provenance and remain available toσ\sigmaas inspiration, so a neutral or failed edit can still inform a later proposal.

From the archive we refresh the frontierℱ\mathcal{F}each iteration to the top-KKnodes by

v∗=arg⁡maxv∈ℱ⁡[η1​Uv+η2​P^v+η3​Nv],v^{*}=\arg\max_{v\in\mathcal{F}}\bigl[\eta_{1}U_{v}+\eta_{2}\hat{P}_{v}+\eta_{3}N_{v}\bigr],(4)whereP^v\hat{P}_{v}is the meta-productivity estimate (Eq.3) andNv=1/(1+times_selectedv)N_{v}=1/(1+\texttt{times\_selected}_{v}). Each term targets a distinct failure mode of greedy search:

• •UvU_{v}– exploitation: prevents chasing volatile gain estimates on weak parents.
• •P^v\hat{P}_{v}– trajectory quality: redirects effort from plateaued high points to nodes still generating useful descendants.
• •NvN_{v}– visitation cooling: a node selectedkktimes must outperform an unselected sibling byη3​k/(k+1)\eta_{3}k/(k{+}1)to be re-picked, preventing budget monopolies.

Setting anyηi=0\eta_{i}{=}0exposes the corresponding mode: the frontier locks on stagnated high-utility nodes (η2=0\eta_{2}{=}0), collapses to one lineage (η3=0\eta_{3}{=}0), or trusts noisy single-child gains as parent quality (η1=0\eta_{1}{=}0). Crucially, we donotfilter by lineage: diversity is a property of the score, not a structural constraint.

3.4Fast Timescale: Task-Skill Evolution

The fast loop (Algorithm1) runs one task-skill iteration on a frontier parentvv. Before invoking any agent, the runtime restores the selected branch’s task and meta snapshots(sv,mv)(s_{v},m_{v})to disk. Thus the SQLite DAG, rather than whatever files remain in the working tree, defines branch state: each branch starts from its recorded snapshot and is evaluated in isolation, preventing leakage between lineages. We then scoresvs_{v}on the training batch and take itsworst-scoringexample as the diagnostic target: a deliberately high-signal choice, hedged against outliers because each resulting edit is judged by its validation gainΔ​Uv\Delta U_{v}rather than by that single training case. This example drives the five-agent pipeline:

• •Analyzer (ψ\psi): emits a tagϕ\phiand a free-form analysisaa; the tag vocabulary is itself maintained byψ\psiand revised by the slow loop.
• •Retriever (σ\sigma): ranks aϕ\phi-matched candidate pool by tag similarity, over-fetching to3×3{\times}the inspiration budget, then LLM-re-ranks this wider pool down to the inspirationsℐ\mathcal{I}handed to the Proposer; the breadth/depth balance is itself a learned object.
• •Allocator (α\alpha): choosesK∈[1,Kmax]K\in[1,K_{\max}], widening search after stagnation (P^≈0\hat{P}\approx 0) and contracting after a productive edit.
• •Proposer (π\pi): for each of theKKchildren emits an editδ\delta; whenK>1K{>}1a diversity hint steers thekk-th proposer toward a distinct intervention angle, reducing near-duplicate children.
• •Evolver (ε\varepsilon): translatesδ\deltainto file writes viaskill_toolsand verifies the result with a before/after hash check that flags edits leaving the target files unchanged.

Each childsk′s^{\prime}_{k}is evaluated on𝒟val\mathcal{D}_{\text{val}}to obtain its gainΔ​Uk\Delta U_{k}. EveryHHiterations the slow loop (§3.5) then refreshes the meta-skillmvm_{v}; theKKchildren are committed to𝒢\mathcal{G}carrying this refreshed meta-skill, and the frontier is re-synchronised before the next iteration.

Algorithm 1Fast timescale: one task-skill iteration1:Frontier parent

vv; train batch

𝒟train\mathcal{D}_{\text{train}}, val batch

𝒟val\mathcal{D}_{\text{val}} 2:

KKcommitted child nodes (those with

Δ​U>0\Delta U>0enter the archive)

3:Restore and evaluate

4:Restore snapshots

svs_{v}(task),

mvm_{v}(meta) to disk

5:

ℰ←Eval​(sv,𝒟train)\mathcal{E}\leftarrow\text{Eval}(s_{v},\mathcal{D}_{\text{train}})⊳\trianglerightcollect failures

6:if

ℰ\mathcal{E}has no failuresthenreturnall_passed

7:endif

8:

f←arg⁡mine∈ℰ⁡score​(e)f\leftarrow\arg\min_{e\in\mathcal{E}}\text{score}(e)⊳\trianglerightworst case

9:Diagnose and plan (3 agents)

10:

ϕ,a←Analyzer(f,mv.ψ)\phi,a\leftarrow\text{Analyzer}(f,\,m_{v}.\psi)⊳\trianglerighttag, analysis

11:

ℐ←Retriever(ϕ,bv,mv.σ)\mathcal{I}\leftarrow\text{Retriever}(\phi,\,b_{v},\,m_{v}.\sigma)⊳\trianglerightinspiring nodes

12:

K←Allocator(hv,a,ℐ,mv.α)K\leftarrow\text{Allocator}(h_{v},\,a,\,\mathcal{I},\,m_{v}.\alpha)⊳\trianglerightchild budget

13:Propose and evolve (KKchildren)

14:for

k=1​…​Kk=1\ldots Kdo

15:Restore

svs_{v} 16:

δ←Proposer(f,a,ℐ,mv.π)\delta\leftarrow\text{Proposer}(f,\,a,\,\mathcal{I},\,m_{v}.\pi) 17:

sk′←Evolver(sv,δ,mv.ε)s^{\prime}_{k}\leftarrow\text{Evolver}(s_{v},\,\delta,\,m_{v}.\varepsilon) 18:

Uk′←Eval​(sk′,𝒟val)U^{\prime}_{k}\leftarrow\text{Eval}(s^{\prime}_{k},\,\mathcal{D}_{\text{val}});

Δ​Uk←Uk′−Uv\Delta U_{k}\leftarrow U^{\prime}_{k}-U_{v} 19:endfor

20:Interleave slow loop, commit and sync

21:if

tmodH=0t\bmod H=0then

mv←m_{v}\leftarrowupdate meta-skill (Alg.2)

22:endif

23:Commit children

{⟨sk′,Δ​Uk,mv⟩}k=1K\{\langle s^{\prime}_{k},\ \Delta U_{k},\ m_{v}\rangle\}_{k=1}^{K}to

𝒢\mathcal{G} 24:

ℱ←SyncFrontier​(ℱ)\mathcal{F}\leftarrow\text{SyncFrontier}(\mathcal{F})⊳\trianglerightnext parent drawn by Eq.4

3.5Slow Timescale: Meta-Skill Evolution

Updatingmmat every iteration would expose the meta-skill to the same single-example noise that drives task-skill evolution. The slow loop (Algorithm2) instead fires once everyHHfast iterations and aggregates over that horizon, trading reactivity for stability. Its driving signal is the empirical meta-productivityP^​(m∣s)=1|ℋ|​∑u∈ℋΔ​Uu\hat{P}(m\mid s)=\tfrac{1}{|\mathcal{H}|}\sum_{u\in\mathcal{H}}\Delta U_{u}over the lastHHdescendantsℋ\mathcal{H}. We foldP^\hat{P}together with the tags, diagnoses, and outcomes of that window into a syntheticmeta-failure tracefmf_{m}: the improvement history reshaped to look like one failing training example, so that a single Analyzer prompt serves both timescales.

We then re-run the same five-agent pipeline onfmf_{m}, switching itstarget objectfrom task-skill files to the hidden meta-skill files. The Analyzer names the single most-implicated component of{ψ,σ,α,π,ε}\{\psi,\sigma,\alpha,\pi,\varepsilon\}; this diagnosis fixes the failure tagϕm\phi_{m}that steers retrieval, but it doesnotnarrow the edit scope. The Retriever surfaces cross-branch lineages whose meta-failure tags matchϕm\phi_{m}, the Allocator sets the round budgetKmK_{m}, and the Proposer and Evolver then co-editall fivefiles per round. The resulting snapshot of all five files becomes the child’smeta_state_json. Each branch therefore carries its own lineage-localmm, and the sole channel by which one lineage’s improvement policy reaches another is this meta-level retrieval, so escape strategies propagate between lineages without any shared global state. Three details separate this from a plain fast-loop run:

• •Constrained Analyzer.A null or task-skill diagnosis triggers a round-robin fallback over{ψ,σ,α,π,ε}\{\psi,\sigma,\alpha,\pi,\varepsilon\}, so the slow loop never aborts on an unusable target nor silently degrades into a redundant fast-loop run.
• •Whole-mmrewrite.Each child editsallfive meta-skill files in one step (Proposer sequential, Evolvers parallel), preserving cross-component coherence; for instance, aπ\piedit assuming a finer tag vocabulary is co-applied with the matchingψ\psiedit.
• •Accumulating children.Childk+1k{+}1reads the files as written by childkk, not by the parent; this moving target drives incremental refinement rather thanKmK_{m}independent overwrites that average back to the parent.

Algorithm 2Slow timescale: meta-skill update, attmodH=0t\bmod H=01:Branch history

ℋ\mathcal{H}(last

HHchildren); meta-skill

mm; parent

vv; names

ℳ={ψ,σ,α,π,ε}\mathcal{M}{=}\{\psi,\sigma,\alpha,\pi,\varepsilon\} 2:Snapshot of all five meta-skill files

3:Build meta-failure trace

4:

P^←1|ℋ|​∑u∈ℋΔ​Uu\hat{P}\leftarrow\tfrac{1}{|\mathcal{H}|}\sum_{u\in\mathcal{H}}\Delta U_{u}⊳\trianglerightmeta-productivity

5:

fm←f_{m}\leftarrowtrace of tags, diagnoses, outcomes over

ℋ,P^\mathcal{H},\hat{P} 6:Diagnose and plan (target∈ℳ\in\mathcal{M})

7:

ϕm,am←Analyzer​(fm,m)\phi_{m},a_{m}\leftarrow\text{Analyzer}(f_{m},\,m)⊳\trianglerightround-robin fallback

8:

ℐm←Retriever(ϕm,bv,m.σ)\mathcal{I}_{m}\leftarrow\text{Retriever}(\phi_{m},\,b_{v},\,m.\sigma) 9:

Km←Allocator(ℋ,am,ℐm,m.α)K_{m}\leftarrow\text{Allocator}(\mathcal{H},\,a_{m},\,\mathcal{I}_{m},\,m.\alpha) 10:Whole-mmrewrite (KmK_{m}accumulating children)

11:for

k=1​…​Kmk=1\ldots K_{m}do

12:Render meta-files from disk⊳\trianglerightreflects childk−1k{-}1

13:for

j∈ℳj\in\mathcal{M}do⊳\trianglerightProposer: sequential

14:

δm(j)←Proposer(fm,am∣tgt=j,ℐm,m.π)\delta_{m}^{(j)}\leftarrow\text{Proposer}(f_{m},\,a_{m}{\mid}\text{tgt}{=}j,\,\mathcal{I}_{m},\,m.\pi) 15:endfor

16:

{m(j)}←ParallelEvolver({δm(j)}j∈ℳ,m.ε)\{m^{(j)}\}\leftarrow\text{ParallelEvolver}(\{\delta_{m}^{(j)}\}_{j\in\mathcal{M}},\,m.\varepsilon)⊳\trianglerightone worker/file

17:endfor

18:returnsnapshot of

{m(j)}j∈ℳ\{m^{(j)}\}_{j\in\mathcal{M}}

4Experiments

4.1Setup

Benchmarks and backbone.

We evaluate on three agentic benchmarks chosen to span complementary capabilities:OfficeQA(Opsahl-Onget al.,2026),SealQA(Phamet al.,2026), andALFWorld(Shridharet al.,2021).

Within the evolution loop, each benchmark file is split by stratified sampling over its category column into three disjoint partitions: a training partition (failure mining), a validation partition (child scoring and best-skill selection), and a held-out test partition that the loop never observes. We then report accuracy of the selected skill on the held-out test partition through a separatebenchmark-mode pass.

A single frozen base model, Gemma-4 31B(Google,2026), serves all five pipeline agents (Analyzer, Retriever, Allocator, Proposer, Evolver); no agent is fine-tuned, so all gains are attributable to evolved skills and meta-skills.

Baselines.

We compare four configurations, all sharing the same backbone:

• •No-Skill: the base agent with no skill loaded and reflection disabled. Quantifies the raw backbone.
• •Static Skill: the same agent loaded with our hand-authored initial skill, held fixed for the entire run. Isolates the value of a skill artifactper se.
• •Single-Level Evolution: our fast loop with the slow loop frozen (Kmax=1K_{\max}{=}1, no cross-branch sharing, no meta-skill updates). Isolates the contribution of task-skill evolution alone.
• •MetaSkill-Evolve(ours): the full two-timescale system.

4.2Main Results

Table1and Fig.3report held-out test accuracy across the four conditions on all three benchmarks. The two QA benchmarks, where the backbone has the most headroom, tell the cleanest story.First, the static skill is worth several points over the raw backbone on OfficeQA (+4.31) and is roughly neutral on SealQA (+0.24).Second, replacing the fixed skill by single-level evolution (our fast loop with the slow loop frozen) adds a further +12.85 / +7.80 points, isolating the contribution of the inner evolution loop and the SQLite-backed evolution graph.Third, switching on the slow loop lifts performance by another+6.38 / +8.05points, a gain attributable to meta-skill adaptation, since the only difference from the Single-Level baseline is whether the meta-skill files{ψ,σ,α,π,ε}\{\psi,\sigma,\alpha,\pi,\varepsilon\}are themselves evolved. The progression No-Skill→\,\to\,Static→\,\to\,Single-Level→\,\to\,MetaSkill-Evolve is monotonic on both QA benchmarks, so each design choice (adding a skill, evolving it, then evolving the procedure that evolves it) pays off independently: end-to-end, MetaSkill-Evolve improves held-out accuracy over the raw backbone by+23.54points on OfficeQA and+16.09on SealQA.

ALFWorld stresses the opposite regime: the backbone already solves most episodes (92.31%), leaving little room to improve. The static skill slightly regresses (−1.93-1.93), and single-level evolution only recovers to the No-Skill baseline (92.31%), so neither non-meta step yields a net gain over the raw backbone. The slow loop alone supplies the entire end-to-end improvement of+1.92points (to 94.23%): small in absolute terms, but it indicates that meta-skill adaptation remains the operative ingredient even once task-skill evolution has saturated.

Figure 3:End-to-end held-out test accuracy on the three benchmarks.All conditions share the Gemma-4 31B backbone; only the skill-evolution strategy differs. Red annotations mark MetaSkill-Evolve’s gain over No-Skill; the No-Skill→\,\to\,Ours ordering improves on every benchmark, with the largest margins on the two QA tasks where the backbone has the most headroom.Table 1:Main results.Held-out test accuracy (%) on OfficeQA, SealQA, and ALFWorld; the test partition is never seen during evolution (App.F). ALFWorld reports the aggregate task success rate. All rows share the Gemma-4 31B backbone; only the skill-evolution strategy differs.Figure 4:Component ablations on the two QA benchmarks.Blue polygon: accuracy with one meta-skill component removed; dashed rings: full MetaSkill-Evolve and Static-Skill references. Dominant component differs by domain:α\alphaon OfficeQA,π\pion SealQA. ALFWorld in Table3.

4.3Component Ablations

To attribute the gains to specific design choices we disable one component at a time and re-run on all three benchmarks (Table3in App.E; QA benchmarks visualised in Fig.4). The configurations−ψ-\psi,−σ-\sigma,−α-\alpha,−π-\piablate the corresponding meta-skill component. In particular,−σ-\sigmaremoves the Retriever’s inspiration policy entirely; the separateno cross-branchcondition (denoted−σx-\sigma_{\mathrm{x}}in Fig.4) removes only cross-branch candidates while same-branch inspirations remain available. Theno meta-updatescondition freezes the slow loop entirely. The Evolverε\varepsilonalways executes (with−π-\piit consumes the raw analysis instead of a structured proposal), soε\varepsilondoes not carry its own ablation row.

Fig.4shows the component ablations on the two QA benchmarks. There are three findings. First,every typed component contributes: no single-component ablation matches the full system, although which component matters most differs by domain. Second, on OfficeQA theallocation policyα\alphais the single most important component (55.32→35.5855.32{\to}35.58,−19.7-19.7pts): the OfficeQA failure landscape contains pockets of related arithmetic errors whereα\alpha’s adaptive widening of the child budget after stagnation is what produces a successful child at all, andπ\pi(−17.7-17.7pts) is a close second. Third, on SealQA theedit-proposal policyπ\piis instead dominant (45.26→36.8445.26{\to}36.84), where the gain hinges on the precise content of each edit rather than on how widely the search fans out.

4.4Meta-Update Horizon

The horizonHHgoverns the coupling between the two timescales: it sets how many fast task-skill iterations elapse between consecutive meta-skill evolutions (§3.5). The choice cuts two ways. Firing the slow loop too often exposes the meta-skill to the single-example noise that aggregating overHHis meant to filter; firing it too rarely lets the meta-skill go stale relative to the drifting task skill, so its broader rewrites land on edits the fast loop has already moved past and overwrite productive changes. To probe this trade-off while holding total compute fixed, we keep the number of meta-updates at three and scale the iteration budget withHH, sweepingH∈{2,4,8}H\in\{2,4,8\}(equivalently 6, 12, and 24 fast iterations). Fixing the meta-update count makes theH=2H{=}2point here (6 iterations, three meta-updates) a slightly different operating point from the five-iteration default (two meta-updates atH=2H{=}2) behind Tables1and3: although all three are scored on the same held-out test partition, the extra iteration and meta-update mean its accuracies are not expected to coincide cell-for-cell with the full-system rows there.

Figure 5:Meta-update horizon sweep.Held-out test accuracy as the horizonHH(fast iterations between consecutive meta-skill evolutions) widens from 2 to 8, with the meta-update count held fixed at three, so total iterations=3​H=3H(shown in parentheses). The brokenyy-axis separates near-ceiling ALFWorld (top) from the two QA accuracies (bottom). The defaultH=2H{=}2(shaded band) is best on every benchmark; OfficeQA is by far the most sensitive to a stale meta-skill.Figure5(exact values in Table2, App.D) reports the sweep on the held-out test set. The tightest spacingH=2H{=}2is best on every benchmark, and accuracy falls as the meta-skill is refreshed less often, but the magnitude is strongly benchmark-dependent. OfficeQA is the most sensitive, shedding9.19.1points fromH=2H{=}2toH=8H{=}8(48.94→41.35→39.8448.94{\to}41.35{\to}39.84); SealQA and ALFWorld are nearly flat betweenH=2H{=}2andH=4H{=}4and slip only atH=8H{=}8(a0.90.9- and1.91.9-point drop overall). All three horizons already aggregate over multiple iterations, escaping the per-iteration noise that motivatesH>1H{>}1; among them the most reactive schedule wins, which fixes our default atH=2H{=}2.

5Conclusion

We introduced MetaSkill-Evolve, a two-timescale framework in which every branch carries a task skillssand a meta-skillm=(ψ,σ,α,π,ε)m=(\psi,\sigma,\alpha,\pi,\varepsilon)whose five components parameterise the improvement pipeline. Because each component ofmmis itself a Markdown LLM-agent program, the same pipeline that rewritessson the fast loop refinesmmon the slow loop, a bounded instance of recursive self-improvement that needs no extra model or training, while frontier selectionη1​Uv+η2​P^v+η3​Nv\eta_{1}U_{v}+\eta_{2}\hat{P}_{v}+\eta_{3}N_{v}redirects search from plateaued branches to ones whose improvement policy is still productive. The result is a +23.54 / +16.09 / +1.92 point gain in held-out test accuracy over the raw Gemma-4 31B backbone on OfficeQA / SealQA / ALFWorld, of which the slow loop contributes +6.38 / +8.05 / +1.92, evidence that an agent’s improvement policy admits the same search machinery as its task behaviour, and that separatingwhat to dofromhow to improvekeeps each loop’s signal interpretable.

Limitations

MetaSkill-Evolve is evaluated on three curated benchmarks; transfer to open-ended, long-horizon real-world tasks with noisier feedback is untested. The five-agent pipeline is itself fixed: we evolve the skills it produces but not its roles or wiring. Meta-updates fire at a fixed horizonHH.

References

• L. A. Agrawal, S. Tan, D. Soylu, N. Ziems, R. Khare, K. Opsahl-Ong, A. Singhvi, H. Shandilya, M. J. Ryan, M. Jiang, C. Potts, K. Sen, A. G. Dimakis, I. Stoica, D. Klein, M. Zaharia, and O. Khattab (2026)GEPA: reflective prompt evolution can outperform reinforcement learning.External Links:2507.19457,LinkCited by:§1,§2.
• EvoSkill: automated skill discovery for multi-agent systems.External Links:2603.02766,LinkCited by:§1,§2.
• J. Bi, Aniri, M. Yang, X. Zhou, W. Huang, S. Yan, Y. Wang, Z. Cao, M. Färber, X. Xiao, V. Tresp, and Y. Ma (2026)EchoRL: reinforcement learning via rollout echoing.InForty-third International Conference on Machine Learning,External Links:LinkCited by:§2.
• J. Bi, Y. Wang, D. Yan, X. Xiao, A. Hecker, V. Tresp, and Y. Ma (2025a)PRISM: self-pruning intrinsic selection method for training-free multimodal data selection.ArXivabs/2502.12119.External Links:LinkCited by:§2.
• J. Bi, Y. Wang, H. Chen, X. Xiao, A. Hecker, V. Tresp, and Y. Ma (2025b)LLaVA steering: visual instruction tuning with 500x fewer parameters through modality linear representation-steering.InProceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers),W. Che, J. Nabende, E. Shutova, and M. T. Pilehvar (Eds.),Vienna, Austria,pp. 15230–15250.External Links:Link,ISBN 979-8-89176-251-0Cited by:§2.
• J. Bi, D. Yan, Y. Wang, W. Huang, H. Chen, G. Wan, M. Ye, X. Xiao, H. Schuetze, V. Tresp, and Y. Ma (2025c)CoT-kinetics: a theoretical modeling assessing lrm reasoning process.ArXivabs/2505.13408.External Links:LinkCited by:§2.
• R. Fang, Y. Liang, X. Wang, J. Wu, S. Qiao, P. Xie, F. Huang, H. Chen, and N. Zhang (2026)Memp: exploring agent procedural memory.External Links:2508.06433,LinkCited by:§2.
• C. Fernando, D. Banarse, H. Michalewski, S. Osindero, and T. Rocktäschel (2023)Promptbreeder: self-referential self-improvement via prompt evolution.External Links:2309.16797,LinkCited by:§2.
• I. J. Good (1965)Speculations concerning the first ultraintelligent machine.Adv. Comput.6,pp. 31–88.External Links:LinkCited by:§1,§2.
• Google (2026)Google/gemma-4-31b.Note:Hugging Face model repositoryExternal Links:LinkCited by:§1,§4.1.
• Q. Guo, R. Wang, J. Guo, B. Li, K. Song, X. Tan, G. Liu, J. Bian, and Y. Yang (2025)EvoPrompt: connecting llms with evolutionary algorithms yields powerful prompt optimizers.External Links:2309.08532,LinkCited by:§2.
• Y. He, J. Liu, Y. Liu, Y. Li, T. Cao, Z. Hu, X. Xu, and B. Hooi (2026)EvoTest: evolutionary test-time learning for self-improving agentic systems.External Links:2510.13220,LinkCited by:§2.
• S. Hu, C. Lu, and J. Clune (2025)Automated design of agentic systems.External Links:2408.08435,LinkCited by:§2.
• X. Huang, Rishabh, G. Franke, Z. Yang, J. Bai, W. Bai, J. Bi, Z. Ding, Y. Duan, C. Fan, W. Fan, X. Gao, R. Guo, Y. He, Z. He, X. Hu, N. Johnson, B. Li, F. Lin, S. Lin, T. Liu, Y. Ma, H. Shen, H. Sun, B. Wang, F. Wang, H. Wang, H. Wang, Y. Wang, Y. Wang, Z. Wang, Z. Wang, Y. Wu, Z. Xiao, C. Xie, F. Yang, J. Yang, Q. Ye, Z. Ye, G. Zeng, Y. E. Zhang, Z. Zhang, Z. Zhu, B. Ghanem, P. Torr, and G. Li (2025)Loong: synthesize long chain-of-thoughts at scale through verifiers.External Links:2509.03059,LinkCited by:§2.
• Y. Jiang, D. Li, H. Deng, B. Ma, X. Wang, Q. Wang, and G. Yu (2026)SoK: agentic skills – beyond tool use in llm agents.External Links:2602.20867,LinkCited by:§2.
• O. Khattab, A. Singhvi, P. Maheshwari, Z. Zhang, K. Santhanam, S. Vardhamanan, S. Haq, A. Sharma, T. T. Joshi, H. Moazam, H. Miller, M. Zaharia, and C. Potts (2023)DSPy: compiling declarative language model calls into self-improving pipelines.External Links:2310.03714,LinkCited by:§2.
• R. T. Lange, Y. Imajuku, and E. Cetin (2025)ShinkaEvolve: towards open-ended and sample-efficient program evolution.External Links:2509.19349,LinkCited by:§2.
• Y. Lee, J. Boen, and C. Finn (2025)Feedback descent: open-ended text optimization via pairwise comparison.External Links:2511.07919,LinkCited by:§2.
• X. Li, Y. Liu, W. Chen, B. You, Z. Di, Y. He, S. Zheng, K. W. Choe, J. Sun, S. Wang, C. Tao, B. Li, X. Zhao, H. Geng, X. Wu, J. Zhou, X. Chen, H. Xing, Y. Li, Q. Zeng, D. Wang, Y. Wang, R. B. Chaim, P. Jiang, H. Shen, L. Kong, X. Liu, R. Wang, X. Liu, J. Li, X. Lan, Y. Lin, W. Ye, J. He, S. Li, Y. Zhang, Y. Gao, Y. Li, Z. Ma, L. Jing, T. Wang, K. Li, Y. Xue, H. Lyu, Y. He, Y. Tian, S. Wu, B. Wang, Y. Gao, B. Chen, L. Liu, S. Cheng, J. Bao, S. Tong, S. Xu, T. Y. Zhuo, T. Ye, Q. Qi, M. Li, L. Liao, Z. Tan, C. Shi, X. Tang, S. Tankasala, B. Yuan, Y. Qian, J. Tu, C. Wang, Y. Sun, W. Wang, A. Taylor, Z. Yang, C. Guan, Z. Dong, X. Zhang, S. Dillmann, H. Lee, and D. Song (2026)SkillsBench: benchmarking how well agent skills work across diverse tasks.External Links:2602.12670,LinkCited by:§2.
• J. Lin, Y. Guo, Y. Han, S. Hu, Z. Ni, L. Wang, M. Chen, H. Liu, R. Chen, Y. He, D. Jiang, B. Jiao, C. Hu, and H. Wang (2025)SE-agent: self-evolution trajectory optimization in multi-step reasoning with llm-based agents.External Links:2508.02085,LinkCited by:§2.
• X. Liu, X. Luo, L. Li, G. Huang, J. Liu, and H. Qiao (2026)SkillForge: forging domain-specific, self-evolving agent skills in cloud technical support.ArXivabs/2604.08618.External Links:LinkCited by:§2.
• X. Ma, Y. Ma, C. Lin, S. Yan, J. Bi, Z. Cao, Y. Tian, V. Tresp, and H. Schuetze (2026a)Self-evolving multi-agent systems via textual backpropagation.InFindings of the Association for Computational Linguistics: ACL 2026,M. Liakata, V. P. Moreira, J. Zhang, and D. Jurgens (Eds.),San Diego, California, United States,pp. 9918–9951.External Links:Link,Document,ISBN 979-8-89176-395-1Cited by:§2.
• Z. Ma, S. Yang, Y. Ji, X. Wang, Y. Wang, Y. Hu, T. Huang, and X. Chu (2026b)SkillClaw: let skills evolve collectively with agentic evolver.External Links:2604.08377,LinkCited by:§2.
• A. Madaan, N. Tandon, P. Gupta, S. Hallinan, L. Gao, S. Wiegreffe, U. Alon, N. Dziri, S. Prabhumoye, Y. Yang, S. Gupta, B. P. Majumder, K. Hermann, S. Welleck, A. Yazdanbakhsh, and P. Clark (2023)Self-refine: iterative refinement with self-feedback.External Links:2303.17651,LinkCited by:§2.
• J. Ni, Y. Liu, X. Liu, Y. Sun, M. Zhou, P. Cheng, D. Wang, E. Zhao, X. Jiang, and G. Jiang (2026)Trace2Skill: distill trajectory-local lessons into transferable agent skills.External Links:2603.25158,LinkCited by:§2.
• A. Novikov, N. Vũ, M. Eisenberger, E. Dupont, P. Huang, A. Z. Wagner, S. Shirobokov, B. Kozlovskii, F. J. R. Ruiz, A. Mehrabian, M. P. Kumar, A. See, S. Chaudhuri, G. Holland, A. Davies, S. Nowozin, P. Kohli, and M. Balog (2025)AlphaEvolve: a coding agent for scientific and algorithmic discovery.External Links:2506.13131,LinkCited by:§2.
• K. Opsahl-Ong, A. Singhvi, J. Collins, I. Zhou, C. Wang, A. Baheti, O. Oertell, J. Portes, S. Havens, E. Elsen, M. Bendersky, M. Zaharia, and X. Chen (2026)OfficeQA pro: an enterprise benchmark for end-to-end grounded reasoning.External Links:2603.08655,LinkCited by:§1,§2,§4.1.
• S. Ouyang, J. Yan, I. Hsu, Y. Chen, K. Jiang, Z. Wang, R. Han, L. T. Le, S. Daruki, X. Tang, V. Tirumalashetty, G. Lee, M. Rofouei, H. Lin, J. Han, C. Lee, and T. Pfister (2026)ReasoningBank: scaling agent self-evolving with reasoning memory.External Links:2509.25140,LinkCited by:§2.
• T. Pham, N. Nguyen, P. Zunjare, W. Chen, Y. Tseng, and T. Vu (2026)SealQA: raising the bar for reasoning in search-augmented language models.External Links:2506.01062,LinkCited by:§1,§4.1.
• R. Pryzant, D. Iter, J. Li, Y. T. Lee, C. Zhu, and M. Zeng (2023)Automatic prompt optimization with “gradient descent” and beam search.External Links:2305.03495,LinkCited by:§2.
• J. Schmidhuber (2006)Goedel machines: self-referential universal problem solvers making provably optimal self-improvements.External Links:cs/0309048,LinkCited by:§1,§2.
• S. Shen, W. Cheng, M. Ma, A. Turcan, M. J. Zhang, and J. Ma (2026)SKILLFOUNDRY: building self-evolving agent skill libraries from heterogeneous scientific resources.External Links:2604.03964,LinkCited by:§2.
• Y. Shi, Y. Chen, Z. Lu, Y. Miao, S. Liu, Q. GU, X. Cai, X. Wang, and A. Zhang (2026)Skill1: unified evolution of skill-augmented agents via reinforcement learning.External Links:2605.06130,LinkCited by:§2.
• N. Shinn, F. Cassano, E. Berman, A. Gopinath, K. Narasimhan, and S. Yao (2023)Reflexion: language agents with verbal reinforcement learning.External Links:2303.11366,LinkCited by:§2.
• M. Shridhar, X. Yuan, M. Côté, Y. Bisk, A. Trischler, and M. Hausknecht (2021)ALFWorld: aligning text and embodied environments for interactive learning.External Links:2010.03768,LinkCited by:§1,§4.1.
• S. Si, H. Zhao, Y. Lei, Q. Wang, D. Chen, Z. Wang, Z. Wang, K. Luo, Z. Wang, G. Chen, F. Qi, M. Zhang, and M. Sun (2026)From context to skills: can language models learn from context skillfully?.External Links:2604.27660,LinkCited by:§2.
• Y. Tian, S. Chen, Z. Xu, Y. Wang, J. Bi, P. Han, and W. Wang (2025)Reinforcement mid-training.External Links:2509.24375,LinkCited by:§2.
• Y. Tian, J. Chen, L. Zheng, M. Tao, X. Zeng, Z. Yin, H. Su, and X. Sun (2026)Skills-coach: a self-evolving skill optimizer via training-free grpo.External Links:2604.27488,LinkCited by:§2.
• G. Wan, L. Fu, H. Liu, Y. Jin, H. Y. Leong, E. H. Jiang, H. Geng, J. Bi, Y. Ma, X. Tang, B. A. Prakash, Y. Sun, and W. Wang (2025a)Beyond magic words: sharpness-aware prompt evolving for robust large language models with tare.External Links:2509.24130,LinkCited by:§2.
• G. Wan, X. Shang, Y. Wu, G. Zhang, J. Bi, L. Zheng, X. Lin, Y. Liu, Y. Ma, W. Huang, and B. Du (2025b)HYPERION: fine-grained hypersphere alignment for robust federated graph learning.InThe Thirty-ninth Annual Conference on Neural Information Processing Systems,External Links:LinkCited by:§2.
• C. Wang, Z. Yu, X. Xie, W. Yao, R. Fang, S. Qiao, K. Cao, G. Zheng, X. Qi, P. Zhang, and S. Deng (2026)SkillX: automatically constructing skill knowledge bases for agents.External Links:2604.04804,LinkCited by:§2.
• G. Wang, Y. Xie, Y. Jiang, A. Mandlekar, C. Xiao, Y. Zhu, L. Fan, and A. Anandkumar (2023)Voyager: an open-ended embodied agent with large language models.External Links:2305.16291,LinkCited by:§1,§2.
• Y. Wang, S. Su, Z. Zeng, E. Xu, L. Ren, X. Yang, Z. Huang, X. He, L. Ma, B. Peng, H. Cheng, P. He, W. Chen, S. Wang, S. S. Du, and Y. Shen (2025)ThetaEvolve: test-time learning on open problems.External Links:2511.23473,LinkCited by:§2.
• P. Xia, J. Chen, H. Wang, J. Liu, K. Zeng, Y. Wang, S. Han, Y. Zhou, X. Zhao, H. Chen, Z. Zheng, C. Xie, and H. Yao (2026)SkillRL: evolving agents via recursive skill-augmented reinforcement learning.External Links:2602.08234,LinkCited by:§2.
• C. Yang, X. Wang, Y. Lu, H. Liu, Q. V. Le, D. Zhou, and X. Chen (2024)Large language models as optimizers.External Links:2309.03409,LinkCited by:§2.
• M. Yang, X. Guo, Z. Shi, J. Bi, S. Bethard, M. Surdeanu, and L. Pan (2026a)AlignSAE: concept-aligned sparse autoencoders.External Links:2512.02004,LinkCited by:§2.
• Y. Yang, J. Li, Q. Pan, B. Zhan, Y. Cai, L. Du, J. Zhou, K. Chen, Q. Chen, X. Li, B. Zhang, and L. He (2026b)AutoSkill: experience-driven lifelong learning via skill self-evolution.External Links:2603.01145,LinkCited by:§2.
• S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao (2023)ReAct: synergizing reasoning and acting in language models.External Links:2210.03629,LinkCited by:§1.
• H. Ye, X. He, V. Arak, H. Dong, and G. Song (2026)Meta context engineering via agentic skill evolution.External Links:2601.21557,LinkCited by:§2.
• M. Yuksekgonul, F. Bianchi, J. Boen, S. Liu, Z. Huang, C. Guestrin, and J. Zou (2024)TextGrad: automatic “differentiation” via text.External Links:2406.07496,LinkCited by:§2.
• E. Zelikman, E. Lorch, L. Mackey, and A. T. Kalai (2024)Self-taught optimizer (stop): recursively self-improving code generation.External Links:2310.02304,LinkCited by:§2.
• H. Zhang, S. Fan, H. P. Zou, Y. Chen, Z. Wang, J. Zhou, C. Li, W. Huang, Y. Yao, K. Zheng, X. Liu, X. Li, and P. S. Yu (2026a)CoEvoSkills: self-evolving agent skills via co-evolutionary verification.External Links:2604.01687,LinkCited by:§2.
• H. Zhang, Q. Long, J. Bao, T. Feng, W. Zhang, H. Yue, and W. Wang (2026b)MemSkill: learning and evolving memory skills for self-evolving agents.External Links:2602.02474,LinkCited by:§2.
• J. Zhang, S. Hu, C. Lu, R. Lange, and J. Clune (2026c)Darwin godel machine: open-ended evolution of self-improving agents.External Links:2505.22954,LinkCited by:§2.
• A. Zhao, D. Huang, Q. Xu, M. Lin, Y. Liu, and G. Huang (2024)ExpeL: llm agents are experiential learners.External Links:2308.10144,LinkCited by:§2.
• X. Zhao, Q. Sun, J. Xiao, X. Liu, H. Yang, Q. Chen, X. Luo, J. Huang, Y. Zhong, L. Chen, S. Fu, Z. Wei, J. Bi, L. Jiang, H. Qiu, S. Yang, P. Shi, J. Hu, and Z. Zeng (2026)Beyond nl2code: a structured survey of multimodal code intelligence.External Links:2606.15932,LinkCited by:§2.
• B. Zheng, M. Y. Fatemi, X. Jin, Z. Z. Wang, A. Gandhi, Y. Song, Y. Gu, J. Srinivasa, G. Liu, G. Neubig, and Y. Su (2025)SkillWeaver: web agents can self-improve by discovering and honing skills.External Links:2504.07079,LinkCited by:§1,§2.
• Y. Zhou, A. I. Muresanu, Z. Han, K. Paster, S. Pitis, H. Chan, and J. Ba (2023)Large language models are human-level prompt engineers.External Links:2211.01910,LinkCited by:§2.

Appendix AFive-Agent Pipeline Details

All five agents are LLM-backedToolCallingAgentinstances sharing the same frozen base model; they load the skill catalog (task skills or meta-skills, depending on context) as additional context.

Analyzer (ψ\psi).

Given the execution trace and failure reason of the worst-scoring training example, the Analyzer produces (i) a structured root-cause analysis, (ii) a short failure tagϕ\phi(at most 15 words), and (iii) the target skill file to edit. It uses a three-layer recovery chain: primary parse offinal_answer, step-level output scanning across all agent steps, and a repair call with constrainedresponse_format. Thetarget_skillfield is auto-derived fromrelevant_sectionswhen not explicitly provided, improving robustness with smaller models.

Retriever (σ\sigma).

Givenϕ\phiand the current branch path, the Retriever fetches same-branch and cross-branch candidates from the SQLite graph store, over-fetched to3​Lsame3L_{\text{same}}and3​Lcross3L_{\text{cross}}by tag similarity, and LLM-re-ranks them by relevance to the present failure, returning the subset it judges relevant.

Allocator (α\alpha).

Given recentΔ​U\Delta Uvalues along the branch and the analysis, the Allocator chooses a child budgetK∈[1,Kmax]K\in[1,K_{\max}], allocating more search effort on stagnation and less when recent edits have been productive.

Proposer (π\pi).

Given the failure analysis, the used skill materials, and the inspiring nodes, the Proposer produces a concrete edit proposal: target section, change, and rationale. WhenK>1K{>}1, a diversity hint instructs it to take a distinct intervention angle from prior child proposals.

Evolver (ε\varepsilon).

The Evolver reads the current skill file, writes the edited version, and verifies that the mutations are consistent with the proposal summary. After each apply, the skill registry is refreshed so subsequent evaluations use the updated skill.

Appendix BMeta-Skill Representation and Skill-Catalog Disclosure

Each meta-skill componentψ,σ,α,π,ε\psi,\sigma,\alpha,\pi,\varepsilonis stored as aSKILL.mdfile under the project skills directory (e.g.,skills/meta-analyzer/SKILL.md) and snapshotted into the SQLite node graph alongside the task-skill snapshot, so each node carries a complete, self-contained record of both task-level and meta-level state at creation. When a branch is selected for expansion, its meta-skill snapshot is restored from the node record before the five-agent pipeline runs, ensuring each branch applies its own lineage-specific improvement policy. Branches can thus diverge in their meta-level heuristics: one may have learned an aggressive edit policy for table-extraction failures while another developed conservative, incremental edits for arithmetic reasoning failures.

Skill-catalog progressive disclosure.

Agents receive a compact catalog first (skill names and one-line summaries), then load the fullSKILL.mdonly for the skill they identify as relevant, and load resource files on demand. This keeps context length manageable while preserving full expressiveness.

Appendix CMeta-Skill Prompt Templates

Each meta-skill component is initialized as a brief Markdown document that describes its role in the evolutionary process. For example, the initial diagnosis policyψ\psiinstructs the Analyzer to: (i) identify the primary failure class from the execution trace, (ii) distinguish between skill-addressable failures and base-model capability limits, and (iii) assign a short, specific failure tag.

Appendix DHyperparameter Sensitivity

Defaults.

Frontier weightsη1=1.0\eta_{1}{=}1.0,η2=0.5\eta_{2}{=}0.5,η3=0.25\eta_{3}{=}0.25; meta-update horizonH=2H{=}2; iteration budget 5 fast iterations (two meta-updates atH=2H{=}2); child budgetK∈[1,Kmax]K\in[1,K_{\max}]withKmax=3K_{\max}{=}3and an initialK=2K{=}2that the Allocator adapts per step (this initial value is what the−α-\alphaablation freezes to); frontier sizeKℱ=3K_{\mathcal{F}}{=}3, with early stopping after 5 iterations without a frontier improvement. Category-aware round-robin training draws 6 categories per batch and 3 samples per category. Cross-branch sharing uses retrieval probabilitypcross=0.2p_{\text{cross}}{=}0.2and same-/cross-branch inspiration limitsLsame=3L_{\text{same}}{=}3,Lcross=2L_{\text{cross}}{=}2(over-fetched at3×3\timesbefore LLM re-ranking, §3.4). Evaluation concurrency defaults to 16, raised to 128 for the QA benchmarks under the vLLM backend; it affects only throughput, not accuracy.

Sensitivity to cross-branch sharing.

Sweeping the Retriever’s cross-branch candidate limit confirms that moderate cross-branch retrieval consistently improves performance on both OfficeQA and SealQA; very aggressive cross-branch retrieval introduces noise by supplying irrelevant inspirations from branches working on structurally different failures.

Table 2:Meta-update horizon sweep (held-out test accuracy, %), the exact values plotted in Fig.5.HHis the number of fast task-skill iterations between consecutive meta-skill evolutions; the number of meta-updates is held fixed at three, so the iteration budget scales as3​H3H. The tightest spacingH=2H{=}2is best on every benchmark; wider gaps let stale meta-rewrites overwrite productive edits.

Appendix EFull Ablation Tables

Table3expands the component-ablation summary of §4.3.

Table 3:Component ablation across the three benchmarks (held-out test accuracy, %), scored on the same partition as Table1. The Evolver (ε\varepsilon) always executes; with−π-\piit consumes the raw analysis instead of a structured proposal.−σ-\sigmaremoves the Retriever’s inspiration policy entirely;no cross-branchremoves only cross-branch retrieval candidates while same-branch candidates remain available.No meta-updatesfreezes the slow loop, exactly reproducing the Single-Level row of Table1.On ALFWorld theedit-proposal policyπ\piis again the dominant component (94.23→86.5494.23\to 86.54), echoing SealQA: the gain hinges on the precise content of each edit rather than on how widely the search fans out. Cross-branch sharing carries the remainder of the meta-gain. Removing only cross-branch retrieval (no cross-branch,92.3192.31) returns accuracy exactly to the Single-Level baseline (92.3192.31), so cross-branch transfer of reusable sub-routines (e.g. object-disambiguation and deferred-placement sub-skills) accounts for the whole+1.92+1.92improvement there. As on the QA benchmarks, freezing the slow loop (no meta-updates,92.3192.31) reproduces the Single-Level row of Table1exactly.

Appendix FEvaluation Protocol: Native Held-Out Test

The accuracy figures in Table1are computed on a held-outtestpartition that the evolution loop never observes, so they measure generalisation to unseen rows rather than recall of evolved ones.

Before the loop runs, each benchmark file is stratified by its category column into three disjoint partitions: train (failure mining), val (child scoring and frontier selection), and test (the per-category remainder).

Appendix GTrain/Validation Split Ratio Sensitivity

We study how the loop’s train/validation split affects the quality of the evolved task skill. All numbers in this section are recomputed on acommonheld-out test set per benchmark: because the stratified split is seeded, a larger-holdout run’s test set is a subset of a smaller one’s, so we intersect the test items across the swept runs and re-score every configuration on that shared subset (no re-running). These subsets are smaller than the benchmark sets used in the main results, so absolute numbers differ slightly.

Training-ratio sweep.

Table4sweeps the training fraction with validation fixed at0.100.10(dual-evolve,55outer iterations). More training data yields only modest gains: ALFWorld rises monotonically (87.7→88.7→90.687.7\to 88.7\to 90.6), while SealQA and OfficeQA are essentially flat within noise (±1∼4\pm 1\sim 4items onn≈87∼107n\approx 87\sim 107).

Table 4:Training-ratio sweep (val=0.10=0.10), accuracy (%) on the common held-out test subset.

Validation-ratio sweep on ALFWorld.

Table5enlarges the validation split (0.10→0.250.10{\to}0.25) at each training ratio. A larger validation set consistentlyimprovesthe evolved skill, by+2.0+2.0,+4.3+4.3, and+2.5+2.5points attr=0.05/0.10/0.15\text{tr}{=}0.05/0.10/0.15respectively. This effect is specific to high-baseline benchmarks such as ALFWorld, where the base agent already solves most episodes out of the box: a small validation set then contains too fewfailuresto drive evolution. The analyzer sees almost no failing trajectories, so the diagnosis→\toproposal→\toselection cycle has essentially no signal to act on and the slow loop degenerates toward a no-op. Enlarging the validation split surfaces enough failure cases to make skill proposal and frontier selection informative, which in turn yields a measurably better skill on the held-out test set. The practical implication is that on saturated benchmarks the validation split must be large enough to expose failures; otherwise the evolution loop has nothing to learn from and cannot improve.

Table 5:ALFWorld validation-ratio sweep, accuracy (%) on the common held-out test subset. Enlarging the validation split exposes more failure cases and produces a better evolved skill.