acceptodds
Under review as a conference paper at ICLR 2027

SKILL²: Continually improving how agents learn skills from experience

Abstract

Skills enable language model agents to turn execution experience into procedural knowledge that can support future tasks. However, existing skill generation methods largely focus on producing and refining individual skill artifacts, while the procedure used to generate these skills is typically kept fixed. As a result, improvements in generated skills do not systematically accumulate into a better process for generating future skills. We introduce SKILL² (Skill-Squared), which instead treats the skill generation procedure itself as an optimization target. SKILL² continually improves this procedure, termed the MetaSkill, and uses the evolved MetaSkill to induce new skills from trajectories. This allows improvements to accumulate in the skill generation procedure rather than only in individual skill artifacts. Across four benchmarks and two executor scales, SKILL² outperforms the strongest skill generation baseline by an absolute 5.00% on average. Controlled experiments further show that evolved MetaSkills produce better skills when given the same trajectories and retain their advantage when applied to previously unseen trajectories, while reducing the computational cost of adaptation. These results demonstrate the value of improving the procedure that generates skills, rather than optimizing each skill in isolation.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM Agents, Agent Skills

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_fV5MOpenReview ↗
Rating
3(+1)
Confidence
2(−1)
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes SKILL2, a method that improves LLM agent skill generation by continuously optimizing a meta-skill. Instead of directly optimizing the generated Skills, the method focuses on improving the skill generation procedure itself. It updates the MetaSkill based on execution feedback, and uses historical rules to detect conflicts and validate new updates.

they evaluate the method on four benchmarks with two different executor model sizes. The results show some improvements over existing skill generation baselines.

Critical strengths
  • Fairly comprehensive experimental evaluation.

they have a relatively full experiments, and compare it with several existing skill generation methods. The improvements are relatively consistent across different settings, which suggests that the method has some practical value.

  • Useful analysis of the meta-skill update process.

Besides comparing the final performance, they also study how performance changes under a fixed trajectory setting, whether the learned meta-skill can transfer to unseen trajectories, and the effect of interference resolution.

Critical weaknesses
  1. Limited novelty The main idea of optimizing meta-level instructions based on execution feedback seems like to be explored in works such as PromptBreeder, MetaSkill-Evolve. While skill2 focuses on skill generation, its algorithmic difference from these methods is not very clear. In particular, the actions like SELECT, REPRESENT, SCOPE, and COMPOSE seem more like structured prompt engineering rather than a new learning mechanism.

  2. Missing important ablation comparisons. Although the paper compares with TextGrad and GEPA, these baselines mainly optimize the generated Skills rather than the same MetaSkill representation. Without a comparison under the same MetaSkill representation, feedback data, and computational budget, it is hard to tell where the improvements actually come from.

Questions for authors
  1. Compared with MetaSkill-Evolve and other meta-level optimization methods, what is the main algorithmic novelty of skill2, beyond changing the optimization target to skill generation? I understand for the current stage, research ideas related to skills are like making the engineering greater.

  2. Could you compare against GEPA or TextGrad directly optimizing the same MetaSkill, under the same feedback data and computational budget?

  3. Could you provide longer-term experiments with continuously arriving tasks and trajectories to better support the claims about continual learning and generalization? [like a dynamic optimization process]

7 comments
AuthorsOpenReview ↗

Response to Reviewer fV5M (1/4)

We thank you for your thorough review and valuable comments on the algorithmic contribution, baseline comparisons, and continual adaptation. We provide our point-by-point responses below. If you have any remaining concerns or questions, please let us know; we would be happy to discuss them further.

(W1, Q1) Algorithmic contribution and the role of the four components

We thank the reviewer for asking us to clarify the algorithmic contribution beyond changing the optimization target. This question helped us better explain both the motivation behind SKILL² and the role of its four components.

SKILL² learns how to generate new skills by updating a persistent MetaSkill from execution feedback. Its contribution lies in the complete procedure for attributing, resolving, and validating updates to generation decisions, rather than in the component names alone.

Below, we explain what motivates SKILL², how it differs from existing meta-level methods, and what evidence supports its contribution.

