- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
The paper studies how to curate evolving skills so that when the executor model is changed, the skill curation policy is still effective. The paper finds that after training a skill curator for a certain executor, transferring such a curator to a new executor can cause a performance drop. Thus, the paper maintains an online behavioral profile of the executor and trains a shared curator that adapts its curation decisions based on this profile. Based on the proposed method, there are improvements on three benchmarks and various executor backbones.
Critical strengths
- The paper validates the dependency of the skill manager on its corresponding executor. Experiments show that the manager and executor are often paired best when they are trained together.
- The online behavioral profile is easy to construct and well supported by targeted ablations.
- The evaluation goes beyond task performance and retrieval rates. There is extensive analysis of the deployment-time token usage, environment steps, and paired edit-rollback diagnostics.
Critical weaknesses
- The motivation for a separately trained skill curator is not well supported. A frozen executor could also curate its own skills. The paper does not clearly explain why a separate curator is necessary, given the cost of additional training and maintenance, particularly for strong executors. Considering all that extra trouble brought by an external curator, the motivation is weak.
- Comparisons with plain-text skill optimization methods are missing. For example, SkillOpt and GEPA optimize skills without training a separate curator yet show high performance. Such comparisons are necessary to support the method.
Questions for authors
- What contributes to the token savings? Since token usage is averaged over all tasks, including the failed ones, the saved tokens may partly come from fewer unsuccessful steps rather than more compact skill context. Could the authors report both the token and step counts on both EASE and baselines so that we could obtain a clearer understanding?
- Is the deployment advantage worth the cost of training models? The reported token counts exclude curator training, quality judging, and skill-free reference generation. Could the authors report these costs and the trade-off between using a curator and using plain-text skill optimizers?
5 comments
Nonetheless, we do agree that taking parameter-free optimization methods into the discussion will greatly increase the impact of our paper. We greatly appreciate the reviewer for these insightful suggestions and have updated our manuscript accordingly.
| Method | ID (Qwen3-8B) | OOD (Kimi K2.6) |
|---|---|---|
| No Memory | 39.6 | 72.1 |
| MemP | 42.7 | 76.3 |
| Memento | 44.9 | 74.9 |
| GEPA | 43.7 | 75.6 |
| SkillOpt | 44.5 | 76.9 |
| SkillOS | 50.0 | 75.3 |
| EASE | 55 | 81.1 |
[1] Y. Yang, Z. Gong, W. Huang, Q. Yang, Z. Zhou, Z. Huang, Y. Li, X. Gao, Q. Dai, B. Liu, K. Qiu, Y. Yang, D. Chen, X. Yang, and C. Luo, "SkillOpt: Executive Strategy for Self-Evolving Agent Skills," arXiv preprint arXiv:2605.23904, May 2026.
[2] Agrawal et al. GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning. ICLR, 2026.
Q1: To better explain why the method is token-efficient, the author should consider reporting both the token and step counts on both EASE and baselines to build a clearer picture. Is it fewer unsuccessful steps or a compact skill context that helps the most?
We thank the reviewer for suggesting us to showcase a more detailed analysis of our token usage and efficiency. As we visualized in Figure 3(b) and reported in Table 7, 8, 9, we have shown and compared EASE’s component-wise token consumption against a strong SkillOS baseline. Specifically, EASE’s inference token advantage comes from two parts: i) shorter skill-context tokens: our learned skill curation policy is explicitly optimized to generate concise rather than verbose skills that help executors. ii) fewer agentic steps: EASE-generated skills facilitate executor agents to take a shorter path towards the answer on average. For more clarity, we recollect this evidence from the manuscript and summarize it as follows:
| Benchmark | Metric | SkillOS-base | SkillOS | EASE (ours) |
|---|---|---|---|---|
| ALFWorld | Skill-context tokens | 3.4k | 2.8k | 1.9k |
| Steps | 28.5 | 25 | 22 | |
| Exec. tokens / step | 315.8 | 300 | 313.6 | |
| ScienceWorld | Skill-context tokens | 7.8k | 6.2k | 4.2k |
| Steps | 32.5 | 28.7 | 24.4 | |
| Exec. tokens / step | 830.8 | 801.4 | 778.7 | |
| WebShop | Skill-context tokens | 8k | 6.5k | 4.5k |
| Steps | 18.5 | 16 | 13.5 | |
| Exec. tokens / step | 1513.5 | 1562.5 | 1592.6 |
For long-horizon agentic tasks, it is the agent’s interaction steps that dominate the total token consumption, and the skill context is relatively negligible. Ideally, higher-quality agent skills should not only improve the agent’s success rates, but also reduce redundant steps, repeated tool interactions, and unproductive exploration by allowing agents to reuse previously acquired procedural knowledge [3, 4]. In this sense, our EASE has successfully fulfilled this expectation and therefore contributes to more efficient token inference when compared with baselines.
We hope these empirical results and discussion could better clarify our token efficiency and build up a clearer understanding for future readers and researchers.
[3] S. Chen et al., “SkillCraft: Can LLM Agents Learn to Use Tools Skillfully?,” arXiv preprint arXiv:2603.00718, 2026, doi: 10.48550/arXiv.2603.00718.
[4] X. Li et al., “SkillsBench: Benchmarking How Well Agent Skills Work Across Diverse Tasks,” arXiv preprint arXiv:2602.12670, 2026, doi: 10.48550/arXiv.2602.12670.
Q2: Could the authors report more on training costs, the trade-off between using a curator and using plain-text skill optimizers, and justification for training a skill curator at all?
We appreciate the reviewer for the in-depth question, and we’d love to disclose more for reproducibility and facilitate follow-up research. During the training stage, following the hyperparameters we reported in Tables 2 and 3, EASE calls all executors and the curator about 307,200 times for the entire RL optimization process, resulting in a total token cost of approximately 3x10^9, including quality judging and skill-free reference generation. Please refer to the following table for more details on training cost.
| Statistics | Value |
|---|---|
| Training updates | 60 |
| Groups per sampling batch B | 32 |
| Rollouts per group N | 8 |
| Tasks per stream T | 10 |
| Curator | Qwen3-8B + LoRA (r=16) |
| Skill-free references m | 4 per (task, executor) |
| Executor episodes | 153,600 |
| Curator calls | 153,600 |
| Executor + curator calls | 307,200 |
| Judge calls | ≤ 153,600 |
| Reference episodes | ≤ 42636 |
| Executor tokens | 1.41B – 1.95B |
| Curator tokens | 0.51B – 0.61B |
| Judge tokens | 0.15B – 0.46B |
| Reference tokens | 0.34B – 0.51B |
| Total tokens | ≈ 3B (3x10^9) |
The training-based skill curator optimization and plain-text online skill optimizers represent two different paradigms. We realized that the training-free plain-text skill optimizer enjoys a great advantage: without any parameter finetuning cost, the strong agentic executor itself can handle problem solving, self-reflection, and skill curation altogether.
However, the advantage is not a free lunch. First, using these strong agent models for self-skill curation can be very costly. Second, the self-reflective behavior largely depends on the carefully designed seed prompt that only heuristically guides the models to do so. Beyond the model’s autonomy, how to monitor, analyze, and improve the self-driven hill-climbing process is also an open research problem. Third, it is less effective with lightweight models (as we have seen in Table 1 and in our answers in W2 above)
In contrast, if we can offload the skill-learning job from the main executor itself to another fine-tuned skill curator, the amortized inference cost can actually be lower when compared with pure plain-text skill optimization for long-running agentic systems. More importantly, with a learned transferable skill curator, it becomes feasible to use more affordable executors rather than only top-tier LLMs for easier and more repetitive agentic tasks, which can further reduce the inference cost.
Therefore, although plain-text skill optimizers show their unique training-free advantages, our training-based skill curation learning provides a transferable solution for long-running agentic systems with different executors. We hope the full cost breakdown, comparison, and justification can help clarify our advantages and strengthen our work. We have added these reviewer-inspired discussions to our revised manuscript for future readers.
In summary, we greatly appreciate the reviewer’s constructive comments and insightful suggestions. We hope the updated version can better explain our work’s motivation, contribution, and academic value for the community.
We deeply appreciate the reviewer sxWb’s recognition of our preliminary analysis on the “dependency of the skill curator on its corresponding executor”, simple yet effective “behavioral profile which is well supported by targeted ablations” and our “extensive analysis of the deployment-time token usage, steps and edit-rollout back diagnosis”. These key points summarize some highlights of our research on learning a transferable skill curator for evolving agents in real environments. To further strengthen our manuscript with the help of reviewer’s insightful comments, we now carefully address and answer each one of them as follows:
W1: The motivation of this work should be further strengthened by comparing with frozen training-free executors that can self-edit their own skills without the effort of additional parameter fine-tuning.
We appreciate the reviewer’s suggestions on strengthening and clarifying our motivations. As the reviewer mentioned, the training-free executor with the skill-using capability alone is an intuitive and nonnegligible baseline. Here are also some of our observations that build up our motivations: 1) Although training-free baselines are more seemingly accessible, they do require either a carefully designed prompt for every domain or an iterative loop that enables automated text optimization during runtime, which introduces sensitivity to prompt or unstability for the stochastic process; 2) These baselines are also largely depend on the strong LLM’s native capability to self-reflect and self-manage its existing skills, which may not necessarily be budget-friendly when using top-tier models due to long-context inference and high API/inference-cost. Given these reasons, learning a separate and generalizable skill curator that works for even lightweight but much more affordable agents becomes natural to us.
EASE framework goes one step forward and targets a harder optimization problem: how to curate executor-adaptive skills that facilitate any agent’s performance. This path offers a plug-and-play solution for any agentic system that supports agent skills. (To our knowledge, many popular and well-developed agent harness systems like Codex, Hermes, Pi, DeepSeek Harness, etc., do support skills natively.) Additionally, since we focus on executor-adaptive skill curation policy learning for any, from weak to strong, executors, even lightweight open-source models (e.g., Qwen3-8B) get benefits from our solution. Lastly, we do believe that by offloading skill curation from the main executor itself, it provides more flexibility for researchers to study stronger and more transferable skill curators.
Empirically, in Table 1, we also compare with several existing approaches (AWM, ReasoningBank, MemP, and Memento-Skills) that follow a similar training-free single-executor configuration as the reviewer suggested. According to the results, these methods are outperformed by training-based methods, including SkillOS and ours, under the same configurations.
Given all these reasons, we believe learning an executor-behavior adaptive skill curation policy is nontrivial and worthwhile. We have updated these discussions in our manuscript to show a more holistic motivation for our research.
W2: To support the method, comparisons with plain-text skill optimization methods are necessary. (e.g., SkillOpt and GEPA optimize skills instead of training a separate curator)
We thank the reviewer for suggesting more advanced training-free prompt optimization methods like SkillOpt[1] and GEPA [2]. GEPA [2] employs natural-language reflection and evolutionary prompt optimization, providing an effective alternative to reinforcement learning for improving LLM systems without parameter updates. SkillOpt[1] applies bounded add/delete/replace edits gated by held-out validation to a single skill document, offering a solution for utilizing frozen LLM agents without parameter training. As the reviewer suggested, we have included these two new context optimization training-free baselines for comparison.
According to our results, GEPA and SkillOpt’s performances are sensitive to different executors: when working with the weak and lightweight agent Qwen3-8B, they are outperformed by the training-based methods (e.g., SkillOS and EASE); However, for a more capable model like Kimi K2.6, they can match the performance of the training-based approach. Our take on this is that when only lightweight executors are accessible, these plain-text skill optimization methods may not be the optimal choices.
Beyond performance, we also observed that these prompt optimization methods are very sensitive to the seed prompt and therefore require lots of heuristic prompt-tuning in the first place. Additionally, the stochastic hill-climbing nature of these text optimization approaches makes them extremely difficult to optimize and analyze retrospectively.