acceptodds
Under review as a conference paper at ICLR 2027

Forgetting is What to learn: Verifier-Grounded Minimal-Core Skills for Self-Evolving Agents

Abstract

AI for Science (AI4Science) increasingly relies on AI agents to execute long-horizon scientific workflows that require multiple reasoning steps, specialized tools, data transformations, and domain-specific procedural constraints. Reusable skills can transfer useful scientific experience across tasks, but directly accumulating successful workflows also preserves redundant, source-specific, and behaviorally unnecessary procedures. We present AutoSkills, a verifier-grounded framework for evolving reusable skills for long-horizon task execution. Given a successful reference workflow, we construct an over-complete skill and performs verifier-grounded forgetting: candidate operations are removed and the solver is rerun under the same executable verifier, retaining only deletions that preserve task performance. The remained core skill is then generalized for transfer and selectively reused based on empirical evidence. We evaluate primarily on biomedical scientific workflows, where tasks involve multi-step data analysis, domain-specific procedures, and executable evaluation. On a 39-task BioDSBench panel, we achieve 100.0% accuracy, compared with 76.9% without skills and 79.5% with SkillOpt. On BioMNIBench, AutoSkills improves the mean reward from 0.790 to 0.917, and on a larger 159-task BioDSBench evaluation reaches 94.97% accuracy versus 77.36% without skills. Beyond the primary biomedical setting, skill transfer improves performance on LiveMathematician from 0.57 to 0.68 and on OfficeQA from 0.33 to 0.60.

Primary area:
foundation or frontier models, including LLMs
Keywords:
llm agents, self-improving agents, skill learning, selective forgetting, execution-based verification, skill transfer, agent harness

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_8X9eOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces AutoSkills, a novel approach to the skill extraction task that focuses on obtaining more concise and broadly applicable skills from positive examples of performed tasks. The described method first obtains a complete skill from the reference implementation of a task and then attempts to remove each operation from it and retrain to see if it made any difference to the execution. After that, the skill is modified to make it more general and added to the skill library. The most applicable skills are then selected based on their past performance, similarity to the task at hand, and compatibility. The experiments were conducted on the domain of biomedical data analysis, with some results reported on mathematical problems and office question-answering tasks. Overall, the results suggest that leveraging skills significantly improves the performance, but it is unsure how much of these improvements are due to the method itself and how much comes from the intensive verification-based pruning as described in the paper.

Critical strengths
  1. I agree with the problem statement that the paper addresses, that completing a task successfully once does not imply that every step taken toward completing it should be retained in future instances of the task. For agents that make several tool calls and process data, these operations that were found to be irrelevant to the task at hand could interfere with subsequent operations. I think that the approach of determining what can be discarded from the workflow by relying on the actual execution is an intuitive one.

  2. The paper benchmarks realistic multi-step data analysis tasks and achieves significant improvements, such as an increase in accuracy from 77.36% to 94.97% in the larger BioDSBench evaluation. With additional clarification of the details of evaluation splits and skill selection, I think that these results could be leveraged to demonstrate the value of the approach well.

Critical weaknesses
  1. It is unclear what test-task information the skill selector uses, which directly impacts how the results should be interpreted. The selector used in Section 3.5 uses both the current task's no-skill score and, preferentially, a skill's previously observed improvement on that same task. This suggests that selection already knows which skills work on the current problem. That is understandable in a context where multiple attempts at the same task are allowed, but different from selecting skills for an unseen task. The paper does not clearly report how many of the tasks in the main results use this direct feedback, nor does it clarify if skill construction, validation, selection and final testing are separated. The authors report that reference files are hidden from the solver, but this alone does not reveal if target-task information gets in the system through the content of skills or their selection. I am then unsure how much of the improvement comes from transfer of tasks.

  2. The paper underlines the idea of "forgetting through verification," but the experiments mostly evaluate the value of skill selection, not the importance of pruning. Table 3 compares the performance using and not using the selector, but not the performance of full skills, skills shortened by an LLM only and skills pruned through execution-based verification. Even if the complete system performs well, it is unclear if verified pruning is more valuable than simply providing the reference workflow or using ordinary text-based simplification. The paper lacks before-and-after measures for skill length, number of retained operations and the extra cost of execution to judge if pruning is worth the overhead. There appears to be an upside-down sign in the core deletion criterion, too: Eq. (2) defines Δ as the full-skill score minus the score with deletion, but Eq. (4) requires Δ ≥ −zSE, which can be true even if deletion dramatically worsens the performance, contrary to the intended meaning that deletion should not worsen performance. Could the authors clarify whether that is a typo in the equation or if the implementation makes the same choice?

