SkillOpt

SkillOpt är ett ramverk med öppen källkod från Microsoft Research för att förbättra färdigheter hos AI-agenter utan att ändra språkmodellens parametrar. I stället för traditionell finjustering optimerar SkillOpt ett separat textdokument med instruktioner, regler och arbetsmetoder som agenten använder när den löser uppgifter.

Projektets grundidé är att behandla detta färdighetsdokument som om det vore modellens träningsbara tillstånd. Dokumentet förbättras stegvis genom körningar, analys av resultat, begränsade textredigeringar och validering mot separat testdata.

SkillOpt kan beskrivas som en optimerare i textrymden, på engelska text-space optimizer. Den underliggande språkmodellen förblir fryst under hela processen.

En vanlig AI-agent styrs ofta med hjälp av en systemprompt, instruktioner eller manuellt skrivna arbetsflöden. Sådana instruktioner kan vara effektiva, men de är ofta statiska och svåra att förbättra systematiskt.

SkillOpt gör i stället instruktionerna till ett träningsbart dokument. Dokumentet kan exempelvis innehålla:

• regler för hur information ska sökas,
• metoder för att använda verktyg,
• strategier för att kontrollera svar,
• vanliga fel som ska undvikas,
• instruktioner för hur resultat ska formateras,
• domänspecifika arbetsmetoder.

Agenten genomför uppgifter med den aktuella versionen av dokumentet. Resultaten analyseras därefter av en separat optimerarmodell, som föreslår förbättringar.

En föreslagen förändring behålls endast om den ger ett bättre resultat på en separat valideringsmängd.

SkillOpt skiljer mellan två huvudsakliga roller.

Målmodellen är den AI-modell eller agent som ska förbättras. Den utför uppgifter med hjälp av det aktuella färdighetsdokumentet.

Målmodellens parametrar ändras inte. Det är därför möjligt att förbättra agentens arbetssätt utan att genomföra traditionell modellträning.

Optimerarmodellen analyserar målmodellens körningar. Den granskar både lyckade och misslyckade försök och föreslår förändringar i färdighetsdokumentet.

Optimerarmodellen kan bland annat föreslå att:

• en ny regel läggs till,
• en felaktig regel tas bort,
• en otydlig instruktion ersätts,
• liknande regler slås samman,
• en befintlig metod görs mer specifik.

Målmodellen och optimerarmodellen kan vara samma språkmodell, men en starkare optimerarmodell kan i vissa fall ge större förbättringar.

SkillOpts träningsloop består av sex huvudsakliga steg.

Målmodellen utför ett antal uppgifter med det aktuella färdighetsdokumentet. Varje körning kan innehålla meddelanden, verktygsanrop, mellanresultat, verifieringsdata och slutpoäng.

Dessa körningar kallas ofta rollouts eller trajektorier.

Optimerarmodellen analyserar körningarna och försöker identifiera återkommande mönster.

Misslyckade körningar används för att upptäcka:

• saknade instruktioner,
• olämpliga strategier,
• felaktiga antaganden,
• problem med verktygsanvändning,
• bristande kontroll av resultat.

Lyckade körningar kan samtidigt användas för att bevara beteenden som redan fungerar bra.

Förslag som behandlar samma problem grupperas och slås samman. Syftet är att minska upprepningar och skapa mer generella instruktioner.

Förslagen rangordnas efter förväntad nytta. Endast ett begränsat antal redigeringar får genomföras under varje optimeringssteg.

Denna begränsning fungerar som en textbaserad motsvarighet till inlärningshastigheten vid träning av neurala nätverk.

De valda ändringarna appliceras på färdighetsdokumentet. Resultatet blir en ny kandidatversion av dokumentet.

SkillOpt stöder huvudsakligen tre typer av förändringar:

• tillägg,
• borttagning,
• ersättning.

Kandidatversionen testas på en separat valideringsmängd. Den accepteras endast om resultatet förbättras jämfört med den nuvarande versionen.

Denna mekanism kallas en valideringsgrind, på engelska validation gate.

Valideringsgrinden är en central del av SkillOpt. Den förhindrar att varje automatiskt genererat förbättringsförslag omedelbart blir permanent.

En kandidat kan få något av följande utfall:

