title: "The Skill You Write for Your Agent Might Be Why It Gets Dumber Over Time" description: "Microsoft's SkillOpt Trains Skills Like Parameters: The Paradigm Shift and Sobering Costs Behind 11k Stars" tags: ["SkillOpt", "AI Agent", "Microsoft", "Skill Optimization", "Self-Evolution"]
The Skill You Write for Your Agent Might Be Why It Gets Dumber Over Time
Have you ever had this experience—carefully writing a Skill for your AI Agent, it runs perfectly on day one, starts glitching by day three, and by day five you have to manually revert to the first version?
Even worse, after your edits, you have no idea whether you improved it or made it worse—there's no validation standard, so you just rely on gut feeling.
Skill maintenance is becoming the stealthiest bottleneck for AI Agent deployment.
Microsoft's SkillOpt offers a radical answer: since Skills affect Agent performance, why not train Skills themselves like model parameters?
This project earned 11k stars in two months, hiding a paradigm shift—from "humans write Skills" to "training Skills".
What Happens When You Treat Skills as Parameters
SkillOpt's core idea is to transplant the optimization paradigm of deep learning entirely into the text space.
You train neural networks with epochs, batch size, learning rate, and validation gate—SkillOpt has all of them, except what's optimized isn't floating-point weights, but a Markdown document.
The entire training loop looks like this:
Rollout → Reflect → Aggregate → Select → Update → Evaluate (Validation Gate)
- Use the current Skill to have the Agent run a batch of tasks, collecting scored trajectories
- Extract reflections from successful and failed trajectories, aggregating them into "gradient signals"
- The optimizer model applies add/delete/replace edits to the Skill document based on the gradient signals
- The edit magnitude is clipped using clip, and the learning rate is scheduled via a scheduler
- The most critical step: Candidate edits are only accepted if they strictly improve scores on the validation set
The final product is a best_skill.md, typically 300–2000 tokens, with zero additional inference calls during deployment.
This isn't a metaphor—it's engineering implementation. Under skillopt/optimizer/ you'll find scheduler.py, lr_autonomous.py, clip.py, slow_update.py, almost mirroring PyTorch's optimizer modules one-to-one.
Work by Day, Evolve by Night: SkillOpt-Sleep
The SkillOpt-Sleep added in v0.2.0 is the most impressive part of this project.
Its operation closely resembles the human sleep-learning mechanism:
- Harvest: Gather historical sessions from Agents like Codex, Claude Code, etc.
- Mine: Extract repeated tasks, common failures, reusable workflows from trajectories
- Dream: Generate dream rollouts for data augmentation
- Replay: Experience replay to validate modification suggestions
- Consolidate: Only changes that pass the validation gate are consolidated into the Skill
The entire process is fully automated, but not auto-accepted—candidate changes are stored temporarily for user review. You can use Git to manage every Skill change: review, rollback, version comparison—just like code review.
This is far more reliable than "letting the Agent summarize its own experience." Self-summarization lacks validation standards, but SkillOpt-Sleep keeps the validation gate at every step.
Total Victory in 52 Evaluation Units, But at What Cost
The paper ran 52 evaluation units across 6 benchmarks, 7 target models, and 3 execution tools—all optimal or tied for optimal.
On GPT-5.5, the average accuracy improvement over no Skill: +23.5pp for direct chat, +24.8pp for Codex Agent loop, +19.1pp for Claude Code.
But behind these numbers, there are sobering costs:
1. "Gradient descent" is an analogy, not a mathematical equivalence
A deep reflection article on Maimai put it plainly: there is a fundamental difference between optimization in the text-symbol space and gradient descent in the parameter space of deep learning. SkillOpt draws inspiration from gradient descent, not strict mathematical isomorphism. There is no continuous gradient in text space; "learning rate" and "momentum" here are heuristic parameters, not theoretically guaranteed optimization quantities.
2. Skill drift
The probabilistic behavior of large models means the same Skill that works in the morning may fail in the afternoon. Some developers have reported that "patching the probabilistic behavior of large models only makes Skills more chaotic."
3. Only suitable for tasks that can be scored
SkillOpt's hard prerequisite: tasks must be executable, results must be scorable, and samples must be separable. It's not suitable for open-ended writing, aesthetic judgment, or product strategy—these scenarios have no objective scoring standard, rendering the validation gate useless.
4. Training requires running two models simultaneously
A frozen target model executes tasks, while an optimizer model proposes edits. A typical configuration is GPT-5.4-mini + GPT-5.5, costing $1–5/skill—not expensive, but not zero.
Four Competitors Emerged in the Same Week: Skill Optimization Has Become Its Own Domain
SkillOpt is not alone. In the same week of May 2026, several similar frameworks appeared densely on arXiv:
| Framework | Source | Differentiation |
|---|---|---|
| SkillGrad | Penn State University | Introduces momentum agent to accumulate cross-batch diagnosis patterns |
| MUSE-Autoskill | arXiv | Full lifecycle management of Skills, not just optimization |
| SIA | arXiv | Optimizes both harness and weights |
| MAA | arXiv | Reduces token consumption in the optimization phase by 75% |
Plus TextGrad, EvoSkill, Trace2Skill directly compared in the SkillOpt paper—this field now has nearly 10 active frameworks.
Notable positioning difference: DSPy is complementary, not competitive—DSPy optimizes program structure, SkillOpt optimizes skill content; they can be used together.
One interesting detail: the first-author team of SkillOpt is a joint research between Microsoft Research + Shanghai Jiao Tong University + Fudan University + Tongji University. The corresponding author is from Shanghai Jiao Tong University. Chinese universities contributed not as assistants but as multiple co-first authors.
Trend Judgment: Skills Are Transforming from "Config Files" to "Trainable Parameters"
The true significance of SkillOpt lies not in any specific feature, but in redefining the nature of Skills:
Past: Skills are static configuration files, written and maintained by humans—changes are made without knowing if they're good. Present: Skills are trainable text parameters, with epochs, validation sets, and version management.
This creates an interesting contrast with fine-tuning:
| Dimension | Fine-tuning | SkillOpt |
|---|---|---|
| Optimization target | Model weights | Skill document |
| Cost | $100–1000+ | $1–5 |
| Readability | Black box | Readable and reviewable |
| Rollback capability | Requires storing checkpoints | Git version management |
| Cross-model transfer | Requires retraining | Direct copy of .md file |
| Use case | General capability enhancement | Specific task optimization |
Fine-tuning changes the model's "muscle memory," while SkillOpt changes the model's "operation manual." They don't conflict, but SkillOpt's cost and transparency advantages are obvious.
When should you use SkillOpt? Your task meets three conditions: repetitive, results are scorable, and you have enough samples. If so, for $1–5 you can upgrade your Agent's Skill from "usable" to "excellent."
When should you not use it? When tasks differ each time or there's no objective scoring standard. In that case, the validation gate fails, and SkillOpt degrades into expensive self-summarization.
Project address: https://github.com/microsoft/SkillOpt
Paper: arXiv:2605.23904
Installation: pip install skillopt
暂无评论。