Questions for authors
  1. Could the authors please clarify the splitting of tasks for skill construction, pruning, generalization validation, selector history, and final testing? How many test tasks in the main results make use of historical skill scores from that same task? What would happen if target task scores are excluded and skills are selected based on only information from other tasks?

  2. Given the same reference to information and evaluation budget, how do full skills, skills shortened directly by an LLM, and skills pruned through execution-based verification compare? How many operations or tokens, on average, does pruning remove and how many additional executions does it require? This comparison would be critical to my assessment of the core contribution.

  3. Is the inequality in Eq. (4) reversed? Could the authors please clarify the acceptance condition actually used in the code and how the standard error and threshold are found? If the implementation does follow the equation as written, would correcting it change the main results?

3 comments
AuthorsOpenReview ↗

Target-Task Feedback, Pruning Controls, and the Correction to Eq. (4)

We thank the reviewer for identifying the sign error and for distinguishing two questions: whether a skill transfers to another task, and what information the selector already has about that target. We address the information available at each stage before interpreting the pruning results.

W1 & Q1. Task splits, same-target history, and information available to the selector

The author constructs and prunes each skill on its source workflow. The generalizer receives the source skill without the target task; the rewritten skill is validated on a task group separate from the source training split. The final transfer comparison evaluates 37 held-out source–target pairs.

We audited two different routes by which task identity enters the evaluation:

Audit questionResult
Is a source skill counted as a transfer back to its own task?0 of 50 audited targets had a source equal to the target.
Is a different task from the same family present in the history?25 of 50 targets had such a task. The split is by task, not by family.
Does a target's transfer outcome enter its own fitted prediction?No. For each target tt, the regression, residuals, and type offsets are fitted exclusively on records with a different target.

With leave-one-target-out fitting, the selector attained 67.5% top-1 accuracy and 99.36% inject/skip accuracy at k=8k=8. At runtime, Eq. (8) permits prior same-target gains in Phase 1 and uses the measured no-skill baseline btb_t in Phase 3. Excluding a target from the fit does not remove this input. The 0/50 count measures self-transfer, not Phase-1 usage. The published BioDSBench panels give neither per-route counts nor an end-task score with all target feedback disabled. They evaluate feedback-assisted reuse.

W2 & Q2. Full skills, direct LLM shortening, verified pruning, and cost

We evaluated three controls using DeepSeek-V4-Flash-0731 on 37 BioMNIBench transfer pairs. Each starts from a source-derived skill. The shortening prompt instructs the LLM to remove duplication while preserving the methods, thresholds, and order of retained operations; no solver execution decides which operations to remove in that control.

Skill supplied to the solverGeneralizationMean rewardResult source
Full source skill, no pruningYes0.8435New transfer control
LLM-shortened source skillYes0.8619New transfer control
Verified-pruned source skillNo0.8541New transfer control
AutoSkills: verified pruning, generalization, and runtime selectionYes0.917Submitted full-system result, Table 3

Direct shortening gained 0.0184 over retaining the full skill before generalization. The complete system has the highest reported reward. Its 0.917 includes runtime selection; the difference from a control is therefore a system-level comparison, not an estimate of pruning alone at equal search cost. The controls also differ in offline work: text-only shortening uses no deletion rollouts, whereas verified pruning explicitly pays for those tests.

In the 49-task pruning analysis, verification removed 87.0% of operations and reduced the rendered skill by 77.1% of tokens, at 11.06 additional evaluations per task. For one concrete source, da-5-1, the original, LLM-shortened, and verified-pruned artifacts occupied 171, 55, and 18 lines, respectively. In a separate block-search experiment, grouping operations reduced evaluations from 10.50 to 6.12 per task on the 16-task common subset. These measurements quantify both the extra work during construction and the reduction in the artifact supplied at transfer.

W2 & Q3. Sign of Eq. (4) and the implemented acceptance rule

