Can skill documents be optimized like neural network weights?
Can natural-language skill documents be treated as trainable parameters and improved through iterative optimization with validation gating, similar to how model weights are tuned in deep learning?
SkillOpt's move is to treat the skill document — a natural-language artifact packaging procedures, heuristics, tool policies, and failure modes — as the external state of a frozen agent, trainable with the same discipline that makes weight-space optimization reproducible. A separate optimizer model turns scored rollouts into structured add/delete/replace edits on a single document, and an edit is accepted only when it strictly improves a held-out validation score. The deep-learning analogy is operational: rollout batch size controls gradient noise, a textual learning rate controls step size, the held-out gate is validation, and an epoch-wise slow/meta update acts as momentum.
This matters because it makes procedural adaptation available for closed frontier models where weight tuning is impossible and prompts are brittle. The skill, not the weights, becomes the recurring object of adaptation — and crucially the deployed artifact (a compact 300–2,000 token best_skill.md) adds zero inference-time model calls, unlike methods that pay an optimization tax at deployment. Across six benchmarks, seven models, and three harnesses, SkillOpt is best-or-tied on all 52 cells and the learned skills transfer (a Codex-trained spreadsheet skill gains +59.7 points moving to Claude Code).
The counterpoint is that the analogy is partial — there is no true gradient, the optimizer is itself an LLM that can hallucinate edits, and "validation" is a held-out task split that can be gamed. But the held-out gate is precisely what disciplines this: harmful proposals are rejected rather than accumulated. Therefore the insight stands — skill text is a trainable parameter space, and the optimizer-plus-validation loop is what makes self-improvement reproducible rather than drift.
— "SkillOpt: Executive Strategy for Self-Evolving Agent Skills", https://arxiv.org/abs/2605.23904
Related concepts in this collection
-
Does constraining edits help agents improve their own skills?
When agents rewrite their own instructions, does freedom to edit lead to better learning, or do safeguards like edit budgets and memory of failures produce more stable improvement?
extends: the same SkillOpt result seen from the control side; the held-out gate here is precisely the bounding mechanism that note argues for over free rewriting
-
Can a separate trained curator improve skill libraries better than frozen agents?
Explores whether decoupling skill curation from agent execution enables better long-term learning of what skills to keep, delete, or refine. Matters because manual curation doesn't scale and heuristic approaches lack feedback.
synthesizes: both adopt the frozen-executor / trainable-skill split, but reach it from different angles — RL curation policy vs. text-space optimizer with validation gating
-
Can frozen language models continually improve through memory structure alone?
If agents can't update parameters, what form of textual memory lets them keep learning across trials and transfer to new tasks without retraining?
exemplifies: another frozen-model-plus-editable-text-state design, generalizing that the recurring object of adaptation is natural-language artifacts not weights
-
Why do LLM agents ignore condensed experience summaries?
LLM agents faithfully learn from raw experience but systematically disregard condensed summaries of the same experience. This study investigates whether the problem lies in how summaries are made, how models process them, or whether models simply don't need them.
grounds: a risk to the optimizer's edits — if skill documents are condensed experience that agents under-use, the held-out gate is what keeps edits faithful rather than ignored
Click a node to walk · click center to open · click Open in graph to see this note in the full knowledge graph
Original note title
the agent skill document can be trained like model weights using a text-space optimizer with held-out validation gating