SkillOpt: waarom je AI-agents voortaan traint als neurale netwerken

Laatst zat ik met een klant om tafel die Claude Code had uitgerold naar z'n hele developmentteam. De vraag was niet "werkt het?" — dat deed het. De vraag was: "Hoe weten we dat de skills die we aan onze agents meegeven niet langzaam verslechteren?"

Die vraag vat precies het probleem samen. Skills zijn vandaag statische tekstbestanden. Iemand schrijft een SKILL.md, test het een paar keer, en hoopt dat het blijft werken. Er is geen mechanisme om te valideren of een aanpassing aan die skill daadwerkelijk beter is. Er is geen audit trail. Er is geen rollback.

Microsoft Research heeft daar nu een antwoord op. Hun SkillOpt-paper (22 mei 2026, arXiv:2605.23904) introduceert een text-space optimizer die agent-skills traint met exact dezelfde discipline die we al decennia toepassen op neurale netwerken: epochs, batches, learning rates, en validation gates. Niet als metafoor — operationeel.

Hoe het werkt

Een apart optimizer-model analyseert de trajecten van een frozen target-agent: welke taken gingen goed, welke fout? Het stelt add/delete/replace-edits voor op een skill-document, maar accepteert die alleen als de aangepaste skill strikt beter scoort op een held-out validatieset. De output is een compact best_skill.md van 300 tot 2.000 tokens.

De cijfers liegen er niet om: SkillOpt is best of tied-best op alle 52 geteste combinaties van model, benchmark en harness. GPT-5.5 gaat gemiddeld 23,5 procentpunt omhoog in direct chat, 24,8 in een Codex-loop, en 19,1 in Claude Code. Een op GPT-5.4 getrainde SpreadsheetBench-skill verbetert elk kleiner GPT-model. Een Codex-getrainde skill transfereert naar Claude Code met een winst van bijna 60 punten.

Wat me hieraan opvalt is niet de benchmarkwinst — indrukwekkend, maar benchmarks zijn benchmarks. Het is de architectuur van het ding.

De DL-analogie is geen marketing

De meeste AI-tools gebruiken termen als "learning rate" als decoratie. SkillOpt meent het. De pipeline spiegelt een DL-training loop één-op-één:

• Rollout = forward pass. De agent voert taken uit met de huidige skill, trajecten worden gescoord.

• Reflection = backward pass. De optimizer analyseert mislukte trajecten in minibatches en stelt gestructureerde edits voor. Niet op basis van één anekdotische fout — op basis van terugkerende patronen.

• Validation gate = early stopping. Een edit wordt alleen geaccepteerd als die de score op een held-out set verbetert. Geaccepteerde edits blijven; afgewezen edits gaan naar een buffer als negatieve feedback voor volgende stappen.

• Learning rate = gradient clipping. Een textual budget begrenst hoeveel edits per stap worden doorgevoerd. Te agressief? De learning rate scheduler — cosine, linear of constant — remt af.

• Slow/meta update = momentum. Aan het eind van elke epoch vergelijkt het systeem de nieuwe skill met de vorige op dezelfde samples. Verbeteringen, regressies, hardnekkige fouten en stabiele successen worden gecategoriseerd. Die longitudinale analyse wordt als guidance in de skill geïnjecteerd. Dit voorkomt dat eerdere verbeteringen verloren gaan — het equivalent van catastrophic forgetting in neurale netwerken.

Deze opzet wijkt af van wat we tot nu toe gewend zijn. Prompt-"optimalisatie" tools als TextGrad of GEPA muteren prompts op basis van feedback zonder validatiegate. Self-improvement loops van agents accumuleren fouten omdat er geen acceptatiecriterium is. SkillOpt zegt: "Nee, je bewijst eerst dat het beter is."

De governance-implicatie

Een klant die onder BIO2 valt moet kunnen aantonen dat z'n AI-systemen onder controlled change management vallen. Met SkillOpt heb je dat bewijs: een best_skill.md met een traceerbare historie van edits, elke edit gekoppeld aan een validatiescore op een held-out set, met een clear accept/reject-beslissing.

Dat is het verschil tussen "we hebben ChatGPT een prompt gegeven" en "we hebben een gevalideerde skill in productie." Voor een auditor is dat het verschil tussen een bevinding en een vinkje.

De skills zelf zijn compacte tekstbestanden. Je kunt ze reviewen, diffen, signen, versioneren in Git, en deployen via een pull request. Afgewezen edits blijven bewaard als documentatie van wat niet werkte. Er is geen extra inference-cost in productie — de skill is gewoon een prompt, geen modelgewicht.

Wat SkillOpt niet is

SkillOpt is geen productieruntime. De repo is alpha-kwaliteit, de dependencies zijn beperkt maar niet gehard, en de evaluator-kwaliteit bepaalt alles. Als je evaluator oppervlakkig is, optimaliseer je richting oppervlakkige compliance. Als je testset lekt, krijg je benchmark gaming. Als je security policy incompleet is, leert de skill mogelijk gevaarlijk maar score-optimaal gedrag.

Daarom is het ook geen vervanging voor finetuning. LoRA en QLoRA veranderen modelgewichten; SkillOpt verandert het procedureel geheugen. Voor compliant deployment is dat juist een voordeel — je hoeft geen model governance-traject te openen voor een skill-aanpassing.

Het is ook geen autonome self-improving agent-laag. Blind een optimizer skills laten muteren in productie zonder menselijke review is vragen om problemen. De output van SkillOpt hoort altijd via een release gate te gaan: PR, diff, security check, reviewer approval.

Waar ik het voor zou inzetten

Voor wie dit concreet wil testen: begin niet met generieke "AI-assistent"-skills. Start met een smalle, meetbare skill. Secure code review is ideaal — je hebt objectieve evaluatiecriteria (CWE-mapping, false positives, severity-classificatie), en een foute skill levert direct zichtbare schade op die je kunt meten.

Mijn aanpak zou zijn:

1. Maak één baseline skill voor secure code review
2. Bouw een dataset van 50 tot 150 taken met bekende kwetsbaarheden, false-positive traps en "niet flaggen"-voorbeelden, strikt gesplitst in train, validation en test
3. Laat SkillOpt optimaliseren, maar evalueer de output op security coverage, false positives, hallucinated vulnerabilities en policy compliance
4. Promoot best_skill.md alleen via pull request met reviewer sign-off
5. Versioneer skills als release-artefacten

Dit is in essentie een CI/CD-pipeline voor agentgedrag — niet "we maken prompts slimmer", maar "we beheren agentprocedures als gevalideerde, auditable, releasebare configuratie."

SkillOpt past in een grotere beweging die ik al langer zie: van modelkwaliteit naar execution assurance. We stoppen met vragen "welk model is het beste?" en beginnen met vragen "hoe valideren we dat deze agent zich gedraagt zoals bedoeld?" Daar hoort een skill-optimalisatie-framework bij dat resultaten kan bewijzen. SkillOpt levert dat bewijs.

---

SkillOpt is open-source (MIT) op github.com/microsoft/SkillOpt. De paper staat op arXiv:2605.23904.

DjimIT adviseert organisaties over het veilig en compliant inzetten van AI-agents. Meer weten? Plan een consult.