• accept_new_best – kandidaten är bättre än både den aktuella och den hittills bästa versionen,
• accept – kandidaten är bättre än den aktuella versionen men inte bättre än den bästa tidigare versionen,
• reject – kandidaten förbättrar inte resultatet och förkastas.

SkillOpt kan använda flera typer av utvärderingsmått:

• hard – ett diskret mått, exempelvis exakt rätt eller fel,
• soft – ett kontinuerligt mått som kan ge delpoäng,
• mixed – en viktad kombination av hårda och mjuka resultat.

Valideringen gör processen mer kontrollerad än metoder där en agent tillåts skriva om sina egna instruktioner utan extern kontroll.

SkillOpt är utformat så att flera begrepp från träning av neurala nätverk får en motsvarighet i textoptimeringen.

Liknelsen innebär inte att SkillOpt beräknar matematiska gradienter. Förändringarna föreslås och bedöms i naturligt språk.

Parametern optimizer.learning_rate anger hur många redigeringsförslag som högst får appliceras under ett optimeringssteg.

En låg inlärningshastighet ger små och försiktiga förändringar. En hög inlärningshastighet kan ge snabbare utveckling, men ökar risken för att fungerande instruktioner skrivs över.

SkillOpt stöder bland annat följande scheman:

• konstant inlärningshastighet,
• linjärt avtagande inlärningshastighet,
• cosinusbaserat schema,
• autonomt valt redigeringsutrymme.

Begränsade uppdateringar är viktiga eftersom stora omskrivningar kan introducera nya fel samtidigt som tidigare fungerande beteenden försvinner.

SkillOpt har en mekanism som kallas långsam uppdatering, på engelska slow update. Den genomförs mellan träningsepoker och fungerar ungefär som momentum i traditionell maskininlärning.

Systemet jämför en äldre och en nyare version av färdigheten på samma uppgifter. Resultaten delas exempelvis in i:

• förbättrade uppgifter,
• försämrade uppgifter,
• kvarstående misslyckanden,
• stabila framgångar.

Optimerarmodellen skapar därefter mer övergripande vägledning. Denna vägledning placeras i en skyddad del av färdighetsdokumentet som vanliga stegvisa redigeringar inte får ändra.

Syftet är att minska risken för att agenten glömmer användbara strategier mellan olika epoker.

SkillOpt kan även skapa en metafärdighet, på engelska meta skill. Detta är ett internt minne för optimerarmodellen.

Metafärdigheten beskriver bland annat:

• vilka typer av ändringar som fungerade,
• vilka ändringar som försämrade resultatet,
• vilka problem som återkommer,
• hur framtida förbättringsförslag bör prioriteras.

Detta minne används under kommande epoker, men inkluderas inte i den färdighet som distribueras till målmodellen.

Det viktigaste resultatet från en SkillOpt-körning är normalt filen:

best_skill.md

Filen innehåller den bäst validerade versionen av färdighetsdokumentet. Enligt projektets beskrivning är den vanligtvis relativt kompakt och kan användas direkt tillsammans med målmodellen.

Vid körning i produktion behövs normalt inte:

• optimerarmodellen,
• träningshistoriken,
• reflektionerna,
• förkastade redigeringar,
• metafärdigheten.

Det innebär att optimeringen inte behöver orsaka ytterligare modellanrop när den färdiga färdigheten används. Målmodellen får endast det slutliga dokumentet som instruktion.

SkillOpt-Sleep är en kompletterande funktion för återkommande förbättring av lokala kodagenter. Funktionen introducerades i SkillOpt version 0.2.0.

Tanken är att agentens tidigare arbetssessioner analyseras under en separat offlineprocess, exempelvis nattetid. Processen omfattar fyra övergripande steg:

• insamling av tidigare erfarenheter,
• identifiering av återkommande mönster,
• återuppspelning av representativa uppgifter,
• konsolidering av validerade färdigheter.

SkillOpt-Sleep kan även använda erfarenhetsåterspelning, syntetiska körningar och långsiktigt minne. Uppdateringar måste fortfarande passera en separat valideringsgrind innan de accepteras.

Funktionen distribueras med kommandoradsverktyget skillopt-sleep och är avsedd för integration med olika agentmiljöer och kodverktyg.

SkillOpt levereras med stöd för sex typer av testmiljöer.

