Les agents IA d'aujourd'hui sont puissants, mais ils abordent chaque tâche comme une page blanche. Chaque exécution est en pratique sans état, si bien que le système répète souvent la même exploration, essaie les outils dans des ordres différents, manque parfois des étapes clés ou rencontre des modes d'échec prévisibles. C'est un peu comme un nouvel employé qui apprend un processus pour la première fois. Même lorsque l'agent réussit finalement, le chemin qu'il a emprunté et les erreurs commises en cours de route ne sont pas conservés, si bien que la tâche similaire suivante recommence de zéro.
Pour tenir leurs promesses, les agents doivent apprendre davantage comme les humains. Ils doivent être exposés à de vraies tâches, apprendre de chaque succès et de chaque échec, et faire progresser ce contexte durement acquis.
C'est là que les traces deviennent essentielles. Une trace est l'enregistrement de la manière dont une tâche a réellement été exécutée, y compris les outils utilisés, l'ordre dans lequel ils ont été utilisés, avec quels paramètres, et quel a été le résultat.
Dans les environnements d'entreprise, les traces sont particulièrement précieuses parce que la partie la plus difficile du problème n'est pas l'utilisation des outils, mais la compréhension du workflow : quels systèmes font réellement autorité, comment plusieurs outils sont combinés d'une étape à l'autre, quelles conventions et séquences implicites s'appliquent, et quels schémas n'apparaissent que dans l'usage réel.
Ces schémas n'existent pas dans les données d'entraînement des modèles. Ils n'émergent que par l'exécution.
L'apprentissage par traces transforme ces exécutions en boucle de rétroaction. Au lieu de mémoriser des trajectoires entières, le système extrait ce qui est utile : quelle stratégie a fonctionné, ce qui a échoué et ce qu'il faudrait faire différemment la prochaine fois. Au fil du temps, cela permet à l'agent de ; :
- éviter de répéter des schémas d'échec connus
- réutiliser des séquences d'outils et des choix de paramètres efficaces
- s'adapter à des workflows spécifiques à l'environnement
- améliorer ses performances sans fine-tuning ni grands ensembles d'instructions
C'est pourquoi les traces ne sont pas seulement utiles pour l'observabilité. Lorsque les agents apprennent à partir d'elles, ils peuvent passer d'une exécution ponctuelle des tâches à la construction d'une véritable expertise propre à l'environnement. ;
Dans ce billet, nous partageons l'approche de Glean en matière d'apprentissage par traces, notamment la manière dont nous concevons la correction, nous concentrons sur des stratégies d'outils au niveau des workflows, et ancrons le tout dans les permissions et la gouvernance.
Comment l'apprentissage par traces améliore les performances des tâches
À un niveau élevé, l'apprentissage par traces comporte deux composantes :
- Apprentissage hors ligne, qui extrait des stratégies à partir de traces historiques.
- Application en ligne, qui récupère et applique ces stratégies à l'exécution.
On peut le voir comme une boucle dans laquelle chaque tâche rend les agents plus forts.
Apprentissage hors ligne : explorer les alternatives en toute sécurité
Pendant l'apprentissage hors ligne, Glean échantillonne des traces réelles fondées sur des tâches agentiques issues de votre déploiement. Il apprend ensuite à partir de ces traces en :
- Exécutant un agent « enseignant » puissant avec un budget de raisonnement élevé et un large accès aux outils, afin de servir de référence de haute qualité pour ce à quoi ressemble une « bonne » exécution d'une tâche.
- Comparant plusieurs traces d'agents « élèves » fonctionnant sous des contraintes de production réelles, notamment des budgets plus serrés, des ensembles d'outils plus restrictifs et des limites de latence, afin de comprendre le comportement de l'agent dans des conditions réelles.
- Évaluant chaque stratégie. La combinaison de plusieurs élèves et d'un enseignant crée une base pour déterminer quelles stratégies fonctionnent mieux ou moins bien. Nous sélectionnons les stratégies qui se démarquent de leur groupe en fonction de la correction, du comportement d'appel aux outils, de l'efficacité d'exécution et de l'alignement avec les retours des utilisateurs.
- Distillant les meilleures stratégies des élèves les plus performants en mémoires compactes en langage naturel qui guideront les futures exécutions de l'agent.
Application en ligne : appliquer les bonnes mémoires à l'exécution
Lorsqu'une personne envoie une requête à Glean, celui-ci :
- comprend l'objectif
- récupère les mémoires pertinentes en fonction du schéma de la tâche
- adapte le plan de l'agent à l'aide de ces mémoires avant l'exécution
- exécute le plan en utilisant les mêmes mémoires dans leur contexte
Par exemple, pour une requête comme « Mettre à jour toutes mes opportunités Salesforce ouvertes », Glean peut utiliser des mémoires telles que :
- Ne pas faire évoluer StageName si un champ MEDDICC est vide ou ne contient que du texte générique comme « TBD » ou « Follow up next week ».
- Lorsque les champs MEDDIC sont mis à jour, privilégier une mise à jour de ces champs dans une écriture séparée avant de modifier StageName.
- Pour les champs narratifs longs comme Customer_Narrative__c, ajouter une nouvelle section datée au lieu d'écraser le contenu existant.
- Lors du changement d'étape d'une opportunité Salesforce, utiliser d'abord l'outil 'Update Salesforce opportunity' pour renseigner chaque champ clé, y compris Amount, CloseDate, ForecastCategory, MEDDIC, Next Step, si ce champ est vide ou a plus de 14 jours.
- Lors de recherches sur moins de 10 opportunités, utiliser la recherche Glean avec le filtre d'application Salesforce et le filtre de type de document 'Opportunity' au lieu de l'outil de recherche Salesforce Object Query Language (SOQL).
- Lors de recherches sur un grand nombre d'opportunités à des fins d'analyse, utiliser la recherche SOQL en sélectionnant au minimum les champs personnalisés `ARR__c`, `TechStack__c`, `Partner__c` et `SeatCount__c`, ainsi que les champs d'opportunité standard.
Ces mémoires ont été apprises à partir de schémas de réussite et de modes d'échec rencontrés pendant la phase hors ligne de l'apprentissage par traces dans le propre déploiement de Glean.
Travaux récents sur l'apprentissage par traces
Les travaux récents sur l'apprentissage par traces convergent vers une idée commune : les agents s'améliorent lorsqu'ils peuvent conserver et réutiliser une expérience structurée issue de tâches réelles. Au lieu de s'appuyer uniquement sur un entraînement statique, ces approches considèrent les exécutions passées comme une source d'apprentissage, permettant aux agents de s'adapter à des environnements complexes, évolutifs et fortement dépendants du contexte.
Dynamic Cheatsheet est l'une des premières formulations de cette idée. Elle présente la mémoire comme une couche auto-curée et adaptative, dans laquelle l'agent décide quoi conserver ou supprimer en fonction de son utilité. L'idée clé est qu'une mémoire efficace doit être à la fois suffisamment spécifique pour être exploitable et suffisamment abstraite pour généraliser. Plutôt que de stocker des trajectoires complètes, le système distille les traces en consignes concises en langage naturel qui capturent ce qui compte d'une manière transférable à des tâches similaires. Cela fait de la mémoire bien plus qu'un simple enregistrement du passé : elle devient quelque chose qui peut guider de manière fiable les comportements futurs.
Agentic Context Engineering (ACE) s'appuie sur cette idée en passant à des playbooks structurés. ACE agrège des schémas issus de nombreuses traces en stratégies réutilisables qui indiquent quand une stratégie s'applique, comment enchaîner les étapes, quels outils privilégier et comment gérer les modes d'échec courants. Le système passe ainsi du souvenir de ce qui s'est passé à l'apprentissage de ce qu'il faut faire.
ReasoningBank utilise l'apprentissage contrastif pour améliorer ces stratégies. Au lieu de simplement renforcer les traces réussies, il compare explicitement les exécutions réussies et échouées afin de comprendre où les comportements divergent. En analysant ce qui change entre un échec et une réussite, comme le choix d'outil, l'ordre des étapes ou le raisonnement intermédiaire, le système peut isoler les décisions qui comptaient réellement. ;
L'apprentissage par traces de Glean s'appuie sur ces idées tout en les adaptant aux environnements d'entreprise. Au lieu de se fier uniquement au résultat d'une seule trace enseignante, Glean agrège des signaux issus de nombreuses exécutions et impose une validation plus stricte avant l'apprentissage. Cela rend les consignes apprises plus précises, tout en leur permettant de généraliser à des tâches similaires au sein du déploiement d'un client.
Comment nous avons conçu l'apprentissage par traces pour l'entreprise
L'apprentissage par traces est autant un problème de correction qu'un problème d'apprentissage ;
Construire une mémoire d'entreprise relevait autant d'un problème de conception autour de la correction que d'un problème d'apprentissage. Pour l'IA d'entreprise, la bonne réponse n'est généralement pas disponible dans des données publiques, et les sorties de l'agent ne sont pas toujours directement vérifiables. ;
Nous avons constaté qu'une seule trace enseignante, même avec l'effort de raisonnement le plus élevé, n'était pas suffisamment fiable à elle seule. Nous sommes donc passés à une configuration plus stricte : extraire les assertions à travers les réponses, vérifier l'accord, valider les conflits à l'aide de Glean Search, et éviter tout apprentissage lorsque les incohérences ne peuvent pas être résolues.
Dans l'apprentissage hors ligne, nous exécutons une trace enseignante à fort raisonnement et la comparons à plusieurs exécutions alternatives. Pour déterminer ce que le système doit réellement apprendre, nous extrayons les affirmations factuelles de plusieurs réponses, vérifions si elles concordent et ne conservons une réponse canonique que lorsque les sorties sont cohérentes ou peuvent être vérifiées à l'aide d'outils supplémentaires. Si l'incohérence ne peut pas être résolue, nous ne produisons aucun apprentissage. Cette approche est plus prudente et plus sélective quant à ce qu'elle apprend, par rapport à des systèmes qui se contentent de faire confiance à leurs propres sorties ou de réutiliser les exécutions passées telles quelles.
Parce que la correction compte, Glean est volontairement sélectif sur ce qu'il apprend. Le flux actuel d'apprentissage par traces sélectionne des requêtes représentatives de haute qualité susceptibles de revenir, et il s'appuie sur plusieurs classificateurs ainsi que sur des vérifications d'intention à forte confiance plutôt que d'essayer d'apprendre à partir de chaque requête possible. Cela permet de garder les stratégies résultantes plus petites, plus propres et plus dignes de confiance comme guidance à l'exécution.
Tout comme dans l'approche de ReasoningBank, nous apprenons à partir des succès et des échecs, pas seulement des exécutions qui ont fini par bien se terminer. L'objectif est d'exposer le modèle à des traces variées afin qu'il puisse comprendre plusieurs chemins menant à une solution, voir où l'exécution se dégrade, et distiller des leçons plus utiles qu'un simple chemin idéal ne le permettrait. Nous nous assurons qu'avec le temps, l'agent deviendra de plus en plus précis dans la manière dont il aborde les tâches.
Stocker délibérément des stratégies d'outils étroites qui se généralisent à des tâches liées
Lorsque nous avons conçu l'apprentissage par traces, nous avons pris la décision délibérée de stocker des apprentissages intentionnellement étroits. L'objectif était de capturer des consignes du type « dans cette situation, privilégiez cette stratégie » plutôt que de prescrire des séquences exactes ou d'abstraire de manière excessive, afin que les apprentissages restent actionnables tout en se généralisant à des tâches apparentées.
Dans un environnement comptant des centaines de connecteurs et d'actions, le défi n'est pas seulement de trouver le bon outil, mais de savoir comment utiliser efficacement plusieurs outils ensemble. Les agents doivent dépasser les actions individuelles et apprendre des schémas d'exécution réutilisables, par exemple quand paralléliser par rapport à séquencer des appels d'outils, quand un système fait autorité pour l'analytics par rapport au détail au niveau de l'enregistrement, et quand plusieurs outils doivent être combinés en un seul workflow. Cela compte encore davantage en entreprise, où la difficulté ne vient pas de la disponibilité des outils, mais de la compréhension de la manière dont le travail est réellement accompli au sein d'une organisation donnée.
Autrement dit, l'apprentissage par traces déplace l'attention de « quel outil appeler » vers « comment accomplir une tâche à travers les outils ».
Capturer ces schémas au niveau du workflow apporte un autre avantage important. Cela réduit l'espace d'actions à l'exécution en regroupant les outils dans des primitives de plus haut niveau, tout en fournissant des conseils pratiques sur la manière de les utiliser ensemble. Au lieu de naviguer entre des dizaines d'outils isolément, les agents peuvent opérer au niveau de workflows significatifs, comme « mettre à jour les notes de version », adaptés à la manière dont cette tâche est réellement réalisée dans une entreprise donnée.
Ces bénéfices de l'apprentissage par traces s'étendent aux outils basés sur MCP, où le contexte et les instructions limités rendent l'apprentissage à partir des traces d'exécution encore plus précieux.
Séparer les apprentissages entre les niveaux déploiement et utilisateur pour capturer en toute sécurité les préférences individuelles
La mémoire est conçue avec la sécurité à l'esprit. L'apprentissage se fait au niveau du déploiement ou de l'utilisateur et n'est jamais généralisé entre entreprises. Tous les apprentissages sont stockés en dehors des modèles, sans information conservée au-delà d'un déploiement Glean. Les actions qui écriraient dans des applications comme Google Drive, Salesforce, Jira, Asana ou Slack sont rejouées dans un chemin fantôme sans toucher aux données de production. Cela nous permet d'apprendre à partir de flux de bout en bout réalistes sans impacter les données des clients.
Nous structurons la mémoire en deux niveaux : des stratégies au niveau du déploiement, partagées au sein d'une entreprise, et des apprentissages personnalisés, visibles uniquement par l'utilisateur individuel.
- L'apprentissage au niveau du déploiement se concentre sur la manière dont les outils sont utilisés, et non sur les données sous-jacentes. Nous ne stockons que ce qui se généralise, comme les noms d'outils, les schémas de séquencement, les modèles de paramètres et les types de requêtes. Nous excluons explicitement les prompts utilisateur, le contenu des documents, les sorties brutes des outils, les titres, les identifiants, les e-mails et d'autres champs sensibles.
- L'apprentissage au niveau de l'utilisateur est privé ; pour chaque personne. Il capture des préférences telles que les modèles de contenu et la mise en forme de documents comme les pull requests, les notes de version et les mises à jour de statut, ainsi que les styles de communication pour les travaux créatifs ou orientés client.
Nos premières versions de l'apprentissage par traces ne stockaient que des stratégies au niveau du déploiement afin de privilégier la sécurité et la compréhension partagée des workflows. Mais cela signifiait aussi que nous manquions initialement la mémoire au niveau de l'utilisateur, là où les modèles, la mise en forme et les préférences de travail individuelles comptent le plus. Nous avons ensuite constaté que ces stratégies au niveau de l'utilisateur avaient un impact significatif sur les performances, ce qui nous a conduits à adopter une structure de mémoire à deux niveaux. ;
Étendre l'apprentissage par traces au-delà des exécutions d'agents
L'apprentissage par traces est une étape clé pour créer des agents qui s'améliorent avec l'expérience. En apprenant à partir d'exécutions réelles, les agents dépassent la simple réalisation ponctuelle des tâches et commencent à accumuler des connaissances pratiques sur ce qui fonctionne, ce qui échoue et comment aborder des problèmes similaires plus efficacement au fil du temps.
Mais les traces ne se limitent pas aux exécutions d'agents. Elles existent aussi dans les systèmes d'entreprise sous forme d'enregistrements de la manière dont le travail est réellement accompli, à travers des documents, des actions et des interactions entre outils. L'étape suivante consiste à relier ces couches. Les traces d'agents montrent comment les tâches sont exécutées, tandis que les traces d'entreprise montrent comment le travail circule dans l'organisation. Ensemble, elles ouvrent la voie à une compréhension plus profonde des workflows — c'est là qu'interviennent les context graphs.
Découvrez-en plus sur l'exécution de tâches auto-améliorante en réservant une démo dès aujourd'hui !
