- Rating
- 3(+1)
- Confidence
- 2
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This work proposes a meta-learning approach to learn natural-language skills tailored for a given model (the Reader) and task. The proposed framework is based on two stages and a meta-learning optimization procedure. In the first stage, a skill generating model (the Writer) is trained to generate skills for a particular Reader-task pair with a few steps of GRPO based on accuracy and observed errors from the Reader. In the second stage, the weight-updated Writer iteratively refines a skill based on accuracy and observed errors from the Reader. The meta-learning procedure optimizes the initial Writer parameter based on a reward that tracks how well the iterative refinement process of the two stages performs. Experiments on five benchmarks demonstrate that this method rivals text-space optimizer methods like GEPA and TextGrad, and ablations validate the utility of both stages as well as the meta-learning procedure.
I think the proposed method is interesting and the experimental results are positive. My main concerns are about whether the comparison with baselines is fair, and with the presentation of the paper. These concerns make me lean towards rejecting the manuscript in its current form, but I am prepared to increase my score if the authors can address them.
Critical strengths
- The approach of learning how to write skills for a specific target model and task is interesting and the proposed method is generally sound.
- The ablation experiments show that each component contributes to the performance of the framework, even the small weight-update to the Writer model during T_grad phase.
Critical weaknesses
Major:
- Comparison with the baselines is not rigorous. All three baselines and the proposed method use iterative refinement of the skills, but no information is provided for how the baseline models were run, and how they compare with the iteration budget used by MetaSkill. Appendix B.6 just says that they use the same backbone/Reader/support and query set, but does not give any further detail on how methods' search budgets are comparable to MetaSkill's. Figure 2d compares the number of tokens per episode, but it is unclear where these differences come from (eg more iterations, more tokens per iterations, a different prompting setup, etc). Figure 2c is not discussed anywhere in the manuscript and does not seem to take into account the meta-learning phase which is only needed for MetaSkill. I would strongly recommend presenting the results compared to the baselines across a common axis like the number of iterations on the skill, and carefully discussing how the evaluation setup of the baselines makes it a fair comparison.
- If my understanding is correct, the meta-training is done over the same tasks used in evaluation. This means that the Writer is only evaluated in-distribution. Again, this might lead to an unfair comparison with the baselines which only perform inference-time search. A stronger evaluation should withhold some environments from the meta-training phase to evaluate performance out-of-distribution.
- The presentation could be significantly improved. The experimental setup mentions various terms like "units", "episodes", "queries" without defining them. Some figures are difficult to parse (e.g. Fig1 and Fig2b; Fig2c is not discussed anywhere). It is unclear how the meta-training is applied in the experiments (on a task-by-task basis or once across all the tasks). The experimental details are missing some important information like the batch size.
Minor:
-
"suggest that weights and words play complementary roles in acquiring procedural knowledge, with weights carrying the capacity to adapt and words carrying what persists." in the conclusion (l.) is misleading. The weight updates operate on the Writer and the procedural knowledge is still only provided to the target model in natural language.
-
The main Table 1 should report the standard deviation from the 5 repeats for all results rather than just the average.
-
MetaSkill-4B use a Qwen3 backbone while 7B/14B use a Qwen2.5 backbone. This makes the parameter count comparison misleading and should be clarified in the main text.
Questions for authors
- Given how RLVR is generally ran (hundreds of epochs, large batch size), I find it surprising that only a handful of steps of GRPO can significantly improve performance as shown by the ablation in Table 1B. Can the authors provide more details on how the performance varies with different amount of adaptation of the Writer's weights?
- As per my W1 comment, can the authors compare the performance across the number of iterations for both T_grad and T_text steps, alongside comparable iterations from the baseline methods?
- Figure 2b is confusing. What is the "single-stage" baseline? Why does it vary depending on "+gradient" or "+text"?
6 comments
Response to Reviewer ncxj(Part 2)
Table N3. Token breakdown for the same four episodes (thousands).
| Method | Writer input | Writer output | Reader input | Reader output | Profile total | With exact-request reuse |
|---|---|---|---|---|---|---|
| GEPA | 2.91 | 2.22 | 45.33 | 0.52 | 50.98 | 11.83 |
| TextGrad | 16.38 | 5.57 | 14.48 | 0.24 | 36.68 | 36.11 |
| SkillOpt | 7.86 | 1.64 | 23.65 | 0.22 | 33.37 | 22.23 |
Support evaluations accounted for about 90% of GEPA’s tokens and 72% of SkillOpt’s. TextGrad spent about 60% on the Writer, with roughly 1,024 input tokens per Writer call versus 612 for GEPA. In the initial profile we disabled GEPA’s native evaluation cache and retained SkillOpt’s native selection cache. For the last column we applied the same additional rule across methods, reusing the first response to each identical complete request. This made the largest difference for GEPA. Fig. 2d reports the full original evaluation.
What Fig. 2c includes.
It estimates the time to construct one skill at equal token throughput and includes the backward passes and optimizer updates for that skill. Relative to MetaSkill (1.0×), the estimates are 2.5× for GEPA, 6.3× for SkillOpt, and 7.1× for TextGrad. We measured offline training and development separately for one complete checkpoint on eight H100s (Appendix E.4).
Table N4. Offline training and development cost.
| Suites | Training (h) | Development evaluation (h) | H100 GPU-hours |
|---|---|---|---|
| SuperNI, BBH, SCAN, CLUTRR | 58.77 | 5.28 | 512.36 |
| ALFWorld | 31.41 | 8.55 | 319.70 |
| Total | 90.18 | 13.83 | 832.06 |
One checkpoint can serve many task–Reader pairs, and each constructed skill can serve many queries. Whether the deployment savings recover the training cost depends on the number of skills constructed and the GPU-hours saved per skill.
W2 ... A stronger evaluation should withhold some environments from the meta-training phase to evaluate performance out-of-distribution.
We totally agree with this point. We held out tasks or construction units within each of the five main suites and added further evaluation on MBPP as an entirely held-out benchmark.
Our original submission also tested transfer to unseen Reader families (Table 3A): we meta-trained a Writer using only Qwen-family Readers, and adaptation improved the five-suite mean by 9.6 points on Gemma and 9.9 points on Ministral. On OOD tabsk MBPP, we ran the same two-stage adaptation procedure with the original and meta-trained Writers and tested the Reader’s generated code with unit tests. Changing the Writer initialization raised pass@1 from 68.87% to 72.76% (+3.89 percentage points, Appendix E.5).
Table N8. Transfer to held-out MBPP.
| MBPP configuration | pass@1 |
|---|---|
| GEPA | 71.98% |
| TextGrad | 71.21% |
| SkillOpt | 70.82% |
| Meta-trained Writer, refinement only (error-driven diagnostics) | 71.21% |
| Meta-trained Writer, initial skill | 71.21% |
| Meta-trained Writer, full two-stage protocol | 72.76% |
| Original Writer, full two-stage protocol | 68.87% |
W3 The presentation could be significantly improved ...
Thank you for raising this point. We have revised our paper according to your suggestions. Section 5.1 now defines the evaluation terms with an example. In SuperNI, a unit is a task ID. Each held-out task gives three episodes, each with its own support and query sets. A query is one scored example, or one environment run in ALFWorld. We meta-train one shared Writer across all five suites and training Readers. The original submission reported eight candidate skills per GRPO round (Table A1) and the sampling rule for each outer batch (Appendix B.3). Section 5.1 now states the batch size directly: each outer update combines up to 276 episode visits per Reader. We revised Fig. 1’s caption to distinguish joint meta-training from adaptation to a new task–Reader pair. Fig. 2b’s caption now names the starting point for each comparison: “+gradient” starts from text refinement alone, and “+text” starts from parameter adaptation alone. Section 5.2 now discusses Fig. 2c’s estimate of skill-construction time, including Writer updates. Appendix E.4 reports offline training cost separately.
Minor W1 ... The weight updates operate on the Writer and the procedural knowledge is still only provided to the target model in natural language.
The frozen Reader receives the procedure only through the saved text skill. The Writer retains its shared initialization across tasks. For each new pair, we temporarily update the Writer’s LoRA parameters and discard that update after skill construction.
Minor W2
The main Table 1 should report the standard deviation from the 5 repeats for all results rather than just the average.
Thank you for raising this point. We now have added the sample SD for every score in Table 1D to Appendix E.1, covering all six methods and all five benchmarks.
Response to Reviewer ncxj(Part 3)
Minor W3 MetaSkill-4B use a Qwen3 backbone while 7B/14B use a Qwen2.5 backbone.
The 4B comparison varies both family and size. The 7B and 14B Writers share the Qwen2.5 family, so their comparison isolates size more closely. We now identify the families in the main text beside Table 2. With the Reader fixed, the two Qwen2.5 Writers scored 57.0 at 7B and 62.4 at 14B across the five suites. The main optimizer comparison holds the Writer backbone fixed at Qwen2.5-14B.
Q1 Given how RLVR is generally ran (hundreds of epochs, large batch size), I find it surprising that only a handful of steps of GRPO can significantly improve performance as shown by the ablation in Table 1B. Can the authors provide more details on how the performance varies with different amount of adaptation of the Writer's weights?
Our insight is that a few GRPO steps are effective here because we meta-train the Writer specifically to adapt quickly to a new task–Reader pair. During meta-training, we reward the shared initialization according to how well the final skill performs on held-out queries after the Writer adapts to the Reader’s support feedback. Table 1B shows why the starting point matters. Under the same two GRPO rounds and subsequent text refinement, the original Writer scored 41.0 across the five suites, while the meta-trained Writer scored 62.4. To measure how performance changes with the amount of adaptation, we varied the number of GRPO rounds on the same meta-trained checkpoints and kept the text-refinement budget fixed. The first round accounted for 6.9 of the 10.1 points gained over text refinement alone.
Table N5. Effect of GRPO rounds on the same meta-trained checkpoints.
| GRPO rounds | Candidates evaluated | Configured optimizer steps | Five-suite mean |
|---|---|---|---|
| 0 | 0 | 0 | 52.3 |
| 1 | 8 | 2–4 | 59.2 ± 1.4 |
| 2 | 16 | 4–8 | 62.4 ± 1.9 |
We also tested whether evaluating more candidates could explain the gain. When we kept all 16 candidate evaluations and the same text-refinement procedure but set the inner learning rate to zero, the mean fell from 62.4 to 54.6 (Table 1B). This isolates a 7.8-point gain from updating the Writer at the same sampling budget. For the five-round setting, we continued meta-training for three epochs using five GRPO rounds per visit and then evaluated with five rounds. This longer schedule scored 61.4 ± 3.2. Because it also changes the checkpoint, Table N5 provides the direct comparison of adaptation depth at a fixed initialization.
Table N6. Five-round continuation experiment.
| Additional meta-training | GRPO rounds at evaluation | Candidates evaluated | Configured optimizer steps | Five-suite mean |
|---|---|---|---|---|
| 3 epochs with 5 rounds per visit | 5 | 40 | 10–20 | 61.4 ± 3.2 |
Q2 As per my W1 comment, can the authors compare the performance across the number of iterations for both T_grad and T_text steps, alongside comparable iterations from the baseline methods?
We report performance by round for each MetaSkill stage, and by construction tokens for the comparison across optimizers. With the text budget fixed, a second parameter round added 3.2 points (Table N5). With parameter adaptation fixed, allowing three text revisions instead of one improved all four non-interactive suites on the same checkpoint, most on SCAN (49.4 to 65.6). Table N7 uses a single evaluation on the same checkpoint for the one- and three-revision caps.
Table N7. Effect of the text-revision cap.
| Suite | 0 revisions | Up to 1 | Up to 3 | Up to 5 |
|---|---|---|---|---|
| SuperNI | 61.2 | 61.2 | 65.9 | 66.4 |
| BBH | 51.7 | 51.8 | 62.5 | 63.3 |
| SCAN | 48.1 | 49.4 | 65.6 | 69.3 |
| CLUTRR | 40.5 | 42.9 | 49.6 | 52.9 |
| ALFWorld | 64.2 | 60.2 | 60.2 | 60.4 |
For the baselines, Table N2 shows why the iteration counts are hard to equate. GEPA averaged 26.75 native loops and 3.75 new proposals, while five TextGrad steps produced five proposals and used 16 Writer calls. Table N1 gives the cross-method score curves at common token caps.
Q3 Figure 2b is confusing. What is the "single-stage" baseline? Why does it vary depending on "+gradient" or "+text"?
“+gradient” starts from text refinement alone, and “+text” starts from parameter adaptation alone. Each bar shows what happens when we add the missing stage. Adding parameter adaptation raises the five-suite mean from 52.3 to 62.4 (+10.1). Adding text refinement raises it from 53.1 to the same 62.4 (+9.3). We revised the Fig. 2b caption to name both starting conditions and report the signed changes on ALFWorld.
We greatly appreciate your thoughtful review and constructive feedback. We revised the setup and figure captions in §§5.1–5.2 and added the standard deviations, adaptation sweeps, cost breakdown, and MBPP results in Appendices E.1 and E.3–E.5. Please let us know if you have any further questions.
Response to Reviewer ncxj(Part 1)
Dear Reviewer ncxj:
We greatly appreciate your thoughtful review. We respond to your comments point by point below.
All four methods use the same Qwen2.5-14B Writer backbone, frozen Reader, support and query sets, and skill-output limits. All select skills on support data. The baselines start from the original Writer. MetaSkill starts from its learned initialization and generates up to 22 candidates: 16 for parameter adaptation, then one fresh skill and up to five revisions. The baseline stopping rules and their actual call counts are reported in Table N2 below.
We respectfully disagree that the baseline comparison lacks rigor. As described above, we held the Writer backbone, frozen Reader, evaluation data, and skill-output limits fixed across methods. How to match the search budget is a separate design choice. In the original paper, we used the same limit of five text revisions when comparing Writer initializations under MetaSkill’s adaptation procedure. This lets us ask how well each Writer uses the same number of opportunities to revise a skill. For GEPA, TextGrad, and SkillOpt, we used each optimizer’s own stopping rule (Table N2), since a GEPA iteration can end without a revision and a TextGrad step can involve several Writer calls.
To address your suggestion, we also compared the methods under common per-episode token caps (Table N1). At 10k tokens, MetaSkill scored 62.30, 1.76 points above TextGrad, the strongest baseline at that cap. At 5k, TextGrad led by 2.62 points. The caps count Writer and support Reader input and output tokens, including unsuccessful proposals. We evaluate the selected skills on held-out queries and weight the four non-interactive suites equally.
Table N1. Four-suite scores under common construction budgets.
Under the original stopping rules, MetaSkill and TextGrad both reached 63.0. MetaSkill used 23.63k tokens on SuperNI, 9.62k on BBH, 10.50k on SCAN, and 12.10k on CLUTRR, for a four-suite mean of 13.96k (about 14.0k). TextGrad used 99.8k tokens per skill on average to reach the same score. We leave MetaSkill’s 20k cell empty because we did not evaluate it under that cap on every episode. Its original mean on SuperNI alone exceeds 20k.
From 5k to 20k, GEPA gained 2.83 points, all after 10k. TextGrad gained 3.04 points across the two intervals. SkillOpt gained 1.28, with little change after 10k (56.22 to 56.20). At 20k, the three methods were 0.40, 1.06, and 1.90 points below their respective original scores. MetaSkill therefore achieved the highest four-suite score at most time and matched TextGrad’s final score under their original stopping rules using about one-seventh as many construction tokens per skill.
In a profile of one episode per non-interactive suite, GEPA and SkillOpt spent most of their tokens executing candidates on the support Reader. TextGrad spent most of its tokens generating feedback and updates with the Writer. Tables N2–N3 report means over these four episodes. The generation limits were 512 tokens for the initial skill, 2,048 for analysis or updates, and 256 for a Reader response.
Table N2. Baseline iteration and call counts in the four-episode profile.
GEPA averaged almost 27 loops but fewer than four new proposals. It skips reflection when it already solves the feedback subset, and we disabled merging. TextGrad uses up to two example-level feedback calls and one update call per step. SkillOpt groups successes and failures for reflection, merges or ranks when needed, and makes slow updates across epochs. We disabled its optional meta-skill extension.The same four episodes give the following breakdown in thousands of tokens. We counted unsuccessful proposals and recorded final query execution separately.