PaperlayerView exact revision on arXiv

Source-linked AI summary

SkillOpt: Executive Strategy for Self-Evolving Agent Skills

Yifan Yang, Ziyang Gong, Weiquan Huang, Qihao Yang, Ziwei Zhou, Zisu Huang, Yan Li, Xuemei Gao, Qi Dai, Bei Liu, Kai Qiu, Yuqing Yang, Dongdong Chen, Xue Yang, Chong Luo

arXiv:2605.23904v2cs.AIcs.CL

TL;DR

Existing agent skills are brittle and lack a disciplined optimization framework for adapting textual procedures. SkillOpt trains a skill document externally for a frozen agent using bounded edits and held-out validation, achieving best-or-tied-best performance in all 52 evaluated cells and a +23.5-point average GPT-5.5 gain in direct chat.

  • Problem

    Existing skills are often brittle, while how to optimize a skill as an adaptation layer remains an open question, especially when model-weight adaptation is unavailable or expensive.

  • Method

    SkillOpt optimizes a single skill document through scored rollouts, structured bounded edits, textual learning-rate budgets, and held-out validation gates for a frozen target agent.

  • Results

    Best or tied-best on 52 of 52 evaluated model–benchmark–harness cells, SkillOpt also raises GPT-5.5 average accuracy over no skill by +23.5 points in direct chat.

  • Takeaways & Limitations

    Optimized skill artifacts retain value when transferred across model scales, execution harnesses, and a nearby math benchmark without further optimization.

  • Takeaways & Limitations

    SkillOpt relies on scored trajectories and held-out validation, limiting direct applicability when task success is subjective, multidimensional, or costly to judge.

Abstract

from arXiv · show

Agent skills today are hand-crafted, generated one-shot, or evolved through loosely controlled self-revision, none of which behaves like a deep-learning optimizer for the skill, and none of which reliably improves over its starting point under feedback. We argue the skill should instead be trained as the external state of a frozen agent, with the same discipline that makes weight-space optimization reproducible. SkillOpt is, to our knowledge, the first systematic controllable text-space optimizer for agent skills: a separate optimizer model turns scored rollouts into bounded add/delete/replace edits on a single skill document, and an edit is accepted only when it strictly improves a held-out validation score. A textual learning-rate budget, rejected-edit buffer, and epoch-wise slow/meta update make skill training stable while adding zero inference-time model calls at deployment. Across six benchmarks, seven target models, and three execution harnesses (direct chat, Codex, Claude Code), SkillOpt is best or tied on all 52 evaluated (model, benchmark, harness) cells and beats every per-cell competitor among human, one-shot LLM, Trace2Skill, TextGrad, GEPA, and EvoSkill skills. On GPT-5.5 it lifts the average no-skill accuracy by +23.5 points in direct chat, by +24.8 inside the Codex agentic loop, and by +19.1 inside Claude Code. Transfer experiments further show that optimized skill artifacts retain value when moved across model scales, between Codex and Claude Code execution environments, and to a nearby math benchmark without further optimization. Code: https://aka.ms/skillopt

1 Introduction