1. What motivates SKILL²?

  • Execution feedback must be interpreted before it can guide a change to the generation procedure. Feedback is observed when a generated skill is executed, but it does not directly identify which generation decision should change. Existing work illustrates this difficulty:

    • In one Trace2Skill case, a log-only analyzer proposed three failure causes even though the generated output was correct [1].
    • In a study of GEPA, the optimizer repeatedly suggested changes to reasoning but did not identify the incorrect output-field order in the initial prompt [2].
    • Even when an edit addresses an observed failure, it can affect other tasks: in Trace2Skill's greedy patch analysis, one update changed 26 tasks from failure to success, while changing 46 tasks from success to failure [1].

    These observations motivate two requirements for improving generation guidance: identify the generation decision associated with the feedback, and check the effect of a proposed change on existing behavior.

  • The performance of an evolved artifact can reflect both meta-level guidance and accumulated inner-loop history. PromptBreeder evolves task prompts and mutation prompts [5]. MetaSkill-Evolve uses a meta-skill to guide successive edits to an existing task skill [3]. MCE co-evolves context-engineering skills and context artifacts using their execution and evaluation history [4].

    For an inner loop that directly uses a previous skill and its execution experience, a representative update can be written as Sti+1=G(Sti,Rti,Fti;Mt)S_t^{i+1}=G(S_t^i,R_t^i,F_t^i;M_t), where MtM_t is the meta-level guidance, StiS_t^i is the current skill, and RtiR_t^i and FtiF_t^i are its execution trajectory and feedback.

    In this setting, the next skill can reflect both the MetaSkill and the previous skill and execution history. Consequently, an improvement in the resulting skill does not by itself identify how much comes from better meta-level guidance.

  • Generated skills can contain instructions tied to previously observed failures. We define an ad-hoc patch as an instruction in a generated skill that addresses an execution error observed in an earlier trajectory. Although such patches can address observed failures, patches tied too closely to specific cases may not improve performance on unseen tasks. In our experiments, skills generated by PromptBreeder and MetaSkill-Evolve contain such patches more frequently than those generated by SKILL² (Table R1), while SKILL² achieves higher held-out performance on ALFWorld with Qwen3-8B (Table R4).

  • Final skill performance alone does not isolate the contribution of meta-level guidance.

    • With meta-level guidance fixed, continued inner-loop optimization reaches performance close to the full methods; evolved meta-level guidance yields only small gains from the same starting artifact (Table R2).
AuthorsOpenReview ↗

Response to Reviewer fV5M (2/4)

2. How does SKILL² differ from existing meta-level methods?

Our intuition is that better generation guidance should produce a better new skill from the same trajectory evidence. SKILL² therefore removes the direct inheritance of previous skills while retaining execution experience through MetaSkill updates.

  • Fixed-evidence regeneration removes direct dependence on the previous skill.

    • At round tt, SKILL² generates a skill as St=G(R;Mt)S_t=G(\mathcal{R};M_t), where R\mathcal{R} is the fixed trajectory pool and MtM_t is the current MetaSkill.
    • The generator is not directly given the previous skill or its newly collected execution trajectories. Each skill is generated afresh from the same trajectory evidence, rather than obtained by continually editing the previous skill.
    • Thus, given the current MetaSkill and fixed trajectory pool, skill generation does not directly depend on the previous skill-editing path.
  • Execution feedback improves the MetaSkill, allowing the system to learn across fresh generations.

    • After executing the current skill, the updater analyzes the skill and its execution feedback to identify a generation decision that may need to change.
    • The MetaSkill represents these decisions through four editable components: SELECT chooses trajectory evidence, REPRESENT turns it into reusable rules, SCOPE specifies when the rules apply, and COMPOSE coordinates them.
    • Once accepted, an edit remains in the MetaSkill and guides subsequent skill generation. Thus, execution experience can improve future skills through the MetaSkill without directly carrying the previous skill forward.

The contribution is not the textual structure itself, but the procedure that uses execution feedback to update a specific generation decision and tests the update through a newly generated skill.

  • We agree that structured textual workflows are not new: ReAct organizes reasoning and actions [6], while Self-Refine organizes feedback and refinement [7]. We do not claim novelty from the four component names themselves.
  • In SKILL², the components provide localized targets for feedback-driven updates. Each proposal specifies a generation decision to change, the intended effect on the generated skill, and the behavior to preserve.
  • The resolver checks the proposal against previously validated principles and their applicability conditions. A candidate MetaSkill then generates a fresh skill from the same trajectory pool.
  • The update is accepted only if the intended change is verified, validation utility improves, and regressions remain within the allowed limit: gtchange=1g_t^{\mathrm{change}}=1, ΔJt>δ\Delta J_t>\delta, and ntreg≤ρn_t^{\mathrm{reg}}\leq\rho.

For example, in a recorded ALFWorld cooling task, the updater proposed a COMPOSE edit that introduced execution-stage routing to coordinate existing rules. The regenerated skill implemented this change and improved paired validation from 6/15 to 8/15, with two additional successes and no regressions (Table R3).

In this way, SKILL² learns from execution experience through the MetaSkill while evaluating each update through a freshly generated skill.

