🤖 AI

LatentSkill: From In-Context Textual Skills to In-Weight Latent Skills for LLM Agents

LatentSkill is een framework dat tekstuele vaardigheden omzet in plug-and-play LoRA-adapters via een vooraf getrainde hypernetwork, waardoor LLM-agenten in staat worden gesteld om herbruikbare taakprocedures op te slaan in de gewichtsruimte in plaats van de contextruimte, wat het token-overhead aanzienlijk vermindert terwijl de prestaties worden verbeterd en modulaire vaardigheidscompositie mogelijk wordt gemaakt.

Oorspronkelijke auteurs: Aofan Yu, Chenyu Zhou, Tianyi Xu, Zihan Guo, Rong Shan, Zhihui Fu, Jun Wang, Weiwen Liu, Yong Yu, Weinan Zhang, Jianghao Lin

Gepubliceerd 2026-08-18

📖 6 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Aofan Yu, Chenyu Zhou, Tianyi Xu, Zihan Guo, Rong Shan, Zhihui Fu, Jun Wang, Weiwen Liu, Yong Yu, Weinan Zhang, Jianghao Lin

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Grote taalmodellen zijn bijzonder bekwaam geworden in het redeneren door complexe problemen, waarbij ze vaak fungeren als digitale agenten die kunnen plannen, zoeken en met software kunnen interageren om taken te voltooien. Om gespecialiseerde banen uit te voeren, vertrouwen deze agenten vaak op "vaardigheden" — in essentie geschreven instructies of procedures die het model vertellen hoe een specife soort probleem moet worden opgelost, zoals het organiseren van een virtuele kamer of het beantwoorden van een meerstapsvraag. Traditioneel worden deze vaardigheden bij elke benodigde actie direct in de input van het model gevoed, vergelijkbaar met het pagina voor pagina lezen van een handleiding voordat men een actie onderneemt. Hoewel dit werkt, creëert het een aanzienlijke flessenhals: hoe complexer de taak en hoe groter de bibliotheek aan vaardigheden, hoe meer tekst het model moet verwerken, wat het proces vertraagt en enorme hoeveelheden rekenkracht verbruikt. Bovendien laat het bewaren van deze instructies als platte tekst in de input ze blootgesteld en kwetsbaar achter voor misinterpretatie of kaping door andere delen van het systeem.

Onderzoekers van de Shanghai Jiao Tong Universiteit en het OPPO Research Institute hebben een andere aanpak voorgesteld genaamd LatentSkill, die deze instructies uit de tekstuele input haalt en naar de interne geheugenstructuur van het model verplaatst. In plaats van telkens een beschrijving van een vaardigheid te lezen, gebruikt het systeem een gespecialiseerde generator om de tekst van een vaardigheid om te zetten in een compacte set interne aanpassingen, bekend als adapters, die permanent aan het "brein" van het model zijn bevestigd. Dit stelt de agent in staat de vaardigheid te "kennen" zonder de instructies opnieuw te hoeven lezen. Het team ontdekte dat deze methode het proces niet alleen versnelt en de hoeveelheid gegevens die het model moet verwerken vermindert, maar ook een verborgen, georganiseerde ruimte creëert waar verschillende vaardigheden met wiskundige precisie kunnen worden gemengd en gecombineerd.

De kern van dit werk is het idee om een vaardigheid niet te behandelen als een document dat gelezen moet worden, maar als een set gewichten die geladen moeten worden. In hun framework neemt een "skill compiler" een geschreven beschrijving van een taak en genereert onmiddellijk een unieke set interne modificaties voor het taalmodel. Deze modificaties zijn klein, efficiënt en modulair, wat betekent dat ze aan het hoofdmodel kunnen worden bevestigd of ervan kunnen worden losgekoppeld zonder het hele systeem opnieuw te trainen. Zodra een vaardigheid in dit interne formaat is omgezet, wordt de oorspronkelijke tekst uit de inputstroom verwijderd. Het model opereert vervolgens met behulp van deze verborgen aanpassingen, die het gedrag sturen even effectief als de tekst dat zou doen, maar zonder de zware kosten van het verwerken van duizenden extra woorden voor elke stap van een taak.