SkillOpt treats an agent skill as trainable external state and optimizes it through bounded textual edits accepted only when they improve held-out validation performance. Across models, benchmarks, and execution harnesses, it achieves best-or-tied performance on all 52 evaluated cells while producing reusable artifacts that transfer across models, harnesses, and tasks.

  • Method: SkillOpt converts rollout trajectories into bounded add/delete/replace edits and accepts an updated skill only when it improves held-out validation performance.The optimizer also uses textual learning-rate budgets, rejected-edit buffers, and epoch-wise slow/meta updates.
  • Results: 52 of 52 evaluated (model, benchmark, harness) cells are best or tied-best for SkillOpt across six benchmarks, seven target models, and three execution harnesses.The study compares SkillOpt with no-skill, human-skill, one-shot LLM-skill, TextGrad, GEPA, Trace2Skill, and EvoSkill baselines.
  • Results: +23.5 points is SkillOpt’s average gain over no skill for GPT–5.5 in direct chat.Reported direct-chat improvements include QA from 33.1 to 72.1, DocVQA from 78.8 to 91.2, LiveMathematicianBench from 37.6 to 66.9, and ALFWorld from 83.6 to 95.5.
  • Results: +24.8 and +19.1 points are SkillOpt’s GPT–5.5 gains over no skill inside Codex-style and Claude Code-style execution loops, respectively.SkillOpt also outperforms EvoSkill by +14.0 and +3.2 points in those two harnesses.
  • Transfer: SkillOpt artifacts transfer across settings: a Codex-trained spreadsheet skill gains +59.7 points in Claude Code, while an OlympiadBench skill improves Omni-MATH.A SpreadsheetBench skill trained on GPT–5.4 also improves every tested smaller GPT variant.
  • Contributions: The exported skill artifact is compact, reusable, and deployable without model-weight updates.The paper validates the design through component ablations and cross-model, cross-harness, and cross-benchmark transfer experiments.

2 Related Work

Prior work optimizes prompts, agent configurations, and reusable skills using execution feedback, evolutionary procedures, and reinforcement learning. SkillOpt narrows this landscape to controlled training of one compact, portable skill with deep-learning-style textual optimization controls, without changing model weights.

  • Prompt auto tuning and agent-configuration search: GEPA, ABSTRAL, and EvoTest optimize prompts or multi-agent design artifacts using trajectory feedback and test-time evolution without gradients or fine-tuning.These methods treat language artifacts as optimizable objects and exploit execution feedback directly.
  • Skill construction and skill evolution: SkillsBench and related surveys define skills as reusable procedural knowledge spanning tool policies, applicability conditions, execution routines, and supporting resources.Prior systems construct skills from lifelong experience, trajectory lessons, knowledge bases, and heterogeneous domain resources.
  • Skill construction and skill evolution: Prior skill-evolution systems refine artifacts through failure analysis, creation-evaluation-revision loops, coevolving generators and verifiers, collective updates, or reinforcement learning.Their emphases include skill discovery, repository growth, sharing, and evolutionary search.
  • SkillOpt’s distinction: SkillOpt instead trains one compact domain skill using trajectory batches, reflection minibatches, textual learning rates, validation gates, rejected-edit buffers, and slow/meta updates.The procedure produces a portable best_skill.md without changing model weights.

3 Method

SkillOpt trains a natural-language skill for a frozen target model by generating bounded edits from scored training rollouts and accepting them only through validation-gated selection. Its optimizer separates fast edits from slower meta-guidance and uses harness adapters to support diverse execution environments without shipping optimizer-side state.

  • Skill and evaluation setup: A skill is a natural-language policy inserted into the agent context, while M denotes the frozen target model whose behavior is adapted.In direct chat, the skill is prepended to system or developer instructions; in tool-use harnesses, it becomes persistent procedural memory.
  • Rollouts and reflection: Training rollouts from Dtr produce trajectories that the optimizer model analyzes in failure- and success-based reflection minibatches to identify reusable procedural errors.Recorded evidence includes task metadata, messages, tool calls, observations, command outputs, final answers, verifier feedback, and benchmark-specific context.
  • Bounded skill updates: The edit budget Lt caps each update at the top Lt ranked edits, preserving continuity against destructive, incompatible, or overfitted rewrites.Edits are hierarchically merged, with failure corrections prioritized; patch mode uses localized operations, while rewrite mode conditions a full skill rewrite.
  • Validation-gated selection: Each candidate is evaluated on Dsel and accepted only when it improves the current selection score, with the best validation-gated skill exported as best_skill.md.The training split supplies experience, the selection split gates updates, and Dtest is reserved for final reporting.
  • Slow updates and portability: At epoch boundaries, slow/meta updates summarize improvements, regressions, persistent failures, and stable successes for future optimizer prompts, while harness adapters standardize execution across environments.Meta guidance remains optimizer-side only, so the deployed skill stays compact and portable; the same adapter interface supports direct QA, tool use, software execution, and Codex- or Claude Code-style harnesses.