Thank you for pointing out the reversed sign. We have corrected Eq. (4) in Section 3.3 of the revised manuscript. Eq. (2) defines Δ=U(S)−U(S′)\Delta=U(S)-U(S'), where S′S' is the skill after deletion, so a positive Δ\Delta denotes a loss in utility. The condition U(S′)≥U(S)−zSEU(S')\geq U(S)-z\mathrm{SE} is therefore equivalent to Δ≤zSE\Delta\leq z\mathrm{SE}. The original manuscript incorrectly stated Δ≥−zSE\Delta\geq -z\mathrm{SE}. The reversed sign was confined to the manuscript, so correcting Eq. (4) does not affect any reported experimental result.

Thank you for the clarifications and additional experiments. My concerns about target-task feedback and the isolated contribution of verified pruning remain unresolved, so I will maintain my original score.

We sincerely thank you for your valuable comments and constructive feedback.

Reviewer_LpxQOpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes AutoSkills, a framework that detects and removes unnecessary operations in skills. AutoSkills uses a predicted score as proxy for block-wise deletion first and gradually falls back to leave-one-out deletion, then generates generalizable specs for pruned skills, and finally selects a skill according to its benefit. The results show that AutoSkills improves the task success rate across biomedical, math, and office benchmarks.

Critical strengths
  1. The problem of pruning unnecessary operations in skill is timely and important for improving LLM efficiency.
  2. The idea of block-wise pruning is interesting and sounds efficient.
  3. The logic of the method is generally coherent and easy to follow.
Critical weaknesses
  1. The implementation and accuracy of pruning score is not clear. No detailed description and prompts are provided. No comparison versus human raters are provided. It is not convincing that the score is properly designed.
  2. The evaluation is weak. Only one backbone model (DeepSeek-V4 Flash), one baseline (SkillOpt), and seemingly one harness is included. The ablation studies do not comprehensively cover all modules necessary to ablate. Specifically:
  • It is not clear whether stronger models (e.g. Opus 5+, GPT-5.6 Sol+) can automatically alleviate the effect of redundant operations and the proposed method can still work. It is also not clear whether the advantage trasfers to different model families (e.g. Qwen 3 series) and other harnesses.
  • The difference and advantage compared to the SkillOpt baseline is not well explained.
  • To validate the necessity of all modules in Sec 3.3-3.5, there should be at least the following results:
    • Real operations consumed during the pruning process to show that score guidance and block pruning reduce the cost.
    • Ablation variants without each threshold in Eq. 4/5/8 to show that these gates are useful in practice.
    • Baselines that do 1) no pruning and 2) no skill generalization to show the use of these two steps.
Questions for authors
  1. L237: Can the authors provide concrete prompt used for this score? Also, the presentation of prompts in the appendix is not well organized.

The second uses an agent-produced removability score to reduce the number of expensive full solver evaluations.

  1. How is each instance routed to leave-one-out and score-guided block pruning? Always score-guided first and finally falling back to leave-one-out if none of the combinations are valid?
  2. How is f^\hat{f} fitted in skill selection phase 3?
  3. L315: How does "inconclusive" count in the experiments?

... is recorded as inconclusive

  1. What is the key difference between AutoSkills and the SkillOpt baseline?
  2. I would like to see additional results as described above. If these results can decently address my concern, I would consider raising my score.
3 comments
AuthorsOpenReview ↗

Score-Guided Pruning, Computational Cost, Component Ablations, and Cross-Model Evaluation

We thank the reviewer for asking those questions.

W1 & Q1. Pruning score and validation

The skill-authoring prompt specifies:

Ablation policy:
- All generated operations should default to enabled.
- Greedy ablation tries operations directly by `ablation_priority` from high to low, regardless of dependency shape.
- Assign higher priority to likely redundant scaffolding, diagnostics, or guardrails.
- Assign lower priority to likely critical formulas, data conventions, coordinate conventions, and output semantics.
- Use `depends_on` only as manifest metadata for human audit; it does not control deletion order or cascade deletion.

The author lists critical and removable operations by ID. self_check.likely_removable_ops nominates the first batch. We evaluated the ranking against execution outcomes, without human ratings. Mean priority was 43.5 for accepted deletions and 29.7 for rejected deletions. All 50 tasks had at least two priority levels. We will group appendix prompts by stage and label their outputs.

Q2. Block or singleton tests?

If the intact skill fails the source check, we keep it in full. Otherwise, the frozen solver tests blocks in descending ablation_priority order. We commit passing deletions. Only failed blocks are restored and recursively split, down to singletons. Without priority scores, we can start with singletons.

W2.1 & Q6. Stronger model and harness

We evaluated DeepSeek-V4-Flash and Claude-5-opus in the same Claude agent harness. On 12 Claude-5-opus transfer pairs, mean reward rose from 0.8275 without skills to 0.8650 with skills (5 gains, 6 ties, 1 decline). On the 7 pairs using verified-pruned skills, it rose 0.9186 → 0.9471. The other 5 used full skills. Together with 0.790 → 0.917 on DeepSeek-V4-Flash, this shows gains on both proprietary and open-weight models. Given runtime and API costs, we prioritized the backbone comparison and used the same Claude agent harness and tools throughout.