3. How does SKILL² perform against other methods?

  • SKILL² outperformed GEPA and TextGrad when all three optimized the same MetaSkill. We adapted GEPA and TextGrad to the same four-component MetaSkill. The three methods shared the initialization, trajectory evidence, feedback access, verifier, acceptance rule, evaluation pipeline, and computational budget. Across the six settings in Table R4, SKILL² exceeded the stronger MetaSkill baseline by 3.15–22.27%.

    Table R4 also reports our PromptBreeder adaptation and MetaSkill-Evolve reimplementation. For example, on ALFWorld with Qwen3-8B, SKILL² achieved 75.55%, compared with 46.72% for PromptBreeder and 49.27% for MetaSkill-Evolve.

  • The evolved MetaSkill generated stronger skills from unseen trajectory evidence. In a separate ALFWorld transfer experiment, both the initial and evolved MetaSkills generated skills from the same unseen target trajectories. The evolved MetaSkill increased test success from 42.70% to 65.82%.

    In the main Qwen3-8B settings, the static initial MetaSkill M0M_0 scored below No-Skill on all four benchmarks, whereas SKILL² exceeded No-Skill by 11.92–33.82% (Table R5). Together, these results show that the evolved MetaSkill retains useful guidance for generating new skills.

We thank the reviewer again for the valuable feedback, which helped us clarify the distinction between the MetaSkill representation and the procedure used to improve it.

AuthorsOpenReview ↗

Response to Reviewer fV5M (3/4)

(W2, Q2) GEPA and TextGrad on the same MetaSkill

We thank the reviewer for suggesting a direct comparison with GEPA and TextGrad under the same MetaSkill representation, feedback, and computational budget.

Under the matched MetaSkill setting, SKILL² outperformed GEPA and TextGrad in all six evaluated settings (Table R4).

  • SKILL² outperformed both optimizers under the shared MetaSkill protocol. The three methods used the same initialization, four-component representation, trajectory pool, access to execution feedback, verifier, acceptance rule, computational budget, and downstream evaluation protocol. Each candidate MetaSkill was evaluated through a freshly generated skill. Across the six settings in Table R4, SKILL² led the stronger MetaSkill baseline by 3.15–22.27%.

  • Moving the optimization target to the MetaSkill improved both optimizers in all six settings. Relative to their original skill-level results in Table 1, TextGrad gained 0.36–10.21% and GEPA gained 2.07–10.50%.

  • SKILL² also exceeded both reimplemented meta-level baselines across the six settings. On ALFWorld with Qwen3-8B, SKILL² scored 75.55%, compared with 46.72% for the PromptBreeder adaptation and 49.27% for MetaSkill-Evolve, using the same three seeds and 274 held-out games.

(Q3) Can the MetaSkill adapt as new tasks and trajectories arrive?

We appreciate the reviewer’s suggestion to evaluate continual adaptation as new tasks and trajectories arrive over a longer sequence. This helps us examine continual adaptation beyond the fixed-trajectory setting in the original experiments.

Continuing to update the MetaSkill outperformed freezing or restarting it at both benchmark shifts in our long-horizon transfer task.

  • Our three-benchmark task tests adaptation as new tasks and trajectories arrive. We designed the sequence WTQ →\rightarrow WikiSQL →\rightarrow TabFact to evaluate the MetaSkill across two successive shifts. Continual carries forward the MetaSkill and its validated history and continues updating at each stage. Frozen keeps the WTQ-trained MetaSkill fixed, and Restart starts each new stage from M0M_0. We evaluate each incoming benchmark and revisit earlier benchmarks using fixed probes.

  • Continual achieved the highest score on both incoming benchmarks. It reached 81.11% on WikiSQL and 81.12% on TabFact, outperforming Frozen by 4.64% and 3.42%, and Restart by 3.34% and 0.84%, respectively (Table R6).

  • Continual largely retained performance on earlier benchmarks across the two shifts. By the final stage, its scores on WTQ and WikiSQL were 0.62% and 0.53% below their respective post-learning scores (Table R6).

References

[1] Trace2Skill: Distill Trajectory-Local Lessons into Transferable Agent Skills. EMNLP 2026.

[2] Reflection in the Dark: Exposing and Escaping the Black Box in Reflective Prompt Optimization. ACL 2026 Student Research Workshop.

[3] MetaSkill-Evolve: Recursive Self-Improvement of LLM Agents via Two-Timescale Meta-Skill Evolution. arXiv preprint, 2026.

[4] Meta Context Engineering via Agentic Skill Evolution. ICML 2026.

[5] Promptbreeder: Self-Referential Self-Improvement via Prompt Evolution. ICML 2024.

[6] ReAct: Synergizing Reasoning and Acting in Language Models. ICLR 2023.

[7] Self-Refine: Iterative Refinement with Self-Feedback. NeurIPS 2023.

Experimental Tables

Table R1. Percentage of generated skills containing patches for previously observed execution errors, across four benchmarks and three seeds.

MethodSkills containing ad-hoc patches
PromptBreeder72.2%
MetaSkill-Evolve78.9%
SKILL²16.4%

Table R2. Effects of meta-level guidance and inner-loop optimization on ALFWorld with Qwen3-8B.

MethodInitial meta guidanceEvolved meta guidanceFixed meta + inner-loop optimizationFull method
PromptBreeder43.07%43.80%44.16%46.72%
MetaSkill-Evolve43.80%44.53%47.45%49.27%