4 Experiments

Across 52 evaluated cells, SkillOpt is best or tied-best, producing large no-skill improvements across models and execution harnesses. Ablations and transfer experiments attribute these gains to controlled text-space training and show that optimized skills generalize across models, harnesses, and a nearby benchmark.

  • Main results: 52/52 evaluated cells are best or tied-best for SkillOpt against all listed skill baselines.The comparison spans seven target models, six benchmarks, and direct-chat, Codex, and Claude Code settings.
  • Main results: +23.5 points lifts GPT–5.5’s six-benchmark direct-chat average from 58.8 without a skill to 82.3 with SkillOpt.SkillOpt also exceeds the best per-cell baseline average of 76.9 by +5.4 points.
  • Model and harness results: +17.6 points is the average improvement across seven direct-chat target models, with gains ranging from +9.1 for Qwen3.6–35B-A3B to +26.7 for GPT–5.4-nano.On GPT–5.5, average gains are +24.8 in Codex and +19.1 in Claude Code over no skill.
  • Alternative explanations: SkillOpt’s gains are not explained by prompt length or optimizer capacity: human skills are 145–516 tokens, yet learned artifacts beat them, including on GPT–5.4-nano.The optimizer-strength analysis reports a baseline increase from 27.5 to 67.5, followed by another +17.5 points from SkillOpt to 85.0.
  • Ablations: Bounded textual learning remains competitive across edit budgets and schedules, while the rejected-edit buffer and slow/meta update stabilize performance.Removing the rejected-edit buffer lowers scores by 1.6, 4.6, and 2.4 points on SearchQA, SpreadsheetBench, and LiveMath, respectively.
  • Transfer: +59.7 is gained when a SpreadsheetBench skill transfers from Codex to Claude Code, while cross-model and cross-benchmark transfers remain positive.Cross-model gains include +9.4 and +3.0 on GPT–5.4-mini and GPT–5.4-nano; OlympiadBench→Omni-MATH gains are +3.7, +1.8, and +1.3 across three scales.

5 Conclusion

SkillOpt treats an external skill document as the trainable state of a frozen LLM agent and turns skill improvement into a controlled learning process. Across six benchmarks, seven target models, and three execution modes, it was best or tied-best in all 52 evaluated cells.

  • Contribution: SkillOpt treats an external skill document as the trainable state for frozen LLM agents.The target model executes tasks while a separate optimizer edits the skill.
  • Contribution: Bounded edit budgets, minibatch reflection, validation gates, rejected-edit buffers, and epoch-wise slow/meta updates replace ad hoc prompt revision.These mechanisms make skill improvement a controlled learning process.
  • Contribution: 52 of 52 evaluated cells were best or tied-best across six benchmarks, seven target models, and three execution modes.The evaluation spans the paper’s reported benchmarks, target models, and execution modes.
  • Outlook: Future extensions include cross-domain skill libraries, reusable optimizer-side meta skills, reward-free or preference-driven validation, and self-distillation toward weight-level adaptation.These directions extend SkillOpt beyond optimizing one skill artifact for one target domain.

A Additional Method Details and Optimizer Prompts

The appendix specifies SkillOpt’s executable optimization loop: a frozen task-execution model is improved solely through a text skill document, with a separate optimizer proposing and selecting edits using held-out evaluation.

  • Optimization loop: SkillOpt fixes the task-execution model and trains only a text skill document.The execution model receives only the current skill and benchmark task, not the optimizer prompts.
  • Optimization loop: A separate optimizer model uses rollout evidence to propose patch-style edits, merge and rank candidates, and submit them to a held-out selection gate.The held-out gate evaluates each candidate skill before selection.

B Limitations

