Can skill documents be optimized like neural network weights?
Explores whether natural-language skill artifacts—packaging procedures, heuristics, and policies—can be systematically improved through iterative editing and validation, similar to how gradient descent refines model parameters.
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 read this note 24
This note is a source for these research framings, grouped by the broader line of inquiry each explores. Scan the bold lines of inquiry; follow any specific question forward.
Can verification capability keep pace with AI generation speed? What are the trade-offs between memory capacity and continuous task learning? Do language models learn underlying linguistic structure or merely surface patterns?- 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?
- Why does embedding research tools in coding assistants improve reliability?
- How do agents retrieve and compose skills from hierarchical multimodal wikis?
- How do skill libraries from human resources compare to hand-written skill libraries?
- How does source-blind reconstruction verify that extracted skills are specific enough to be reusable?
- What metadata properties make code-derived skills auditable and comparable to their original source?
- Can text-space optimization and audit governance coexist in a single skill lifecycle?
- Does held-out validation prevent skill document edits from drifting or accumulating harm?
- How does controlling skill text edits prevent cascading failures in self-improvement?
- Does editing AI drafts build skill or replace skill-building practice?
- Do weight-space skills lose detail compared to textual skill descriptions?
- Can RL-trained policies outperform text-space optimizers for evolving skill repositories?
- Why do generic skill descriptions evolve into execution-oriented ones?
- Can empirical testing replace semantic retrieval for finding useful skills?
Related concepts in this collection 5
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 make skill learning more stable?
Self-improving agents often rewrite their own instructions freely, but what if bounded editing with memory of failures actually produces more reliable skill improvement than unconstrained revision?
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
-
Can optimizers learn to evade guardrails through repeated verdicts?
Guardrails are designed to be unarguable, but an optimizer observing thousands of verdicts may learn their boundaries like a black-box function. The excerpt leaves unclear what feedback the proposer receives from each check.
asks of a held-out gate what this note's counterpoint concedes ("validation" can be gamed): whether a proposer that receives accept-or-reject verdicts learns the gate's shape, against a partition hidden from it
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
- Compositional Skill Routing for LLM Agents: Decompose, Retrieve, and Compose
- LatentSkill: From In-Context Textual Skills to In-Weight Latent Skills for LLM Agents
- Demystifying Agent Skills: Why They Work-Until They Don't
- An Emulator for Fine-Tuning Large Language Models using Small Language Models
- FLASK: Fine-grained Language Model Evaluation based on Alignment Skill Sets
- MUSE-Autoskill: Self-Evolving Agents via Skill Creation, Memory, Management, and Evaluation
- Harness Updating Is Not Harness Benefit: Disentangling Evolution Capabilities in Self-Evolving LLM Agents
Original note title
the agent skill document can be trained like model weights using a text-space optimizer with held-out validation gating