W2.2 & Q5. What distinguishes AutoSkills from SkillOpt?

SkillOpt proposes bounded add/delete/replace edits from scored rollouts and validates revisions on held-out data. AutoSkills asks a more specific question: which operations in a successful reference workflow can this solver do without? AutoSkills tests which operations a solver can omit from a successful reference workflow and records verified deletions before generalization and selection. On BioDSBench, no skill, SkillOpt transferred from BioMNIBench, and AutoSkills passed 30/39, 31/39, and 39/39 tasks, respectively.

W2.3.1 & Q6. Pruning cost

One verifier-scored solver run averaged 0.4M tokens across model calls. All means use 50 tasks with results for all four configurations.

OrderBlock sizeRuns/taskOps removed
Random110.5084.2%
Priority110.5083.6%
Random36.7590.1%
Priority36.1292.1%

Blocking saved 35.7% of runs under random ordering and 41.7% under priority ordering. Within block search, priority ordering saved 9.3% relative to random. Singleton sweeps test each operation once.

W2.3.2 & Q6. Thresholds in Eqs. 4, 5, and 8

Eq. 4. The audit counted 486 accepted deletions at threshold 0.60 (233 harmful), 253 at 1.00 (0 harmful), and 403 under the continuous rule (0 harmful), 150 more than at 1.00.

Eq. 5. The 0.8541 control removes the rewrite and both acceptance conditions together. Neither inequality was ablated individually.

Eq. 8. Removing transfer-type offsets at k=8k=8 reduced top-1 accuracy (67.5% → 55.0%) and inject/skip accuracy (99.36% → 98.08%). Raising the score threshold from 0.00 to 0.10 improved inject/skip accuracy (98.72% → 100%), with top-1 unchanged at 67.5%. Top-1 ranged from 65% to 70% over k∈0,4,8,16k\in{0,4,8,16}.

W2.3.3 & Q6. Removing pruning or generalization

On 37 BioMNIBench transfer pairs with DeepSeek-V4-Flash, mean reward was 0.8435 for full skills plus generalization, 0.8619 for LLM shortening plus generalization, and 0.8541 for verified pruning without generalization. Separately, Table 3 holds the library fixed and reports 0.870 without selection and 0.917 with selection (full system).

Q3. Phase-3 fitting

We fit isotonic regression from no-skill baseline bub_u to transfer gain rs→u−bur_{s\to u}-b_u, then interpolate piecewise linearly. For target tt, we exclude all its records when fitting f^\hat f, residuals, and type offsets. Phase 3 combines f^(bt)\hat f(b_t) at the target’s measured baseline with source quality and compatibility.

Q4. Inconclusive runs

Timeouts and abnormal exits count separately from scored passes and failures. If a deletion test is inconclusive, we retain the operation.

Reviewer_LpxQOpenReview ↗

Response to Author Rebuttal

I thank the authors for their response, which partly address my concerns. However, I am still not sufficiently convinced that the evaluation comprehensively validates the effectiveness of AutoSkills and the necessity of modules in its design. Specifically, the main issues include the limited coverage of evaluation (i.e. single harness) and the priviledged information from reference skills (which I think is not utilized in SkillOpt). Therefore, I will increase my score to 2 but not 3.

Thank you for your kind response!

Reviewer_qrL1OpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes AutoSkills to address the problem in long-horizon scientific workflows that “successful trajectories are not equivalent to necessary procedural knowledge.” It argues that the key to skill evolution is not continual accumulation, but rather actively “forgetting” unnecessary behaviors through an executable verifier: AutoSkills first constructs an overcomplete skill set from reference implementations, then deletes candidate operations one by one or in blocks and reruns the solver. A deletion is accepted only if it does not significantly reduce utility and the resulting utility remains above the no-skill baseline; otherwise, the deletion is rolled back, yielding a verifier-screened core. Subsequently, AutoSkills removes source-task-specific anchors, merges operations that share the same principle, and supplements applicability boundaries. Finally, at runtime, it decides whether to inject skills based on direct transfer, task similarity, source quality, and compatibility. Biomedical benchmarks and auxiliary experiments show that the method improves long-horizon task performance, and ablation studies also indicate that goal-aware skill selection is important.

Critical strengths

1.The motivation is clear.

2.The experiments and ablations are generally sufficient

3.Although I am not deeply familiar with the field of AI for Science, I find it rather interesting that the authors incorporate a continual learning–like concept into this AI4S agent.

Critical weaknesses