Om dit te testen, pasten de onderzoekers hun systeem toe op twee verschillende uitdagingen: een tekstgebaseerde simulatie van een robot die door een huis navigeert om klusjes te klaren, en een reeks complexe vraag-en-antwoordtaken die vereisen dat er door meerdere bronnen van informatie wordt gezocht. In de navigatietaak in het huis moest het systeem uitzoeken hoe het objecten kon oppakken, schoonmaken en op specifieke locaties kon plaatsen. In de vraag-en-antwoordtaak moest het antwoorden vinden die het verbinden van verschillende stukken informatie vereisten. Wanneer het werd vergeleken met de standaardmethode van het plakken van vaardigheidsinstructies in de prompt, bleek de nieuwe aanpak aanzienlijk efficiënter. Bij de navigatietaken in het huis verbeterde het systeem het succespercentage met meer dan twintig procentpunten bij bekende taken en met meer dan dertien punten bij nieuwe, onbekende taken, terwijl het bijna twee derde minder input-tokens gebruikte. Op de vraag-en-antwoordbenchmarks behaalde het een hogere nauwkeurigheidsgraad terwijl het aantal verwerkte tokens per stap met meer dan zeventig procent werd verminderd.

Naast het besparen van tijd en middelen, ontdekten de onderzoekers dat deze interne vaardigheidsaanpassingen een verrassende hoeveelheid structuur bezitten. Wanneer zij de wiskundige ruimte in kaart brachten waarin deze vaardigheden zich bevinden, vonden zij dat vaardigheden die tot dezelfde categorie behoren, zoals schoonmaaktaken of zoektaken, van nature samenklonteren en de vorming van duidelijke clusters vormen. Dit suggereert dat het systeem niet alleen tekst onthoudt, maar ook de onderliggende logica van de procedures leert. Deze structuur maakt een hoge mate van controle mogelijk; de onderzoekers ontdekten dat ze de sterkte van een vaardigheid eenvoudig konden aanpassen door een draaiknop te gebruiken, vertegenwoordigd door een schaleringsgetal. Als het getal te laag was, had de vaardigheid geen effect; als het te hoog was, raakte het model in de war. Echter, bij de juiste instelling presteerde het model optimaal, en deze ideale instelling bleef consistent over verschillende soorten taken.

Misschien wel de meest intrigerende bevinding was dat deze interne vaardigheden gecombineerd konden worden. Net zoals men ingrediënten kan mengen om een nieuw gerecht te maken, lieten de onderzoekers zien dat ze de interne aanpassingen van twee verschillende vaardigheden konden samenvoegen om een nieuwe, samengestelde vaardigheid te creëren. Dit werkte echter alleen betrouwbaar wanneer de vaardigheden werden afgebroken in hun kleinste, meest uitgelijnde componenten voordat ze werden gemengd. Als ze simpelweg de hele vaardigheidsblokken bij elkaar optelden, was het resultaat vaak minder effectief. Door de delen zorgvuldig af te stemmen, waren ze in staat een vaardigheid te creëren die een complexe reeks handelingen uitvoerde zonder het vermogen om de individuele stappen uit te voeren te verliezen. Dit suggereert dat het systeem complexe gedragingen kan opbouwen door modulaire stukjes kennis te assembleren op een manier die zowel flexibel als precies is.

De studie benadrukte ook een belangrijk beveiligingsvoordeel. Omdat de vaardigheden worden opgeslagen als interne aanpassingen in plaats van zichtbare tekst, zijn ze veel moeilijker te manipuleren. Toen de onderzoekers het systeem testten tegen pogingen om de instructies te kapen of de verborgen kennis te extraheren, hield de nieuwe methode opmerkelijk goed stand. Terwijl de traditionele tekstgebaseerde aanpak vaak instortte of haar geheimen prijsgaf bij een aanval, behield de interne vaardigheidsversie haar prestaties en hield zij de instructies verborgen. Dit geeft aan dat het verplaatsen van vaardigheden van de zichtbare prompt naar de interne gewichten van het model een robuustere en veiligere manier biedt om gespecialiseerde kennis aan kunstmatige agenten uit te rusten.

De onderzoekers concluderen dat deze aanpak een praktische weg vooruit biedt voor het bouwen van meer capabele en efficiënte AI-agenten. Door de opslag van procedurele kennis te verschuiven van de inputstroom naar de interne parameters van het model, hebben zij aangetoetahui dat er een manier is om agenten sneller, veiliger en beter in het combineren van verschillende vermogens te maken. De resultaten suggereren dat de toekomst van AI-agenten niet ligt in het voeden van meer tekst, maar in het aanleren van de vaardigheid om hun vaardigheden intern te dragen, klaar om te worden ingezet met een eenvoudige, onzichtbare schakelaar.