SkillOpt is a lightweight alternative to model-weight adaptation but has practical limitations. Its optimization loop depends on scored trajectories, held-out selection, and reliable feedback, limiting direct applicability in open-ended domains where evaluation is subjective, multidimensional, or costly.

  • SkillOpt remains a lightweight alternative to model-weight adaptation with several practical limitations.
  • The optimization loop relies on scored trajectories and a held-out selection split.
  • SkillOpt is most directly applicable when tasks provide automatic verifiers, exact-match metrics, executable checks, or otherwise reliable feedback signals.
  • Open-ended domains pose challenges when success is subjective, multi-dimensional, or costly to judge.

C Experimental Protocol Details

The protocol evaluates frozen students with native benchmark evaluators, compares SkillOpt against aligned skill and prompt-optimization baselines, and uses gated multi-epoch text optimization with controlled ablations.

  • Benchmarks and metrics: Held-out test examples are scored with each benchmark’s native evaluator using hard success or exact-match accuracy.The benchmarks cover question answering, spreadsheet and document reasoning, noisy retrieval, mathematical multiple-choice reasoning, and sequential decision making.
  • Baselines: Baselines include no-skill, human-skill, one-shot LLM-skill, Trace2Skill, TextGrad, GEPA, and harness-matched EvoSkill under the aligned evaluation protocol.Trace2Skill lacks SkillOpt’s iterative validation gate, while TextGrad and GEPA target direct-chat settings.
  • Optimization protocol: Unless otherwise stated, SkillOpt uses four epochs, rollout batches of 40, reflection minibatches of 8, textual learning rate 4, and minimum cosine-decay rate 2.The default configuration also enables held-out validation gating, slow updates with 20 sampled examples, and an optimizer-side meta skill.
  • Ablation protocol: One-factor ablations vary a single scalar or component while keeping the remaining optimizer configuration fixed.Train-size ablations use a 2:1:7 train/selection/test split, and the 100% row exposes the full training partition for direct comparison with smaller subsets.

C.1 Optimization Procedure · C.2 Optimizer Prompt Contracts

SkillOpt maintains explicit skill, validation, cache, rejection-buffer, and meta-skill state, while optimizer prompt contracts turn trajectory evidence into structured, ranked, and epoch-level updates. The contracts prioritize systematic failure repair, conservative success reinforcement, regression prevention, and optimizer-side learning through JSON-parseable outputs.

  • C.1 Optimization Procedure: The optimization state includes the current skill, best validation-gated skill, selection-score cache, rejected-edit buffer, and optimizer-side meta skill.The meta skill guides future edit generation.
  • C.2 Optimizer Prompt Contracts: Optimizer prompts require valid JSON so proposed edits can be parsed, filtered, applied, and validated without manual intervention.The contracts normalize terminology around the optimizer and training model.
  • C.2.3 Failure merge: merge_failure.md: Failure merging deduplicates and reconciles patches while preserving nonredundant corrective edits and prioritizing patterns recurring across multiple patches.Single-patch edits may be discarded when they appear task-specific.
  • C.2.4 Success merge: merge_success.md: Success merging conservatively reinforces generalizable patterns absent from the current skill, estimates support counts, and protects the designated slow-update section.Patterns appearing across many successful trajectories receive greater emphasis.
  • C.2.5 Final merge: merge_final.md: Final merging gives failure-driven patches priority, removes duplicate success edits, and retains success insights that address patterns not covered by failures.The output preserves edit operations, targets, content, support counts, and failure-or-success source types.
  • C.2.6 Ranking and selection: ranking.md: Edit ranking orders candidates by systematic impact, complementarity, generality, and actionability, then selects the requested budget of edits in priority order.The ranking output returns 0-based selected indices.
  • C.2.7 Slow update: slow_update.md: Slow updates compare the same 20 training tasks across consecutive epoch skills to detect regressions, persistent failures, improvements, and stable successes.Only the epoch-boundary process may overwrite the protected guidance section, which is read-only to step-level optimization.
  • C.2.8 Optimizer memory: meta_skill.md: Optimizer memory uses adjacent-epoch evidence to produce compact guidance for future failure analysis, success analysis, patch merging, and edit ranking.It records helpful or harmful edit types, useful abstraction levels, repair priorities, and regression risks while addressing the future optimizer rather than the training model.

