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.
Inquiring lines that use this note as a source 5
This note is a source for these synthesized inquiries. Follow a line forward into its question, or open it to trace back to all of its sources.
- How does validation skill replace production skill in AI systems?
- How do trained weights differ from a stored library or text?
- How tight should a textual learning rate be before it prevents skill escape?
- How should skill libraries coordinate with gradient-based weight optimization?
- How do skills authored in-loop validate faster than offline generated skills?
Related concepts in this collection 4
This note in its neighbourhood — explore the map, then jump to a related concept in the list below.
Click a node to walk · click center to open · click Open in graph to see this note in the full knowledge graph
-
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
Related papers in this collection 8
Papers most semantically related to this note, ranked by cosine similarity in the embedding space.
- SkillOpt: Executive Strategy for Self-Evolving Agent Skills
- An Emulator for Fine-Tuning Large Language Models using Small Language Models
- Instruction-tuned Language Models are Better Knowledge Learners
- Extreme Multi-Label Skill Extraction Training using Large Language Models
- FLASK: Fine-grained Language Model Evaluation based on Alignment Skill Sets
- A Decomposition Perspective to Long-context Reasoning for LLMs
- How new data permeates LLM knowledge and how to dilute it
- Learning, Fast and Slow: Towards LLMs That Adapt Continually
Original note title
the agent skill document can be trained like model weights using a text-space optimizer with held-out validation gating