Technische Samenvatting: LatentSkill

Probleemstelling

Large Language Model (LLM) agenten vertrouwen steeds vaker op externe tekstuele vaardigheden—herbruikbare procedures die strategieën, tool-gebruikspatronen en heuristieken coderen—om complexe, langdurige taken op te lossen. Het huidige ontwerp haalt deze vaardigheden uit een bibliotheek en injecteert ze als plaintext in de prompt bij elke beslissingsstap. Hoewel modulair, lijdt deze aanpak onder drie kritieke beperkingen:

Context Overhead: Het herhaaldelijk invoegen van skill-tekst verbruikt aanzienlijke ruimte in het contextvenster en verhoogt de prefill-kosten, vooral naarmate de skill-bibliotheken groeien en interacties langer worden.
Robuustheid: Lange inputs kunnen het vermogen van een model aantasten om alle aangeleverde informatie robuust te benutten.
Beveiliging: Het binnen de leesbare prompt-content houden van vaardigheden legt propriëtaire procedures bloot en creëert kwetsbaarheden voor instruction hijacking of skill-extractie-aanvallen.

Daartegenover staan parametrische alternatieven zoals volledige fine-tuning of curriculum learning, waarbij vaardigheden in de modelgewichten worden gefuseerd, wat ze moeilijk maakt om modulair bij te werken, te verwijderen of te combineren. Dit creëert een trilemma: bestaande methoden worstelen met het vermijden van herhaalde skill-tekst terwijl ze de mogelijkheid behouden om vaardigheden dynamisch tijdens inferentie bij te werken en te combineren.

Methodologie: LatentSkill

LatentSkill stelt een framework voor dat tekstuele agent-vaardigheden omzet in modulaire LoRA (Low-Rank Adaptation) adapters via een getrainde hypernetwork, waardoor de kennis van de vaardigheid effectief wordt verplaatst van de contextruimte naar de gewichtsruimte.

Kernarchitectuur

Skill Compiler (Hypernetwork): Een Transformer-gebaseerd hypernetwork $G_\phi$ brengt een tekstueel vaardigheidsdocument $s$ in kaart naar een set LoRA-updates $\Delta_s$ .
$\Delta_s = G_\phi(s)$
De gegenereerde update volgt de standaard LoRA-vorm $\Delta W_s = B_s A_s$ voor doelmodules (query, key, value, output, gate, up, down projecties).
Inference Mechanisme: In plaats van het model te conditioneren op de skill-tekst binnen de prompt, wordt de gegenereerde adapter gemonteerd op het bevroren backbone LLM $\theta$ . Het model voorspelt outputs op basis van de taakgeschiedenis $h_t$ en de uitgebreide gewichten:
$p_{\theta, \phi}(y_t | h_t, s) = p_{\theta \oplus \alpha \Delta_s}(y_t | h_t)$
Hierbij is $\alpha$ een schaalcoëfficiënt die de injectiekracht van de vaardigheid regelt.

Trainingspipeline

Het framework maakt gebruik van een tweestaps trainingsproces voor de skill compiler, terwijl de backbone LLM bevroren blijft:

Document-Level Pretraining: De compiler wordt getraind op een corpus van tekstuele vaardigheidsdocumenten ( $D_{pre}$ ) met een 1:1 mix van reconstructie (het reproduceren van het volledige document) en completion (het voorspellen van de afgekapte suffix) doelstellingen. Dit initialiseert de mapping van procedurele tekst naar bruikbare adaptergewichten.
Trajectory-Supervised Fine-Tuning (SFT): De compiler wordt gefinetuned met behulp van teacher agent trajecten ( $D_{sft}$ ). Voor elk skill-document en traject-paar wordt dezelfde gegenereerde adapter toegepast op alle beslissingsstappen. De doelstelling minimaliseert de loss tussen de output van de aangepaste model en het traject van de teacher, wat de adapter stimuleert om stabiele, skill-niveau beleidsinformatie te vangen in plaats van per stap aanpassingen te maken.

Controle en Compositie tijdens Inferentie