C.2.1 Failure analysis: analyst_error.md

The failure-analysis skill extracts systematic, generalizable patterns from minibatches of failed trajectories and proposes a concise, budgeted set of skill edits. It returns structured JSON while excluding protected slow-update content from modification.

  • Analysis process: The agent reads all minibatch trajectories, prioritizes prevalent common failures, classifies each pattern, and patches only generalizable skill gaps.It should not hardcode task-specific values or duplicate existing content.
  • Edit constraints: The optimizer limits proposals to at most L edits, while allowing fewer edits when warranted.The edit budget L is supplied explicitly to the failure-analysis agent.
  • Output format: The analysis output is a JSON object containing the batch size, failure summaries, reasoning, and edit operations.Supported operations are append, insert_after, replace, and delete; edits may be empty when no patch is warranted.
  • Protected content: A protected section between SLOW_UPDATE markers must not be targeted, modified, or deleted by proposed edits.That section is managed by a separate slow-update process.

C.2.2 Success analysis: analyst_success.md

The success analyst extracts generalizable patterns common across multiple successful trajectories and proposes only broadly applicable, previously uncovered skill patches. It operates under an edit budget, prioritizes reinforcing existing sections, and protects slow-update content from modification.

  • Pattern extraction: The analyst identifies generalizable behavior patterns common across multiple successful trajectories in one minibatch.It receives the trajectories and current skill document as inputs.
  • Pattern extraction: It proposes patches only for patterns not already covered, favoring concise, task-general reinforcements of existing sections.New top-level sections are discouraged unless warranted by the observed patterns.
  • Patch generation: It produces at most L edits, where L is the supplied maximum edit budget, and may return fewer edits when appropriate.The output can include append, insert_after, replace, or delete operations, and edits may be empty if the skill already covers the patterns.
  • Patch generation: It must not target, modify, or delete content inside the protected SLOW_UPDATE markers.That section is managed by a separate slow-update process.

C.3 Patch Representation and Safeguards

SkillOpt represents updates as bounded atomic patches governed by a textual learning-rate budget, while safeguards isolate slow updates, require held-out acceptance, and retain rejected edits for future avoidance.

  • C.3 Patch Representation and Safeguards: Patch optimization permits only append, insert_after, replace, and delete operations, with merged edits recording support counts and source types for ranking.Ranking favors edits that survive independent analyses and hierarchical merges.
  • C.3 Patch Representation and Safeguards: The edit budget Lt limits how many proposed patches apply at each step, preserving continuity between adjacent skills.The budget functions as a textual learning rate.
  • C.3 Patch Representation and Safeguards: The protected slow-update section can change only at epoch boundaries, and rewritten candidates must pass the held-out selection gate before adoption.Rejected candidates’ failure patterns and edits remain in the step buffer to help later optimizer calls avoid harmful repetitions.

C.4 Design Principles

SkillOpt fixes the task-execution model and trains only the text skill through validated, evidence-aggregated, budgeted edits. Its design prevents unvalidated reflection from accumulating and supports larger early changes with smaller later ones.

  • Fixed model: The task-execution model remains fixed while only the text skill changes.This isolates skill optimization from changes to the execution model.
  • Validated updates: Every candidate skill must improve on a selection split before acceptance, preventing unvalidated reflection from accumulating.Selection-split evaluation serves as the acceptance check for candidate edits.
  • Evidence aggregation: Minibatch analyses are merged hierarchically so final edits reflect recurring evidence rather than single examples.The hierarchy aggregates evidence before producing the final edit.
  • Budgeted updates: The edit budget acts as a learning-rate analogue, permitting larger early changes and smaller later changes.The budget controls edit magnitude across training.
Loading 2605.23904v2…