Table R3. Paired validation of the recorded COMPOSE update.

Incumbent successesCandidate successesFailure →\rightarrow successSuccess →\rightarrow failure
6/158/1520
Reviewer_9pv3OpenReview ↗
Rating
4(+1)
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The authors propose learning a MetaSkill—a skill for generating skills—to improve how LLMs create new skills. By updating a shared generation procedure, the approach aims to propagate improvements to subsequently generated skills. The MetaSkill is refined through diagnostic analysis of generated skills, followed by a meta-update that translates the resulting findings into revisions to the MetaSkill.

Critical strengths

The paper proposes a structured, relatively simple, and effective approach to improving skill generation. Experiments across several environments provide compelling evidence of the method’s efficiency compared with relevant baselines.

Critical weaknesses

The method involves several stages and design choices that warrant additional ablation studies to clarify their contributions and assess the method’s sensitivity to them. In particular, the paper would benefit from a sensitivity analysis of ρ\rho and δ\delta in Equation (10), along with a clearer rationale for their chosen values.

Questions for authors

Line 375: Although the authors report continued improvement beyond the first update, performance appears to plateau quickly across all benchmarks. Can the authors explain this behavior?

Line 388: The paper evaluates transfer by freezing the learned MetaSkill and testing it on a different benchmark. Have the authors investigated what happens when the transferred MetaSkill is allowed to continue evolving? In particular, does it forget knowledge specific to the original benchmark, or does it retain that knowledge while acquiring knowledge relevant to the new benchmark?

Have the authors evaluated the method using models from other families?

6 comments
AuthorsOpenReview ↗

Response to Reviewer 9pv3 (1/3)

We appreciate your thoughtful review and helpful questions about the acceptance thresholds, update dynamics, and generalization of our method. Below, we respond to your comments point by point. Please let us know if you have any remaining concerns or questions, and we would be glad to address them.

Unless otherwise noted, references to sections, figures, equations, and tables refer to the original submission. Tables labeled R1, R2, and so on are included in this response.

(W1) Rationale and sensitivity of ρ\rho and δ\delta

We appreciate the reviewer’s suggestion to examine the sensitivity of ρ\rho and δ\delta and clarify the rationale for their default values.

The default (ρ,δ)=(1,0)(\rho, \delta) = (1, 0) allows small positive validation gains while limiting each accepted update to one validation regression.

  • The default requires new successes to outweigh any regression. Eq. (10) requires change verification, a net validation gain ΔJ>δ\Delta J > \delta, and at most ρ\rho validation regressions. An update that loses one previously solved validation task must therefore solve at least two previously unsolved validation tasks.

  • At δ=0\delta = 0, ρ=1\rho = 1 came within one task of the highest final success count while retaining more initially solved test tasks than ρ=2\rho = 2. The default solved nine more test tasks than ρ=0\rho = 0 and retained four more initially solved test tasks than ρ=2\rho = 2.

  • At ρ=1\rho = 1, stricter gain thresholds reduced accepted updates and final test success. With 90 validation tasks and ΔJ\Delta J measured as a success fraction, setting δ\delta to 00, 1/901/90, and 2/902/90 requires net gains of at least one, two, and three validation successes, respectively. Accepted updates fell from 4 to 3 to 2, while the stricter thresholds retained one or two more initially solved test tasks.

Table R1. Threshold sensitivity on ALFWorld with Qwen3-8B. We varied one threshold at a time using 90 validation tasks and 274 held-out test tasks.

ρ\rhoδ\deltaAccepted updatesFinal test successInitially solved test tasks retained
002164/274164/274 (59.85%)157/158157/158
10 (default)4173/274173/274 (63.14%)155/158155/158
205174/274174/274 (63.50%)151/158151/158
11/901/903170/274170/274 (62.04%)156/158156/158
12/902/902167/274167/274 (60.95%)157/158157/158
  • Validated history and interaction resolution reduced candidate regressions in a separate matched ablation. Under the same proposal sequence and acceptance rule, Table 3 reports 21 validation regressions for Greedy, 17 for History without resolution, and 7 for Full SKILL².
AuthorsOpenReview ↗

Response to Reviewer 9pv3 (2/3)

(Q1) Why does performance plateau after the early updates?

We thank the reviewer for this insightful observation. Examining the plateau helps us better understand both the effectiveness of early updates and the opportunities for subsequent improvement.

In the traced WTQ run, the first accepted edit produced a rapid improvement, while many later proposals left the generated skill unchanged. Relatively simple tasks may also leave less room for further gains after their main failure modes are addressed.

  • Early edits to the generation procedure produced immediate gains in the traced WTQ run. The first accepted update increased validation successes from 30/6430/64 to 35/6435/64. Six of the next eight proposals left the generated skill unchanged. The other two were blocked by the guard or reduced validation performance, so the system retained the same MetaSkill checkpoint.

Table R2. Outcomes of the eight proposals after the first accepted update in the traced WTQ run.

