Optimizing Agent Skills Like Weights: A Close Reading of SkillOpt

Introduction

The dominant story of the past few years has been about scaling model weights. But as frontier language models increasingly operate as agents, with tools, files, verifiers, and multi-step execution loops, a second adaptation surface has quietly become just as important: the procedures the agent follows. How it gathers evidence, which tools it calls and when, what conventions it respects, how it formats output. These procedures are usually packaged as a skill, a portable natural-language document that a frozen agent reads before acting.

The trouble is that almost nobody trains these documents in any principled sense. They are hand-written, generated in a single shot from an LLM, or evolved through loosely supervised self-revision that may or may not improve over the starting point. The paper SkillOpt: Executive Strategy for Self-Evolving Agent Skills (Yang et al., 2026) makes a clean argument: if the skill is the recurring object of adaptation, it should be optimized with the same discipline we apply to weight-space optimization. The result is, to the authors' knowledge, the first systematic and controllable text-space optimizer for agent skills.

The core idea: a deep-learning optimizer, in text

SkillOpt builds an explicit analogy between gradient descent and skill editing, and the authors are careful to insist the analogy is operational rather than decorative. The mapping is worth stating precisely:

• Parameters become the skill document itself, treated as the external state of a frozen agent.
• Gradients become trajectory-derived edit directions. The target model runs tasks under a current skill, and a separate frontier optimizer model converts scored rollouts into structured add/delete/replace edits.
• Learning rate becomes a textual edit budget that bounds how far a new skill version can move from the previous one.
• Validation becomes a held-out selection gate. An edit is accepted only if it strictly improves the held-out score.
• Momentum is approximated by an epoch-wise slow/meta update that carries stable editing directions across epochs.
• Batch size maps to rollout and reflection batch sizes, controlling the noise in the evidence behind each edit.

This is more than a naming exercise. The reason it matters is stability. If consecutive skill revisions jump too far, or in inconsistent directions, the optimization history loses meaning. The optimizer model can no longer reason about what helped, what failed, and what should be preserved, because each version is essentially a new document. By keeping updates bounded and validation-gated, each revision stays close to its predecessor, so rejected edits (retained as negative feedback) and previously accepted edits remain a usable training signal.

The deployed output is a single best_skill.md of roughly 300 to 2,000 tokens. Critically, deployment adds zero inference-time model calls. The optimizer model is used only during training. At runtime the frozen agent simply reads a slightly longer prompt. This is the property that separates SkillOpt from approaches that bolt extra reasoning models onto the inference path.

What the numbers actually show

The evaluation is unusually broad for this kind of work: six benchmarks (QA, spreadsheets, documents, math, embodied decision making), seven target models from frontier GPT down to small Qwen, and three execution harnesses (direct chat, Codex, Claude Code). That produces 52 (model, benchmark, harness) cells, and SkillOpt is reported as best or tied-best on all 52.

The headline numbers on GPT-5.5 in direct chat give a sense of scale:

• SearchQA: 77.7 to 87.3
• SpreadsheetBench: 41.8 to 80.7
• OfficeQA: 33.1 to 72.1
• DocVQA: 78.8 to 91.2
• LiveMathematicianBench: 37.6 to 66.9
• ALFWorld: 83.6 to 95.5

That is a +23.5 point average gain over no skill, plus a +5.4 point margin over the strongest per-cell baseline drawn from human-written, one-shot LLM, Trace2Skill, TextGrad, GEPA, and EvoSkill. Inside agentic loops the gains hold: +24.8 points inside Codex and +19.1 inside Claude Code, beating EvoSkill by +14.0 and +3.2 respectively.

Two observations about these results. First, the largest absolute gains appear on tasks with heavy procedural structure (SpreadsheetBench at +38.9, OfficeQA at +39.0), exactly where you would expect codifying a workflow to pay off. Tasks that are more about raw knowledge or perception (SearchQA, DocVQA) show smaller but still real gains. This pattern is informative: skills are most valuable where success depends on how you operate, not what you know.

Second, the transfer results are arguably the most consequential part of the paper for practitioners. A SpreadsheetBench skill trained on GPT-5.4 improves every smaller GPT variant tested. A Codex-trained spreadsheet skill transfers to Claude Code with a +59.7 point gain. An OlympiadBench skill yields positive gains on Omni-MATH. This suggests the optimized artifact is capturing something closer to a genuine domain procedure than a model-specific prompt hack. A skill can be optimized once, audited as plain text, and reused across related models, harnesses, and tasks. That auditability matters: unlike fine-tuned weights, a skill document can be read, reviewed, and edited by a human before deployment.

My take: the missing momentum term

The tweet I posted flagged what I think is the most interesting open thread, and it is worth expanding. SkillOpt's analogy is deliberately conservative. Rejected edits become negative feedback, telling the optimizer what not to do, but there is no explicit notion of accumulated direction across epochs. The slow/meta update plays a momentum-like role, but it is described as carrying stable editing directions rather than as a true velocity term over accepted edit vectors.

If skill space genuinely behaves like a loss landscape, then the failure mode we should expect is plateaus: regions where no single bounded edit clears the strict held-out gate, even though a sequence of edits would. A strict improvement gate is essentially greedy hill-climbing with a step-size limit. Greedy methods stall at local optima. The classic remedy in weight-space optimization is momentum, which accumulates a direction and lets the optimizer push through flat regions and small adverse gradients.

A textual momentum term would mean maintaining a representation of recent accepted edit directions (which sections of the skill keep getting expanded, which heuristics keep getting refined) and biasing the optimizer model toward continuing in that direction even when a single step does not immediately improve validation. One could even relax the strict gate into something like a temporary tolerance budget, analogous to allowing a brief loss increase during a momentum step, with rollback if the cumulative trajectory fails to recover. This is speculative, but it follows directly from taking the optimizer analogy seriously rather than treating it as marketing.

A related inference: the strict gate is probably doing a lot of the stabilization work that prevents the well-known degeneration of self-revising prompt systems, where each iteration drifts and the document bloats. The 300 to 2,000 token ceiling and the add/delete/replace structure act like an implicit regularizer. I would want to see ablations isolating how much of the gain comes from the gate alone versus the bounded edit structure.

Limitations worth naming

The method requires a strong frontier optimizer model during training, which is a real cost and a dependency that the deployment-time zero-call property partly obscures. The held-out gate also presupposes a reliable, cheap-to-evaluate validation metric; for open-ended generation tasks without crisp scoring, the gate becomes noisy and the whole optimizer loop weakens. Finally, all transfer results are between related settings. Whether a skill optimized for spreadsheets degrades gracefully or harmfully when applied to an unrelated domain is not something a strict in-domain gate can protect against.

Conclusion

SkillOpt's contribution is conceptual as much as empirical: it reframes skill editing as controllable domain adaptation, with a document as the parameter, trajectories as gradients, a textual learning rate as step size, and a held-out gate as validation. The breadth of the evaluation and the transfer results make a convincing case that this is the right framing. The open questions are the ones the analogy itself raises. If skills live in something like a loss landscape, then the entire toolkit that made stochastic optimization robust, momentum, adaptive learning rates, scheduling, warm restarts, is available to borrow. SkillOpt has built the first stable optimizer. The interesting work now is finding which of those tricks transfer into text space, and which break in ways that only natural-language parameters can.