Modulaire Loading: Vaardigheden worden eenmaal gecompileerd en gecached. Tijdens inferentie monteert een selector de relevante adapter(s) zonder de skill-tekst in de prompt op te nemen.
Weight-Space Compositie: Meerdere vaardigheden kunnen worden gecombineerd door hun LoRA-updates op te tellen: $\Delta_K = \sum \alpha_k C[k]$ .
Component-Level Compositie: Om overmatige amplificatie van gedeelde gedragingen te voorkomen, kunnen vaardigheden worden gedecomposeerd in semantische componenten (bijv. algemene principes versus specifieke strategieën), die onafhankelijk worden gecompileerd en gecombineerd met specifieke injectiecoëfficiënten.

Belangrijkste Bijdragen

Framework Voorstel: De introductie van LatentSkill, dat tekstuele vaardigheden omzet in modulaire, plug-and-play LoRA-adapters via een hypernetwork, waardoor de noodzaak voor skill-tekst in de inferentie-prompt wordt geëlimineerd.
Prestaties en Efficiëntie: Demonstratie dat LatentSkill beter presteert dan directe in-context skill prompting op de ALFWorld en Search-QA benchmarks, terwijl het de context overhead (prefill tokens) aanzienlijk vermindert.
Structurele Analyse: De bevinding dat gegenereerde skill LoRA's een gestructureerde semantische geometrie vertonen, continue controle mogelijk maken via schaalcoëfficiënten, en composibele aritmetiek in de parameterrruimte ondersteunen wanneer componenten semantisch uitgelijnd zijn.

Experimentele Resultaten

Het framework werd geëvalueerd op ALFWorld (embodied AI taken) en Search-QA (multi-hop vraagbeantwoording), waarbij Qwen3-8B als de bevroren backbone werd gebruikt.

ALFWorld Prestaties: LatentSkill behaalde succespercentages van 74,3% (gezien) en 69,4% (ongezien). Dit is een verbetering van respectievelijk 21,4 en 13,4 punten ten opzichte van de in-context skill baseline. Het verminderde ook het gemiddelde aantal prefill tokens met 63,9%.
Search-QA Prestaties: LatentSkill behaalde een gemiddelde Exact Match (EM) van 35,6%, waarmee het RAG met 1,2 punten en de in-context skill baseline met 3,0 punten versloeg, terwijl het 71,8% minder tokens per stap gebruikte.
Out-of-Domain (OOD) Generalisatie: Op de WebShop benchmark (zonder trainings-trajecten) scoorde LatentSkill (SFT) 23,9, wat aanzienlijk beter is dan de in-context skill baseline (6,7), wat suggereert dat het compileren van vaardigheden in de latente ruimte de aandacht-dilutie veroorzaakt door lange prompts mitigeert.
Robuustheid: LatentSkill behield consistente prestaties onder skill-tekst perturbaties (parafrasering, ruis, herordening) en prompt-niveau aanvallen (hijacking, extractie), terwijl in-context skills ernstige prestatiedalingen leden (bijv. een daling van 52,9% naar 8,57% onder hijacking op ALFWorld).

Betekenis en Claims

Het artikel stelt dat LatentSkill een praktisch substraat biedt voor het uitbreiden van LLM-agenten door de efficiëntie-, modulariteit- en beveiligingsafwegingen van huidige skill-systemen aan te pakken.

Efficiëntie: Door vaardigheden in de gewichtsruimte op te slaan, elimineert het framework de per-stap kosten van het tokeniseren en verwerken van skill-tekst, wat snellere inferentie en lager contextgebruik mogelijk maakt.
Modulariteit: In tegenstelling tot fine-tuning blijven vaardigheden gescheiden van de backbone, waardoor ze geladen, ontladen, vervangen of geschaald kunnen worden zonder de basismodel opnieuw te trainen.
Gestructureerde Representatie: De gegenereerde LoRA-gewichten zijn niet louter gecomprimeerde prompts; ze vormen een gestructureerde semantische geometrie waar vaardigheden clusteren per domein. Deze structuur maakt het volgende mogelijk:
- Controleerbaarheid: De injectiekracht van een vaardigheid kan continu worden gemoduleerd via de schaalcoëfficiënt $\alpha$ .
- Compositie: Vaardigheden kunnen aritmetisch worden gecombineerd in de parameterrruimte, mits hun semantische componenten uitgelijnd zijn, wat de creatie van complexe gedragingen uit eenvoudigere modules mogelijk maakt.

De auteurs concluderen dat latente skill-gewichten een efficiënt, modulair en minder blootgesteld alternatief bieden voor plaintext prompts voor het bouwen van robuuste LLM-agenten.