1.The paper relies heavily on an executable verifier, yet it remains unclear whether reliable verifiers are readily obtainable and broadly applicable across scientific tasks.

2.The experimental validation is limited to a single foundation model, DeepSeek-V4-Flash. It is therefore unclear whether the findings are sufficiently general, or whether they may reflect model-specific preferences and behaviors.

3.The paper should explicitly specify which reported results are obtained via an LLM judge. While LLM-based evaluation is now commonplace in the field, greater clarity on this point would improve transparency; the current presentation is insufficiently explicit.

4.The computational cost of pruning appears potentially high.

Questions for authors

na

1 comment
AuthorsOpenReview ↗

Scope of Verification, Pruning Cost, and Cross-Model Results

We thank the reviewer for recognizing the motivation for learning what to remove from a successful workflow. We address the scope of verification, the role of LLM grading, and the measured cost and benefit of pruning below.

W1. Which scientific tasks admit verification?

Both scientific benchmarks in our study already provide the verifier that AutoSkills needs, so applying the method requires no additional verifier development. On BioDSBench, the evaluator executes the submitted R code and checks its outputs against task-specific assertions. On BioMNIBench, the benchmark’s LLM judge grades both the analysis trace and the final answer against a hidden, expert-authored rubric. In both settings, AutoSkills reruns the workflow after a candidate deletion and scores it against the same criteria used for the intact skill. This makes verification-based pruning applicable across scientific workflows with different kinds of outputs, from computational results with executable checks to multi-step analyses with expert-defined grading criteria.

W2. Does the benefit persist with a stronger backbone?

We ran skill authoring, pruning, generalization, and transfer with Claude-5-opus, keeping the selector unchanged. In the broader no-skill evaluation, Claude scored 0.887, compared with 0.790 for DeepSeek-V4-Flash. On the 12 source–target pairs evaluated with and without a skill, mean reward increased from 0.8275 to 0.8650. The breakdown separates the two paths through the pipeline:

Source skill used at transferPairsNo skillWith skillImproved / tied / declined
Verified-pruned skill70.91860.94712 / 4 / 1
Full skill retained because the source did not reach the pruning threshold50.70000.75003 / 2 / 0
All pairs120.82750.86505 / 6 / 1

The largest gain was 0.70 → 0.90; the single decline was 0.94 → 0.88. All five targets with no-skill reward between 0.70 and 0.85 improved by 0.06–0.20. The tested skills therefore improved performance beyond the original DeepSeek backbone, including on a second model that already solved three of the twelve targets perfectly without a skill. The results show that AutoSkills improves performance on both an open-weight backbone and a frontier proprietary backbone under the same execution environment.

W3. Which results use an LLM judge?

BioMNIBench uses an LLM judge . We follow BioMNIBench’s official evaluation protocol :https://huggingface.co/datasets/phylobio/BiomniBench-DA which uses an LLM judge by default. For each task, the judge evaluates both the analysis trace (trace.md) and the final answer (answer.txt) against the benchmark’s expert-authored rubric, which is hidden from the solver. We use this procedure for all BioMNIBench results: the scores in Tables 1 and 3, the increase in mean reward from 0.790 to 0.917, and the transfer experiments reported here. Appendix B.6 provides the grading prompt.

BioDSBench uses executable R assertions. Its 39-task and 159-task results are binary pass/fail outcomes. The LLM that proposes a deletion order does not grade these submissions. LiveMathematicianBench and OfficeQA are auxiliary transfer evaluations: their published metrics compare a predicted choice or normalized answer with a reference answer, respectively.

W4. How much does pruning cost?

Each pruning evaluation used approximately 0.4 million tokens on average, accumulated across the model calls in one full solver run. In each evaluation, the solver executes the source task with a candidate skill, and the task verifier scores the resulting output. Across 49 source tasks, the original continuous-score protocol required 11.06 additional runs per task, equivalent to an estimated 4.4 million tokens per source task at the average per-run cost. This cost is incurred once during skill construction. Subsequent tasks reuse the stored skills, which contained 87.0% fewer operations and 77.1% fewer tokens than the original skills.

We tested four pruning configurations on 50 tasks and compared them on the 16 tasks with results for all four configurations. With the deletion order fixed by score, testing operations individually required 10.50 runs per task, whereas testing them in blocks of three required 6.12. Blocking thus saved 4.38 full solver runs per task (41.7%): a single run tests the entire block, and only rejected blocks are split and retested. With random deletion order, blocking also reduced the count, from 10.50 to 6.75 runs per task (35.7%).

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.