Proposal outcomeCount
Generated skill unchanged6
Blocked by the guard1
Reduced validation performance1
  • Relatively simple tasks may benefit from fewer changes to the generation procedure. Once early edits address the main failure modes, later proposals may have fewer opportunities to improve the generated skill.

  • Most settings still improved after the first accepted update. In Fig. 4, six of eight settings improved after M1M_1, and the first checkpoint to reach the final mean fell between M1M_1 and M5M_5 across settings.

(Q2) What happens when the transferred MetaSkill continues to evolve?

We thank the reviewer for asking whether the MetaSkill can continue adapting to a new benchmark while retaining its performance on earlier benchmarks.

In our three-benchmark transfer task, continued MetaSkill updates improved performance on both incoming benchmarks while largely retaining performance on the previously seen benchmarks.

  • Our long-horizon transfer task measures both adaptation and retention across three benchmarks. We designed the sequence WTQ →\rightarrow WikiSQL →\rightarrow TabFact, with new tasks and trajectories at each stage. Frozen keeps the WTQ-trained MetaSkill fixed. Restart begins each new stage from M0M_0. Continual carries forward the MetaSkill and its validated history and continues updating. After each stage, we evaluate the incoming benchmark and revisit earlier benchmarks using fixed probes.

  • Continual outperformed both controls on each incoming benchmark. It led Frozen by 4.64% on WikiSQL and 3.42% on TabFact, and Restart by 3.34% and 0.84%, respectively.

  • Earlier benchmark scores stayed close to their post-learning levels. By the final stage, Continual's scores had declined by 0.62% on WTQ and 0.53% on WikiSQL from their respective post-learning scores.

Table R3. Adaptation and retention in the three-stage WTQ →\rightarrow WikiSQL →\rightarrow TabFact transfer task.

Completed stageEvaluation benchmarkFrozen (%)Restart (%)Continual (%)
WTQWTQ57.6557.6557.65
WTQ →\rightarrow WikiSQLWTQ57.6556.0157.38
WTQ →\rightarrow WikiSQLWikiSQL76.4777.7781.11
WTQ →\rightarrow WikiSQL →\rightarrow TabFactWTQ57.6554.6257.03
WTQ →\rightarrow WikiSQL →\rightarrow TabFactWikiSQL76.4776.6480.58
WTQ →\rightarrow WikiSQL →\rightarrow TabFactTabFact77.7080.2881.12

(Q3) Does SKILL² work with other model families?

We appreciate the reviewer's question about whether SKILL² extends to model families beyond Qwen.

With Mistral and OLMo, SKILL² achieved the highest score among the evaluated methods in all four settings.

  • The gains were larger in three settings, and the OLMo/WTQ results were close. The margin over the strongest evaluated baseline was 3.45–6.06% in three settings and 0.08% on OLMo/WTQ. We replaced Qwen throughout the pipeline with Mistral 7B or OLMo 3 7B Instruct and evaluated both using seed 42.

Table R4. Single-seed results with two non-Qwen model families.

MethodMistral / ALFWorldMistral / WTQOLMo / ALFWorldOLMo / WTQ
No-Skill20.0714.1617.1512.42
Static MetaSkill (M0M_0)18.6113.9522.2612.28
SkillOpt21.3120.7120.8012.17
TextGrad–Skill22.4118.2120.4414.34
SKILL²28.4724.1626.3214.42
AuthorsOpenReview ↗

Response to Reviewer 9pv3 (3/3)

References

[1] Ni et al. [Trace2Skill: Distill Trajectory-Local Lessons into Transferable Agent Skills]. EMNLP 2026.

[2] Zhao et al. [Self-Evolving Agents Can Repair Failures but Struggle to Generalize from Them]. arXiv preprint, 2026.

[3] Liu et al. [Reflection in the Dark: Exposing and Escaping the Black Box in Reflective Prompt Optimization]. ACL 2026 Student Research Workshop.

[4] Wang et al. [MetaSkill-Evolve: Recursive Self-Improvement of LLM Agents via Two-Timescale Meta-Skill Evolution]. arXiv preprint, 2026.

[5] Ye et al. [Meta Context Engineering via Agentic Skill Evolution]. ICML 2026.

[6] Fernando et al. [Promptbreeder: Self-Referential Self-Improvement via Prompt Evolution]. ICML 2024.

Reviewer_EbB7OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes SKILL², a framework that optimizes the procedure used to generate agent skills from execution trajectories. This procedure is represented as a persistent textual MetaSkill with four components: SELECT, REPRESENT, SCOPE, and COMPOSE. Execution feedback motivates localized MetaSkill edits, which are checked against previously validated principles. Candidate MetaSkills generate fresh skills from a fixed trajectory pool and are accepted only after change verification and validation-based utility and regression checks. Experiments cover four benchmarks and two Qwen3 executor scales. The paper reports an average improvement of 5.00 percentage points over the strongest baseline in each setting, supplemented by fresh-generation, transfer, interference, and adaptation-cost analyses.