Varje testmiljö innehåller normalt komponenter för:

• datainläsning,
• agentkörningar,
• poängsättning,
• reflektion,
• en inledande färdighet.

Egna testmiljöer kan skapas genom att implementera motsvarande komponenter.

SkillOpt har utbytbara modellbakändar och kan anslutas till flera typer av språkmodeller och agentmiljöer.

Projektets dokumentation beskriver bland annat stöd för:

• Azure OpenAI,
• OpenAI-kompatibla gränssnitt,
• Anthropic Claude,
• lokala Qwen-modeller via vLLM,
• Codex-baserade exekveringsmiljöer,
• Claude Code.

Version 0.2.0 utökade även projektet med integrationsskal för fler agentverktyg.

Optimerarmodellen och målmodellen kan använda olika leverantörer, modeller eller tekniska bakändar.

Enligt projektets forskningsrapport utvärderades SkillOpt med:

• sex testmiljöer,
• sju målmodeller,
• flera exekveringsmiljöer,
• både direkta chattkörningar och agentbaserade arbetsflöden.

Microsofts projektsida uppger att SkillOpt nådde bäst eller delat bäst resultat i samtliga 52 utvärderade kombinationer av modell, testmiljö och körmiljö.

För GPT-5.5 rapporteras en genomsnittlig förbättring på 23,5 procentenheter jämfört med körning utan färdighet i direkt chatt. Projektet rapporterar även förbättringar i agentmiljöer baserade på Codex och Claude Code.

Resultaten bör tolkas utifrån de modeller, datauppdelningar, poängsystem och konfigurationer som användes i studien. De innebär inte att samma förbättring automatiskt uppstår för alla typer av agenter och uppgifter.

En viktig egenskap hos SkillOpt är att den färdiga textfärdigheten kan återanvändas.

Projektet har undersökt överföring:

• mellan olika modellstorlekar,
• mellan olika agentramverk,
• mellan närliggande testmiljöer,
• från en träningsmiljö till en annan körmiljö.

Eftersom färdigheten består av naturligt språk är den inte tekniskt bunden till en viss modellparameteruppsättning. Överförbarheten beror dock på att den mottagande modellen kan förstå och följa instruktionerna.

SkillOpt kräver Python 3.10 eller senare. Paketet kan installeras från Python Package Index:

pip install skillopt

Valfria komponenter kan installeras separat:

pip install "skillopt[alfworld]"
pip install "skillopt[webui]"
pip install "skillopt[claude]"

För utveckling kan projektet installeras direkt från källkoden:

git clone https://github.com/microsoft/SkillOpt.git
cd SkillOpt
pip install -e .

Installationen kan kontrolleras med:

python -c "import skillopt; print('SkillOpt ready!')"

Användaren behöver även åtkomstuppgifter till minst en kompatibel modellbakände. Testdata ingår inte fullständigt i paketet och måste i flera fall hämtas eller förberedas separat.

En egen datamängd delas normalt upp i tre delar:

data/my_split/
├── train/items.json
├── val/items.json
└── test/items.json

Delarna används på följande sätt:

Det är viktigt att testmängden inte används för att välja redigeringar. Annars finns risk för överanpassning och missvisande resultat.

En grundläggande träningskörning kan startas med projektets träningsskript:

python scripts/train.py \
  --config configs/searchqa/default.yaml \
  --split_dir /sökväg/till/searchqa_split \
  --azure_openai_endpoint https://din-resurs.openai.azure.com/ \
  --optimizer_model DIN_OPTIMERARMODELL \
  --target_model DIN_MÅLMODELL

Vanliga inställningar omfattar:

• antal epoker,
• mängden träningsdata,
• batchstorlek,
• minibatchstorlek,
• inlärningshastighet,
• schema för inlärningshastighet,
• antal parallella analysarbetare,
• mått för valideringsgrinden,
• sökväg till inledande färdighetsdokument.

En träningskörning skapar normalt en katalog med följande struktur:

outputs/run_name/
├── config.json
├── history.json
├── runtime_state.json
├── best_skill.md
├── skills/
├── steps/
├── slow_update/
└── meta_skill/

Filerna innehåller bland annat:

