🤖 AI

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

LatentSkill est un cadre de travail qui convertit des compétences textuelles en adaptateurs LoRA prêts à l'emploi via un hyperréseau préentraîné, permettant aux agents LLM de stocker des procédures de tâches réutilisables dans l'espace des poids plutôt que dans l'espace du contexte, ce qui réduit considérablement la surcharge de jetons tout en améliorant les performances et en permettant une composition modulaire des compétences.

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

Publié 2026-08-18

📖 6 min de lecture🧠 Analyse approfondie

CC BY 4.0

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

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Les modèles de langage de grande taille sont devenus remarquablement capables de raisonner sur des problèmes complexes, agissant souvent comme des agents numériques capables de planifier, de chercher et d'interagir avec des logiciels pour accomplir des tâches. Pour gérer des emplois spécialisés, ces agents s'appuient fréquemment sur des « compétences » — essentiellement des instructions ou des procédures écrites qui disent au modèle comment résoudre un type de problème spécifique, comme organiser une pièce virtuelle ou répondre à une question à étapes multiples. Traditionnellement, ces compétences sont injectées directement dans l'entrée du modèle chaque fois qu'il doit les utiliser, un peu comme si l'on lisait une page de manuel page par page avant de passer à l'action. Bien que cela fonctionne, cela crée un goulot d'étranglement important : plus la tâche est complexe et plus la bibliothèque de compétences est vaste, plus le texte que le modèle doit traiter est important, ce qui ralentit son exécution et consomme d'énormes quantités de puissance de calcul. De plus, le fait de conserver ces instructions sous forme de texte brut dans l'entrée les laisse exposées et vulnérables à une mauvaise lecture ou à un détournement par d'autres parties du système.

Des chercheurs de l'Université Jiao Tong de Shanghai et de l'institut de recherche OPPO ont proposé une approche différente appelée LatentSkill, qui déplace ces instructions hors de l'entrée textuelle pour les intégrer dans la structure de la mémoire interne du modèle. Au lieu de lire une description de compétence à chaque fois, le système utilise un générateur spécialisé pour convertir le texte d'une compétence en un ensemble compact d'ajustements internes, connus sous le nom d'adaptateurs, qui sont attachés de manière permanente au « cerveau » du modèle. Cela permet à l'agent de « connaître » la compétence sans avoir à relire les instructions. L'équipe a constaté que cette méthode non seulement accélère le processus et réduit la quantité de données que le modèle doit traiter, mais crée également un espace caché et organisé où différentes compétences peuvent être mélangées et assorties avec une précision mathématique.

L'idée centrale de ce travail est de traiter une compétence non pas comme un document à lire, mais comme un ensemble de poids à charger. Dans leur cadre, un « compilateur de compétences » prend une description écrite d'une tâche et génère instantanément un ensemble unique de modifications internes pour le modèle de langage. Ces modifications sont petites, efficaces et modulaires, ce qui signifie qu'elles peuvent être attachées ou détachées du modèle principal sans réentraîner l'ensemble du système. Une fois qu'une compétence est convertie en ce format interne, le texte original est supprimé du flux d'entrée. Le modèle opère alors en utilisant ces ajustements cachés, qui guident son comportement aussi efficacement que le texte le ferait, mais sans le coût lourd du traitement de milliers de mots supplémentaires pour chaque étape d'une tâche.

Pour tester cela, les chercheurs ont appliqué leur système à deux défis distincts : une simulation textuelle d'un robot naviguant dans une maison pour accomplir des tâches ménagères, et une série de tâches de questions-réponses complexes nécessitant la recherche à travers plusieurs sources d'information. Dans la tâche de navigation domestique, le système devait comprendre comment ramasser des objets, les nettoyer et les placer dans des endroits spécifiques. Dans la tâche de questions-réponses, il devait trouver des réponses nécessitant la connexion de plusieurs morceaux d'information. Comparée à la méthode standard consistant à coller les instructions de compétence dans l'invite (prompt), la nouvelle approche s'est avérée nettement plus efficace. Sur les tâches de navigation domestique, le système a amélioré son taux de réussite de plus de vingt points de pourcentage sur des tâches familières et de plus de treize points sur de nouvelles tâches inédites, tout en utilisant près de deux tiers de jetons (tokens) d'entrée en moins. Sur les benchmarks de questions-réponses, il a atteint un taux de précision plus élevé tout en réduisant le nombre de jetons traités par étape de plus de soixante-dix pour cent.