Critical strengths
  1. Consistent improvements across several evaluation settings. SKILL² achieves the highest reported mean in all eight benchmark–executor combinations, with an average margin of 5.00 percentage points over the strongest competing baseline. Appendix C.6 provides seed-level standard deviations. This breadth makes the empirical result more persuasive than an improvement confined to one benchmark or model configuration.

  2. Useful controls separating persistent generation guidance from a particular skill artifact. Regenerating skills from fixed trajectories without supplying the incumbent skill is a meaningful experimental design. The additional ALFWorld experiment using disjoint source and target trajectory pools strengthens the evidence that the evolved MetaSkill retains reusable information. These controls support a substantive contribution beyond merely reporting a better final skill.

Critical weaknesses
  1. The experiments do not adequately isolate the central contribution from existing meta-level optimization or accumulated task strategies. PromptBreeder, MCE, and MetaSkill-Evolve already optimize aspects of the procedures that generate or improve downstream artifacts; the submission acknowledges these related approaches but does not compare against them experimentally. Meanwhile, TextGrad and GEPA optimize the downstream skill text, rather than the MetaSkill under the same representation and evaluation pipeline. Consequently, their results do not establish that the proposed update and resolution mechanism improves upon a generic optimizer applied to the same upstream object.

  2. Fresh regeneration establishes that useful information resides in the MetaSkill, but does not establish whether that information constitutes a better evidence-processing procedure or primarily encodes reusable task strategies. The examples involving search thresholds and execution-stage routing make this distinction consequential. Transfer to new trajectories is evaluated in one ALFWorld setting, while cross-benchmark transfer uses a single WTQ-derived principle. Moreover, the deliberately conservative initialization underperforms No-Skill in all four 8B settings, limiting what large gains over this initialization establish. The missing matched meta-level control leaves the necessity and incremental value of the proposed design unresolved.

  3. The interference experiments demonstrate reduced candidate-search damage more directly than improved retention, and the resolver’s actual contribution is insufficiently specified. Appendix C.3 explicitly states that Table 3 counts regressions across all evaluated candidates, including rejected candidates, and divides this total by five accepted updates. Therefore, “Reg./update” is not the forgetting caused by an average committed update. Candidates stopped before validation contribute no measured regressions, so differences in filtering also affect the totals. Equal numbers of accepted updates do not remove this confound.

  4. The paired analysis of 19 interfering proposals is useful evidence that resolution can reduce harmful candidate changes, but it does not establish retention along the committed learning trajectory. The matched ablation improves final test success by only three or four games out of 274, without corresponding uncertainty estimates. Furthermore, Appendix F.2 describes a canonical guard overriding the LLM’s compatibility judgment and blocking a previously edited coordinate. The rule governing this override is not fully specified or separately ablated. Thus, the reported benefit cannot be confidently attributed to the proposed interaction reasoning rather than conservative parameter-locking and candidate filtering.

Questions for authors
  1. Additional evidence needed to assess the contribution: How does SKILL² compare with GEPA or TextGrad optimizing the MetaSkill itself, using the same four-component representation, trajectory evidence, feedback access, verifier, acceptance rule, and compute budget? A comparison at this level would directly test whether the proposed optimization mechanism contributes beyond the choice of optimization target.

  2. Clarification and a focused transfer control: What is the exact WTQ-derived principle transferred in Table 2, and how was it selected before inspecting target results? Can you distinguish its benefit as generation guidance from the benefit of directly supplying an equivalent query-planning instruction to the executor? This distinction would materially affect my interpretation of the claimed transfer of skill-generation ability.

  3. Reanalysis of the stability evidence: Can you separate regressions from accepted and rejected candidates, report the number of candidates actually evaluated in each arm, and show held-out performance on previously solved instances along the accepted-update sequence? Please also provide uncertainty estimates for the final differences in Table 3. These results would clarify whether the resolver preserves deployed capabilities or mainly reduces unsuccessful search.

  4. Implementation clarification and mechanism control: What exact rule produces the canonical guarded decision in Appendix F.2, when can it override the LLM, and how frequently does this occur? How does the full resolver compare with the same canonical guards operating without LLM interaction assessment? This is necessary to identify which mechanism produces the reported stability benefit.

These requests concern evidence needed to assess the current claims, rather than suggestions for extending the work to unrelated settings.

6 comments
AuthorsOpenReview ↗

Response to Reviewer EbB7 (1/5)

We sincerely thank you for your careful review and constructive feedback on the contribution, transfer, and stability of our work. We address your comments point by point below. If you have any remaining concerns or questions, please let us know; we would be happy to provide further clarification.

(W1, Q1) Contribution beyond existing meta-level optimization

We thank the reviewer for highlighting the need to clarify our contribution beyond existing meta-level optimization methods. This suggestion helped us assess the roles of both the optimization target and the update procedure more directly.