• fullständig körningskonfiguration,
• träningshistorik,
• återupptagningsinformation,
• den bästa validerade färdigheten,
• mellanversioner av färdighetsdokumentet,
• föreslagna och förkastade ändringar,
• resultat från långsamma uppdateringar,
• optimerarmodellens minne.

SkillOpt sparar tillstånd efter varje avslutat steg. En avbruten körning kan därför normalt fortsätta från den senaste kontrollpunkten.

Projektet innehåller ett valfritt webbgränssnitt för övervakning av körningar. Komponenten bygger på Gradio.

Den installeras och startas med:

pip install "skillopt[webui]"
python -m skillopt_webui.app

Webbgränssnittet kan användas för att följa optimeringsprocessen och granska mellanresultat.

SkillOpt kan vara användbart när en AI-agent behöver utveckla återanvändbara arbetsmetoder inom ett tydligt avgränsat område.

Exempel på möjliga användningsområden är:

• förbättring av kodagenter,
• dokumentanalys,
• informationssökning,
• matematisk problemlösning,
• automatisering av kalkylblad,
• verktygsanvändande assistenter,
• interna företagsagenter,
• återkommande kvalitetskontroll,
• specialiserade frågesvarssystem.

Metoden passar särskilt bra när uppgifterna kan poängsättas automatiskt eller kontrolleras med en tillförlitlig utvärderare.

SkillOpt löser inte alla problem med AI-agenter.

Viktiga begränsningar är:

• Optimeringen kräver ett relevant och tillförlitligt poängsystem.
• Dålig träningsdata kan leda till dåliga eller alltför snäva instruktioner.
• Små valideringsmängder kan ge instabila beslut.
• Många agentkörningar och modellanrop kan medföra betydande kostnader.
• En förbättring på testuppgifter behöver inte motsvara bättre beteende i verklig användning.
• Färdighetsdokument kan överanpassas till en specifik modell eller testmiljö.
• Automatiskt genererade regler kan innehålla olämpliga eller motsägelsefulla instruktioner.
• Överföring mellan olika modeller fungerar inte nödvändigtvis för alla uppgifter.
• SkillOpt förbättrar instruktioner men förändrar inte modellens grundläggande kunskap eller kapacitet.

Systemet bör därför kombineras med manuell granskning, separata säkerhetstester och tydliga begränsningar för vilka verktyg agenten får använda.

Ett självförbättrande färdighetsdokument kan påverka hur en agent använder verktyg, hanterar data och fattar beslut. Därför bör optimeringsprocessen omfattas av säkerhetskontroller.

Lämpliga åtgärder omfattar:

• separata säkerhets- och kvalitetsmått,
• granskning av accepterade textändringar,
• versionshantering av färdighetsdokument,
• begränsad åtkomst till känsliga verktyg,
• testning mot manipulativa instruktioner,
• kontroll av att säkerhetsregler inte skrivs över,
• loggning av alla optimeringssteg,
• möjlighet att återgå till en tidigare version.

En förbättrad uppgiftspoäng är inte i sig ett bevis på att agenten blivit säkrare eller mer tillförlitlig.

SkillOpt kan kombineras med flera av dessa metoder. En agent kan exempelvis använda både informationshämtning, verktyg och ett SkillOpt-optimerat färdighetsdokument.

SkillOpt är ett Microsoft-projekt för systematisk optimering av AI-agenters instruktioner och arbetsmetoder. I stället för att träna om språkmodellen förbättrar systemet ett externt dokument i naturligt språk.

Processen bygger på:

• upprepade agentkörningar,
• analys av lyckade och misslyckade försök,
• begränsade textredigeringar,
• separat validering,
• minne mellan träningsepoker,
• export av en kompakt och återanvändbar färdighet.

Den viktigaste skillnaden mot okontrollerad självrevidering är att varje kandidatförändring prövas innan den accepteras. SkillOpt representerar därmed ett försök att överföra principer från maskininlärningens optimeringsprocesser till instruktioner skrivna i naturligt språk.

• SkillOpt på GitHub
• SkillOpts officiella projektsida
• Dokumentation och reproduktionsguide
• Forskningsrapporten SkillOpt: Executive Strategy for Self-Evolving Agent Skills
• Versioner och ändringslogg
• SkillOpt på Python Package Index

Sök efter detta ämne på ...