Au-delà du simple gain de temps et de ressources, les chercheurs ont découvert que ces ajustements de compétences internes possèdent une structure surprenante. En cartographiant l'espace mathématique où vivent ces compétences, ils ont constaté que les compétences appartenant à une même catégorie, telles que les tâches de nettoyage ou les tâches de recherche, se regroupent naturellement, formant des clusters distincts. Cela suggère que le système ne fait pas que mémoriser du texte, mais apprend la logique sous-jacente des procédures. Cette structure permet un haut degré de contrôle ; les chercheurs ont découvert qu'ils pouvaient ajuster la force d'une compétence simplement en tournant un cadran, représenté par un nombre d'échelle. Si le nombre était trop bas, la compétence n'avait aucun effet ; s'il était trop élevé, le modèle devenait confus. Cependant, au réglage approprié, le modèle fonctionnait de manière optimale, et ce point idéal restait constant à travers différents types de tâches.

La découverte la plus intrigante fut peut-être que ces compétences internes pouvaient être combinées. Tout comme on pourrait mélanger des ingrédients pour créer un nouveau plat, les chercheurs ont montré qu'ils pouvaient prendre les ajustements internes de deux compétences différentes et les additionner pour créer une nouvelle compétence composite. Cependant, cela ne fonctionnait de manière fiable que lorsque les compétences étaient décomposées en leurs composants les plus petits et les plus alignés avant d'être mélangées. Si l'on ajoutait simplement les blocs de compétences entiers, le résultat était souvent moins efficace. En alignant soigneusement les parties, ils ont pu créer une compétence capable d'exécuter une séquence d'actions complexes sans perdre la capacité d'exécuter les étapes individuelles. Cela suggère que le système peut construire des comportements complexes en assemblant des pièces de connaissances modulaires de manière à la fois flexible et précise.

L'étude a également mis en évidence un avantage significatif en matière de sécurité. Comme les compétences sont stockées sous forme d'ajustements internes plutôt que de texte visible, elles sont beaucoup plus difficiles à manipuler. Lorsque les chercheurs ont testé le système contre des tentatives de détournement des instructions ou d'extraction des connaissances cachées, la nouvelle méthode a résisté remarquablement bien. Alors que l'approche traditionnelle basée sur le texte s'effondrait souvent ou révélait ses secrets lors d'attaques, la version de la compétence interne maintenait sa performance et gardait ses instructions cachées. Cela indique que le déplacement des compétences de l'invite visible vers les poids internes du modèle offre une manière plus robuste et sécurisée d'équiper les agents artificiels de connaissances spécialisées.

Les chercheurs concluent que cette approche offre une voie pratique pour construire des agents d'IA plus capables et plus efficaces. En déplaçant le stockage de la connaissance procédurale du flux d'entrée vers les paramètres internes du modèle, ils ont démontré un moyen de rendre les agents plus rapides, plus sûrs et meilleurs pour combiner différentes capacités. Les résultats suggèrent que l'avenir des agents d'IA ne réside peut-être pas dans l'injection de plus de texte, mais dans l'apprentissage de la capacité à porter leurs compétences en interne, prêtes à être déployées par un interrupteur invisible et simple.

Résumé Technique : LatentSkill

Énoncé du Problème

Les agents basés sur les Grands Modèles de Langage (LLM) s'appuient de plus en plus sur des compétences textuelles externes — des procédures réutilisables encodant des stratégies, des modes d'utilisation d'outils et des heuristiques — pour résoudre des tâches complexes à long horizon. La conception prédominante consiste à extraire ces compétences d'une bibliothèque et à les injecter sous forme de texte brut dans le prompt à chaque étape de décision. Bien que modulaire, cette approche souffre de trois limitations critiques :