We gratefully thank you for your valuable suggestion to compare SKILL² against other meta-level optimization methods. We conduct additional experiments comparing SKILL² against PromptBreeder, MetaSkill-Evolve, and GEPA/TextGrad at meta-level, and decompose this comparison into three questions as follows:

  1. What motivates SKILL²?
    • Follow the notations in our submitted manuscript, with MtM_t being the MetaSkill, StiS_t^i being the iith skill generated in ttth outer loop iteration, RtiR_t^i being the corresponding trajectory produced by StiS_t^i with feedback FtiF_t^i, GG being the skill generator in the inner loop, and MtM_t being updated via analyzing {Sti,Rti,Fti}\{S_t^i, R_t^i,F_t^i\}.
    • What do we observe in prior literature?
      • Current meta-level optimization methods perform meta-level optimization (the outer loop in Figure 2) based on path-dependent inner loop.
        • In MetaSkill-Evolve, a meta-skill guides successive edits to an existing task skill and is further updated using the improvement history.
        • In MCE, context-engineering skills co-evolve with context artifacts, where each context artifact refinement builds upon previous artifacts and execution feedback.
      • Such inner loop process can be written as Sti+1=G(Sti,Rti,Fti;Mt)S_t^{i+1}=G(S_t^i, R_t^i, F_t^i;M_t), hence Sti+1S_t^{i+1} (and Fti+1F_t^{i+1}) is dependent on both MtM_t and RtiR_t^i. We refer to this as path-dependent inner loop.
    • What is the consequence?
      • Path-dependent inner loop exposes a shortcut where Sti+1S_t^{i+1} directly contains specific ad-hoc patches for RtiR_t^i instead of genuine reusable task strategies. In our experiment:
        • We define an ad-hoc patch as an instruction in a generated skill that addresses an execution error observed in an earlier trajectory. Although such patches can address observed failures, patches tied too closely to specific cases may not improve performance on unseen tasks. In our experiments, skills generated by PromptBreeder and MetaSkill-Evolve contain such patches more frequently than those generated by SKILL² (Table R1), while SKILL² achieves higher held-out performance on ALFWorld with Qwen3-8B (Table R3).
      • Shortcutting with such ad-hoc patches introduces ambiguity in meta-level credit assignment where high performance may come from richer context history in the inner loop instead of better MetaSkill.
        • Inner-loop optimization approaches the full methods' performance without meta-level updates, making it difficult to attribute the final performance to improved meta-level guidance (Table R2).
AuthorsOpenReview ↗

Response to Reviewer EbB7 (2/5)

  1. What differentiate SKILL² from others? Building on this observation, our intuition is that a path-independent generation process can improve skill generation by refining the guidance itself: given the same trajectory evidence, better guidance should produce a better new skill. Accordingly, SKILL² generates each new skill without directly inheriting previous skills, while retaining execution experience through MetaSkill updates.

    • The inner loop generates each skill from a fixed trajectory pool, without directly inheriting the previous skill or its new execution trajectories.

      • In the path-dependent form discussed above, the next skill can depend directly on the previous skill and its execution experience: Sti+1=G(Sti,Rti,Fti;Mt)S_t^{i+1}=G(S_t^i,R_t^i,F_t^i;M_t).
      • In SKILL², each skill is generated as St+1=G(R;Mt+1)S_{t+1}=G(\mathcal{R};M_{t+1}), using the same fixed trajectory pool R\mathcal{R}. The previous skill and its newly collected execution trajectories are not directly supplied to the generator.
      • Thus, given the current MetaSkill and fixed trajectory pool, the generator does not need to follow the previous skill-editing path.
    • The system continues to learn because execution experience updates the MetaSkill.

      • After executing the current skill, the updater analyzes the skill and its execution feedback to identify a generation decision that may need to change.
      • The MetaSkill represents these decisions through SELECT, REPRESENT, SCOPE, and COMPOSE. This representation gives the updater a specific part of the generation procedure to revise.
      • Once accepted, the edit remains in the MetaSkill and guides the next fresh skill generation. Past execution experience can therefore influence future skills through the MetaSkill, without directly inheriting the previous skill.
    • Each MetaSkill update is checked through the skill it generates.

      • The resolver checks the proposed edit against previously validated principles and their applicability conditions, reducing potential interference with useful guidance.
      • The candidate MetaSkill then generates a fresh skill from the same trajectory pool. A verifier checks whether the intended change is realized and the specified behavior is preserved.
      • The update is accepted only if the change is verified, validation utility improves, and regressions remain within the allowed limit: gtchange=1g_t^{\mathrm{change}}=1, ΔJt>δ\Delta J_t>\delta, and ntreg≤ρn_t^{\mathrm{reg}}\leq\rho.

      In this way, SKILL² learns from execution history through the MetaSkill while evaluating each update through a freshly generated skill. The following results assess whether this procedure produces stronger skills in practice.

  2. How does SKILL² perform against those?

    • SKILL² outperforms GEPA and TextGrad when they optimize the same MetaSkill. The three methods share the initialization, four-component representation, trajectory evidence, feedback access, verifier, acceptance rule, evaluation pipeline, and computational budget. Across six settings, SKILL² exceeds the stronger MetaSkill baseline by 3.15–22.27% (Table R3). The table also reports our PromptBreeder adaptation and MetaSkill-Evolve reimplementation.
    • The evolved MetaSkill generates stronger skills from unseen trajectory evidence. On the same unseen ALFWorld target trajectories, the evolved MetaSkill increases test success from 42.70% with M0M_0 to 65.82%. Moreover, SKILL² outperforms No-Skill in all four Qwen3-8B settings, while static M0M_0 scores below No-Skill (Table R4).

