LLMON : structurer le contexte des modèles de langage
Découvrez comment LLMON structure les échanges avec les LLM, réduit les injections de prompt et ce qu’il faut vérifier avant de l’expérimenter.

LLMON : mieux structurer les échanges avec les modèles de langage
Un modèle de langage ne reçoit pas une conversation comme on la voit à l'écran. Il ingère une suite de tokens, où se mélangent des consignes, un historique, des documents récupérés, des réponses d'outils et des contraintes de sortie. Sur le papier, on peut distinguer ces éléments. Dans la pratique, leur rôle et leurs relations restent souvent flous, surtout quand le contexte devient long ou quand on utilise un modèle plus petit.
Cette ambiguïté n'a pas que des conséquences « qualité ». Un document récupéré ou la sortie d'un outil peut contenir une instruction malveillante que le modèle risque de confondre avec une consigne légitime. C'est l'une des formes d'injection de prompt indirecte. Pour limiter ce risque, IBM Granite propose LLMON : un format de balisage destiné à rendre visibles les composants d'un contexte et la façon dont ils se répondent.
Ça ne veut pas dire que c'est magique. LLMON est-il vraiment plus adapté que JSON pour les modèles de langage ? Qu'apporte-t-il concrètement en sécurité, et comment s'intègre-t-il aux systèmes existants ? Et dans quels cas une équipe a intérêt à le tester ? Voici comment ça marche, ce que les évaluations annoncent, et les précautions à garder.
Pourquoi LLMON plutôt que JSON ou un modèle de conversation classique ?
JSON est très pratique côté logiciel : lisible, largement pris en charge, facile à valider. Mais un format robuste pour un programme n'est pas forcément l'option la plus simple pour un modèle génératif. Un LLM prédit des tokens ; il ne « vérifie » pas automatiquement la grammaire d'un JSON à chaque étape.
Dans JSON, les accolades, les guillemets et les deux-points structurent le tout. Mais ces mêmes caractères peuvent aussi apparaître dans le texte ordinaire, et les règles d'échappement deviennent alors déterminantes pour un parseur conforme. Pour un modèle, ce sont surtout des régularités apprises, qui peuvent rester fragiles avec la longueur. Même chose pour les niveaux d'imbrication : le modèle doit suivre des paires de délimiteurs, ce qui peut se dégrader dans un contexte long.
Des délimiteurs distincts du texte ordinaire
LLMON utilise une syntaxe de type balisage, mais ses délimiteurs structurels ne sont pas des caractères ordinaires : ce sont des tokens spéciaux réservés. Le modèle peut ainsi séparer plus facilement les marqueurs de structure du contenu textuel. Les tags sont placés au début des blocs, et les limites entre blocs sont plus nettes.
La vraie différence n'est pas « JSON est mauvais ». C'est que JSON a été conçu pour échanger et analyser des données côté logiciel, tandis que LLMON cherche une représentation plus lisible pour un modèle causal. Dans une application, JSON peut rester le format d'entrée et de sortie de vos services. LLMON peut servir de couche intermédiaire pour construire la requête adressée au modèle.
IBM indique aussi avoir développé des convertisseurs capables de passer de JSON à LLMON (et inversement) sans perte. L'intérêt pratique : tester le format sans devoir tout réécrire (stockage, contrats d'API, etc.). Cela dit, il faut valider la conversion sur des structures réelles : types, tableaux imbriqués, et chaînes qui contiennent des caractères un peu « étranges ».
LLMON complète les modèles de conversation
LLMON ne remplace pas les modèles de conversation, ni les chat templates. Ceux-ci gèrent surtout les rôles classiques : système, utilisateur, assistant, et l'organisation des tours. LLMON ajoute une couche en précisant la fonction des parties d'un message et leurs liens.
Les modèles de prévisualisation Granite conservent une interface de messages familière. L'application peut fournir un tour utilisateur composé d'une instruction, de données et de contraintes. Ensuite, le modèle de conversation transforme ces éléments en blocs LLMON : certaines parties sont marquées comme devant être liées à l'exécution, d'autres restent présentes dans le contexte sans être référencées.
Ça peut limiter les changements côté application pour un premier essai. Mais on ne doit pas confondre compatibilité d'interface et compatibilité de comportement : le modèle doit avoir été entraîné pour interpréter les marqueurs, et la qualité dépendra de vos tâches. En bref : le format rend les conventions plus explicites, mais il ne dispense pas de définir correctement rôles, données et sorties attendues.
Quel effet LLMON peut-il avoir sur les injections de prompt ?
Une injection de prompt indirecte consiste à glisser une instruction malveillante dans un contenu que le modèle doit traiter comme une donnée : page récupérée, pièce jointe, résultat d'outil, texte fourni par un utilisateur. Par exemple, un document peut demander au modèle d'ignorer sa mission et de divulguer des informations. Si le système ne sépare pas clairement « qui a autorité » et « qui est un simple contenu », le modèle peut suivre cette instruction.
La séparation entre instructions et données est précisément le mécanisme que LLMON vise à renforcer. Une consigne est reliée au bloc d'exécution qui la traite ; un document ou une sortie d'outil est représenté comme une donnée. Résultat attendu : le modèle lit le contenu sans considérer automatiquement chaque instruction qu'il contient comme un ordre.
Ce que montrent les évaluations publiées
IBM compare ses modèles LLMON à des modèles ouverts et propriétaires sur le benchmark OPI. L'objectif de ce benchmark est de placer des injections dans les données de tâches de traitement du langage. La mesure annoncée par IBM porte sur la robustesse : un taux de réussite des attaques plus faible se traduit par une robustesse plus élevée (le texte parle d'un « moins le taux de réussite », puis présente des écarts).
IBM présente des résultats où les modèles LLMON « évitaient » davantage d'attaques que les meilleurs modèles testés dans les catégories concernées. Le chiffre mis en avant est 47 % de plus que le meilleur modèle de pointe évalué, et 95 % de plus que le meilleur modèle ouvert évalué. L'équipe indique aussi des tendances similaires sur ASB et StruQ, et affirme que les performances globales restent comparables à celles des Granite 4.1 Instruct sur plusieurs catégories de benchmarks.
Pour les équipes qui construisent de la recherche augmentée, des assistants documentaires, ou des agents qui appellent des outils, ça peut sembler utile : ce sont des cas où le modèle consomme souvent du « contenu externe ». Concrètement, pour une entreprise, l'enjeu n'est pas seulement de produire une réponse utile, mais d'éviter qu'un contenu source prenne le contrôle du comportement applicatif.
Une réduction du risque, pas une garantie
Ces résultats restent à lire avec une limite nette : les tests évoqués portent sur des injections indirectes statiques. IBM indique travailler aussi sur des attaques adaptatives, qui se déploient au fil de plusieurs échanges. Un benchmark ne prouve donc pas que le modèle résistera à toutes les attaques, tous les formats, et tous les scénarios.
Et surtout : LLMON ne remplace pas les contrôles de sécurité autour du modèle. Une architecture sérieuse devrait aussi limiter les permissions des outils, contrôler les données sensibles, journaliser les appels, valider les sorties, et prévoir un refus/supervision humaine pour les actions à fort impact. Un modèle plus robuste à une injection ne devrait pas, par défaut, être autorisé à faire des actions critiques (comme modifier des comptes ou exécuter des virements).
Il existe enfin une limite « mécanique » de la protection : la règle de privilège est apprise à partir de la structure et des exemples d'entraînement. Ce n'est pas un garde-fou formel qui rendrait impossible toute interprétation contraire. Le modèle peut encore échouer. La bonne lecture, c'est donc : LLMON est une couche supplémentaire, à évaluer dans votre système, pas un correctif universel.
Comment évaluer LLMON dans un projet réel ?
Les versions 3B et 8B sont présentées comme des préversions expérimentales, faites pour explorer et évaluer, pas pour remplacer immédiatement de la production. Dit autrement : ne partez pas du principe que « ça marche » sur des métriques. Testez si la structuration explicite améliore vraiment votre cas d'usage, sans dégrader ce qui compte pour votre entreprise.
Commencer par un flux où les rôles se mélangent
Choisissez un scénario où votre application combine plusieurs types de contenu : consigne métier, document récupéré, historique, résultat d'outil, contraintes de réponse. C'est là que LLMON a le plus de chances d'apporter un vrai bénéfice. Un échange simple, sans source externe, ne teste pas grand-chose.
Construisez ensuite un jeu d'essai représentatif, incluant des cas adverses. Si vous faites un assistant qui résume des procédures, par exemple : testez des documents propres, des documents hors sujet, des textes contenant des instructions malveillantes, et des situations où les sources se contredisent. Mesurez au minimum :
- la réussite de la tâche métier, selon des critères définis avant de commencer ;
- la capacité à ignorer les consignes présentes dans les données ;
- la fidélité aux documents et le taux d'informations inventées ;
- le respect des exigences de sortie (format, longueur, etc.) ;
- le coût, la latence, et les erreurs de conversion de structure.
Comparez ensuite LLMON avec votre modèle actuel sur les mêmes entrées. Un gain de robustesse qui s'accompagne d'une baisse trop forte de qualité, d'un surcoût opérationnel ou d'une latence incompatible avec votre service ne sera pas forcément rentable. À l'inverse, un surcoût modéré peut se justifier si vos données sont souvent non fiables, ou si vos actions sont sensibles.
Garder des garde-fous et des critères de passage
Pendant le pilote, gardez les contrôles applicatifs sous votre responsabilité. Le serveur doit continuer à gérer les permissions, valider les paramètres et autoriser (ou non) l'appel à un outil. Ne laissez pas une convention de balisage décider seule si une action est légitime.
Définissez aussi des critères d'arrêt avant de vous engager trop loin : seuil maximal d'injections réussies, niveau minimal de qualité, budget de latence, taux d'échec de conversion, exigences de traçabilité. Et pour un service soumis au RGPD, documentez les données envoyées au modèle, la durée de conservation et les rôles des fournisseurs, comme pour toute autre intégration d'IA. LLMON ne change pas vos obligations.
Si vos données sont déjà en JSON, testez d'abord les convertisseurs sur des exemples représentatifs plutôt que sur un échantillon « parfait ». Vérifiez la conservation des types, des relations, des champs optionnels, et des contenus inhabituels. IBM mentionne aussi la possibilité de définir un vocabulaire adapté à un domaine, puis d'entraîner un adaptateur LoRA pour aider le modèle à lire et à produire cette structure. C'est utile si votre structure métier ne se résume pas à des catégories génériques (instruction, donnée, exigence).
L'exemple ScienceWorld publié par IBM illustre cette approche : des tags dédiés représentent les objectifs, les règles de planification, l'état de l'environnement et l'action suivante. Un adaptateur LoRA est entraîné sur ces trajectoires pour que le modèle produise des actions dans cette structure. Pour une entreprise, le principe peut s'étendre à des flux plus spécialisés, mais il faut des données d'entraînement cohérentes et un protocole d'évaluation adapté.
Conclusion
LLMON répond à un problème concret : dans les prompts complexes, le modèle doit souvent deviner quelles parties sont des consignes, lesquelles sont des données, et comment tout est relié. En rendant ces relations explicites, le format propose une piste pour améliorer la fiabilité et réduire certaines injections indirectes, sans promettre de supprimer le risque.
Pour une équipe produit ou technique, la décision la plus raisonnable reste simple : lancer un pilote ciblé si vos flux combinent documents, outils et contraintes métier. Comparez au comportement actuel, gardez les permissions sous contrôle applicatif, et ne passez en production qu'après avoir testé les limites sur vos propres données.
Comment LLMON structure-t-il le contexte d'un LLM ?
LLMON signifie LLM Object Notation. L'idée est simple : aider le modèle à reconnaître plus clairement le type de chaque élément du contexte, et les liens entre ces éléments. Au lieu de laisser le modèle deviner ce qui relève d'une instruction, d'une donnée ou d'une contrainte, on présente tout sous forme de blocs distincts et nommés.
Ces blocs sont délimités par des tokens spéciaux. Un tag indique la nature du contenu (instruction, donnée, exigence, etc.). Des identifiants permettent ensuite de référencer un bloc précis. Enfin, un bloc d'exécution décrit ce qu'il faut faire : quelle instruction appliquer, à quelles données, avec quelles contraintes, et dans quel bloc placer la réponse.
Une relation explicite entre consigne et données
Prenons une demande de résumé. Le contexte peut contenir : une consigne (« résumer »), le texte à résumer, et une contrainte de longueur. Dans un prompt « classique », ces éléments sont souvent mélangés dans une même chaîne : le modèle doit comprendre que le texte est une source à traiter, pas une instruction à suivre.
Avec LLMON, les éléments deviennent des blocs adressables. Le bloc d'exécution relie les pièces : appliquer la consigne à ce document, respecter la contrainte, puis produire la sortie au bon endroit. Une autre instruction présente dans le contexte, mais non appelée par le bloc d'exécution, n'est pas censée piloter la réponse.
Ce mécanisme devient particulièrement utile quand on combine plusieurs sources : historique de conversation, résultats de recherche, réponses d'API, documents internes, règles métier. Le modèle voit tout, mais le rôle de chaque élément est moins ambigu.
Des structures imbriquées et des identifiants compacts
LLMON permet aussi de représenter des structures imbriquées. Les sous-éléments sont balisés localement, plutôt que d'exiger du modèle le suivi d'une profondeur d'imbrication sur une longue séquence. Les identifiants sont choisis dans un ensemble que le tokenizer encode via des tokens dédiés ; selon IBM, référencer un bloc coûte un nombre fixe de tokens (deux).
Attention : ça ne garantit pas que le contexte sera plus court. Le format ajoute aussi des marqueurs. L'intérêt est ailleurs : rendre la structure et les dépendances plus visibles pour le modèle, au lieu de les laisser noyées dans une mise en forme « conventionnelle » ou dans une suite de caractères.
IBM publie deux modèles expérimentaux dérivés de Granite 4.1 : les versions 3B et 8B LLMON Preview. Ils sont entraînés pour lire et produire du texte balisé selon ce format. Ce n'est donc pas juste un préfixe à coller sur n'importe quel modèle : le comportement attendu dépend du modèle et de son entraînement.