Surcharge de Contexte : L'insertion répétée du texte de la compétence consomme un espace significatif dans la fenêtre de contexte et augmente les coûts de pré-remplissage (prefill), particulièrement à mesure que les bibliothèques de compétences croissent et que les interactions s'allongent.
Robustesse : Les entrées longues peuvent dégrader la capacité d'un modèle à utiliser de manière robuste l'ensemble des informations fournies.
Sécurité : Le fait de conserver les compétences sous forme de contenu textuel lisible expose les procédures propriétaires et crée des vulnérabilités face au détournement d'instructions (instruction hijacking) ou aux attaques d'extraction de compétences.

Inversement, les alternatives paramétriques comme le fine-tuning complet ou l'apprentissage curriculaire fusionnent les compétences dans les poids du modèle, ce qui les rend difficiles à mettre à jour, à supprimer ou à combiner de manière modulaire. Cela crée un trilemme : les méthodes existantes peinent à éviter la répétition du texte de la compétence tout en maintenant la capacité de mettre à jour et de combiner les compétences de manière dynamique lors de l'inférence.

Méthodologie : LatentSkill

LatentSkill propose un cadre qui convertit les compétences textuelles d'agents en adaptateurs LoRA (Low-Rank Adaptation) modulaires via un hyperréseau pré-entraîné, déplaçant ainsi la connaissance de la compétence de l'espace contextuel vers l'espace des poids.

Architecture Centrale

Compilateur de Compétences (Hyperréseau) : Un hyperréseau basé sur un Transformer $G_\phi$ mappe un document de compétence textuelle $s$ vers un ensemble de mises à jour LoRA $\Delta_s$ .
$\Delta_s = G_\phi(s)$
La mise à jour générée suit la forme standard LoRA $\Delta W_s = B_s A_s$ pour les modules cibles (projections query, key, value, output, gate, up, down).
Mécanisme d'Inférence : Au lieu de conditionner le modèle sur le texte de la compétence dans le prompt, l'adaptateur généré est monté sur le LLM de base gelé $\theta$ . Le modèle prédit les sorties en fonction de l'historique de la tâche $h_t$ et des poids augmentés :
$p_{\theta, \phi}(y_t | h_t, s) = p_{\theta \oplus \alpha \Delta_s}(y_t | h_t)$
Ici, $\alpha$ est un coefficient d'échelle contrôlant la force d'injection de la compétence.

Pipeline d'Entraînement

Le cadre utilise un processus d'entraînement en deux étapes pour le compilateur de compétences tout en gardant le LLM de base gelé :

Pré-entraînement au niveau du Document : Le compilateur est entraîné sur un corpus de documents de compétences textuelles ( $D_{pre}$ ) en utilisant un mélange 1:1 d'objectifs de reconstruction (reproduire le document complet) et de complétion (prédire le suffixe tronqué). Cela initialise la correspondance entre le texte procédural et les poids de l'adaptateur utilisables.
Fine-tuning Supervisé par Trajectoire (SFT) : Le compilateur est affiné à l'aide de trajectoires d'agents enseignants ( $D_{sft}$ ). Pour chaque paire document-compétence et trajectoire, le même adaptateur généré est appliqué à toutes les étapes de décision. L'objectif minimise la perte entre la sortie du modèle adapté et la trajectoire de l'enseignant, encourageant l'adaptateur à capturer une information de politique stable au niveau de la compétence plutôt que des adaptations par étape.

Contrôle et Composition au Moment de l'Inférence