Table R1. Percentage of generated skills containing patches for previously observed execution errors, across four benchmarks.

MethodSkills containing patches
PromptBreeder72.2%
MetaSkill-Evolve78.9%
SKILL²16.4%

Table R2. Effects of meta-level guidance and inner-loop optimization on ALFWorld with Qwen3-8B.

MethodInitial meta guidanceEvolved meta guidanceFixed meta + inner-loop optimizationFull method
PromptBreeder43.07%43.80%44.16%46.72%
MetaSkill-Evolve43.80%44.53%47.45%49.27%

Table R3. Comparison of skill-level, MetaSkill-level, and related methods.

MethodSpreadsheetBench 8BSpreadsheetBench 30BWTQ 8BWTQ 30BALFWorld 8BALFWorld 30B
PromptBreeder12.2519.5053.7460.4946.7246.35
MetaSkill-Evolve14.5020.2555.1260.8549.2753.65
TextGrad–Skill11.0022.5061.7160.1452.9240.15
TextGrad–MetaSkill15.6724.5063.0865.5853.2850.36
GEPA–Skill10.2516.2552.6361.3250.0045.99
GEPA–MetaSkill14.0822.1763.1365.9452.0750.49
SKILL²27.7534.2566.2869.3075.5571.17
AuthorsOpenReview ↗

Response to Reviewer EbB7 (3/5)

Table R4. Comparison of No-Skill, static MetaSkill, and evolved SKILL² with Qwen3-8B.

BenchmarkNo-SkillStatic M0M_0SKILL²SKILL² − No-Skill
SpreadsheetBench15.839.7527.75+11.92
WTQ53.9151.8966.28+12.37
ALFWorld41.7341.3675.55+33.82
ScienceWorld13.8512.8926.56+12.71

Comments on the paper

1 comment
AuthorsOpenReview ↗

Revision Note

Dear Reviewers and Area Chairs,

We sincerely thank you for your valuable time, careful attention, and dedicated effort throughout the review process, which has helped us substantially strengthen the manuscript. We have incorporated the additional analyses, experiments, and clarifications into Appendices G–M (pp. 25–32) of the updated PDF. These additions are indexed below in order of appearance for your convenience:

LocationAdditional Experiment / ClarificationAddresses
App. GMeta-level credit assignment and learning mechanism: clarified path dependence, experience retention through the MetaSkill, and the attribution, resolution, and verification of generation updates.EbB7 W1; fV5M W1/Q1
App. H.1–H.2, Tables 12–13Ad-hoc patch analysis and controls with fixed meta-level guidance to examine the contribution of accumulated inner-loop refinement.EbB7 W1; fV5M W1/Q1
App. H.3, Table 14Matched MetaSkill optimization: compared GEPA and TextGrad on the same MetaSkill, and added a PromptBreeder adaptation and a MetaSkill-Evolve reimplementation.EbB7 W1/Q1; fV5M W2/Q2
App. I, Table 15Generation versus execution guidance: compared two uses of the same WTQ-derived principle across nine target benchmarks.EbB7 W2/Q2
App. J.1, Table 16Retention after accepted updates: clarified Reg./update, separated candidate regressions by acceptance outcome, and added pooled held-out retention statistics across five accepted updates.EbB7 W3/Q3
App. J.2, Table 17Canonical guard and LLM-based resolution: clarified the guard rule and override frequency, and added three paired cases under the same guard.EbB7 W4/Q4
App. K.1, Table 18Sensitivity analysis and rationale for the acceptance thresholds ρ\rho and δ\delta.9pv3 W1
App. K.2, Table 19Early-plateau analysis: traced eight proposals following the first accepted WTQ update.9pv3 Q1
App. L, Table 20Continual adaptation and retention: added WTQ → WikiSQL → TabFact experiments comparing Frozen, Restart, and Continual.9pv3 Q2; fV5M Q3
App. M, Table 21Evaluation beyond Qwen: added Mistral and OLMo experiments on ALFWorld and WTQ.9pv3 Q3

Thank you again for your time and constructive feedback.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.