Chargement Modulaire : Les compétences sont compilées une seule fois et mises en cache. Lors de l'inférence, un sélecteur monte l'adaptateur ou les adaptateurs pertinents sans inclure le texte de la compétence dans le prompt.
Composition dans l'Espace des Poids : Plusieurs compétences peuvent être combinées en sommant leurs mises à jour LoRA : $\Delta_K = \sum \alpha_k C[k]$ .
Composition au Niveau des Composants : Pour éviter de sur-amplifier les comportements partagés, les compétences peuvent être décomposées en composants sémantiques (par exemple, principes généraux vs stratégies spécifiques), qui sont compilés indépendamment et recombinés avec des coefficients d'injection spécifiques.

Contributions Clés

Proposition de Cadre : L'introduction de LatentSkill, qui convertit les compétences textuelles en adaptateurs LoRA modulaires et interchangeables via un hyperréseau, éliminant le besoin de texte de compétence dans le prompt d'inférence.
Performance et Efficacité : Démonstration que LatentSkill surpasse le prompting de compétence en contexte direct sur les benchmarks ALFWorld et Search-QA, tout en réduisant considérablement la surcharge de contexte (tokens de prefill).
Analyse Structurelle : La découverte que les LoRA de compétences générées présentent une géométrie sémantique structurée, permettent un contrôle continu via des coefficients d'échelle et supportent une composition arithmétique dans l'espace des paramètres lorsque les composants sont sémantiquement alignés.

Résultats Expérimentaux

Le cadre a été évalué sur ALFWorld (tâches d'IA incarnée) et Search-QA (réponse à des questions multi-sauts), en utilisant Qwen3-8B comme backbone gelé.

Performance ALFWorld : LatestSkill a atteint des taux de réussite de 74,3 % (vu) et 69,4 % (non vu). Cela représente une amélioration de 21,4 et 13,4 points par rapport à la ligne de base de la compétence en contexte, respectivement. Il a également réduit le nombre moyen de tokens de prefill de 63,9 %.
Performance Search-QA : LatentSkill a atteint un Exact Match (EM) moyen de 35,6 %, surpassant le RAG de 1,2 point et la ligne de base de la compétence en contexte de 3,0 points, tout en utilisant 71,8 % de tokens en moins par étape.
Généralisation Hors-Domaine (OOD) : Sur le benchmark WebShop (sans trajectoires d'entraînement), LatentSkill (SFT) a obtenu un score de 23,9, surpassant nettement la ligne de base de la compétence en contexte (6,7), suggérant que la compilation des compétences dans l'espace latent atténue la dilution de l'attention causée par les prompts longs.
Robustesse : LatentSkill a maintenu des performances constantes sous des perturbations du texte de la compétence (paraphrase, bruit, réordonnancement) et des attaques au niveau du prompt (hijacking, extraction), alors que les compétences en contexte ont subi de sévères chutes de performance (par exemple, passant de 52,9 % à 8,57 % sous un hijacking sur ALFWorld).

Signification et Revendications

L'article soutient que LatentSkill offre un substrat pratique pour étendre les agents LLM en abordant les compromis d'efficacité, de modularité et de sécurité des systèmes de compétences actuels.

Efficacité : En stockant les compétences dans l'espace des poids, le cadre supprime le coût par étape de la tokenisation et du traitement du texte de la compétence, permettant une inférence plus rapide et une utilisation moindre du contexte.
Modularité : Contrairement au fine-tuning, les compétences restent distinctes du backbone, permettant de les charger, de les décharger, de les remplacer ou de les mettre à l'échelle sans réentraîner le modèle de base.
Représentation Structurée : Les poids LoRA générés ne sont pas simplement des prompts compressés ; ils forment une géométrie sémantique structurée où les compétences se regroupent par domaine. Cette structure permet :
- Contrôlabilité : La force d'injection d'une compétence peut être modulée de manière continue via le coefficient d'échelle $\alpha$ .
- Composabilité : Les compétences peuvent être combinées arithmétiquement dans l'espace des paramètres, à condition que leurs composants sémantiques soient alignés, permettant la création de comportements complexes à partir de modules plus simples.

Les auteurs concluent que les poids de compétences latentes fournissent une alternative efficace, modulaire et moins exposée aux prompts en texte brut pour construire des agents LLM robustes.