🤖 AI

GOAT: A Training Framework for Goal-Oriented Agent with Tools

Le papier présente GOAT, un nouveau cadre d'entraînement permettant le fine-tuning d'agents LLM open source pour l'utilisation complexe d'outils sans annotation humaine, en synthétisant automatiquement des données d'exécution d'API orientées vers un objectif à partir de la documentation, et atteignant des performances de pointe sur des benchmarks existants ainsi que sur un nouveau benchmark nommé GOATBench.

Auteurs originaux : Hyunji Min, Sangwon Jung, Junyoung Sung, Dosung Lee, Leekyeung Han, Paul Hongsuck Seo

Publié 2026-05-06

📖 4 min de lecture☕ Lecture pause café

CC BY 4.0

Auteurs originaux : Hyunji Min, Sangwon Jung, Junyoung Sung, Dosung Lee, Leekyeung Han, Paul Hongsuck Seo

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

Imaginez que vous avez une bibliothécaire très intelligente et bien informée (l'IA) qui sait lire des livres et écrire des histoires. Cependant, si vous demandez à cette bibliothécaire d'aller dans la salle arrière de la bibliothèque, de trouver une boîte spécifique de vieilles cartes, d'en extraire une page précise, puis d'utiliser cette page pour trouver une recette spécifique dans un livre de cuisine, elle se perd souvent. Elle pourrait deviner la mauvaise boîte, ouvrir le mauvais livre, ou oublier d'apporter la page de la carte à la cuisine.

C'est le problème des agents IA actuels lorsqu'ils tentent d'utiliser des « outils » (comme les API, qui sont des connexions numériques vers des bases de données, des services météorologiques ou des listes de films). Ils sont excellents pour discuter, mais terribles pour planifier une mission à multiples étapes où une étape dépend entièrement du résultat de la précédente.

L'article présente GOAT (Goal-Oriented Agent with Tools), une nouvelle méthode d'entraînement conçue pour transformer cette bibliothécaire perplexe en un détective maître. Voici comment cela fonctionne, en utilisant des analogies simples :

Le Problème : Le « Jeu de Devinettes »

Habituellement, pour enseigner à une IA comment utiliser des outils, les chercheurs doivent engager des humains pour rédiger des milliers d'exemples comme : « D'abord, demandez à l'API météo s'il va pleuvoir. Ensuite, prenez cette réponse 'pluie' et demandez à l'API vêtements un imperméable. »
C'est coûteux et lent. Sans ces exemples rédigés par des humains, les modèles d'IA devinent simplement. Ils échouent souvent dans des tâches complexes nécessitant de chaîner plusieurs étapes.

La Solution : La Cuisine de « Réingénierie Inverse »

Les auteurs de GOAT ont réalisé qu'ils n'avaient pas besoin d'humains pour rédiger les instructions. Ils avaient déjà le « livre de cuisine » (la documentation des API). Au lieu de demander à l'IA de deviner la recette à partir d'un plat fini, ils ont décidé de préparer le plat d'abord, puis de décrire la recette.

Ils utilisent une stratégie « Appel en Premier » :

Cartographier la Cuisine : D'abord, le système lit tous les manuels d'API et dessine une carte de la façon dont les outils sont connectés. (Par exemple : « La sortie de l'outil 'Météo' s'intègre parfaitement dans l'entrée de l'outil 'Parapluie' »).
Cuisiner le Repas (L'Étape Appel en Premier) : Le système choisit un chemin sur cette carte et exécute réellement les outils. Il demande des données à l'outil météo, obtient le résultat, puis utilise immédiatement ce résultat pour interroger l'outil parapluie. Il ne devine pas ; il exécute de vraies étapes et obtient de vraies réponses.
Écrire la Recette (L'Étape d'Abstraction) : Après que les outils ont effectué le travail, l'IA examine la chaîne d'événements terminée et rédige une requête utilisateur qui correspond. Elle dit essentiellement : « Oh, je viens de faire toutes ces étapes pour trouver un imperméable. Donc, un utilisateur demandant 'Que devrais-je porter s'il pleut ?' est ce que je viens de résoudre. »

En procédant ainsi à l'envers (Action $\rightarrow$ Question), l'IA apprend la logique correcte de la connexion des outils sans qu'un humain ait à rédiger les instructions. Elle apprend en faisant le travail d'abord, puis en expliquant ce qu'elle a fait.

Le Résultat : Un Super-Assistant

L'article a testé ces nouveaux agents entraînés avec GOAT sur plusieurs défis :

RestBench & API-Bank : Ce sont comme des examens où l'IA doit trouver des critiques de films ou des recommandations musicales en utilisant une chaîne d'outils.
GOAT-Bench : Les auteurs ont créé un tout nouvel examen, plus vaste, spécifiquement pour ce type de tâches complexes à multiples étapes.

Les conclusions étaient claires :

Modèles Open Source : Avant GOAT, les petits modèles d'IA open source (gratuits et accessibles à tous) étaient presque inutiles pour ces tâches complexes. Ils échouaient dans près de 100 % des cas.
Après GOAT : Une fois entraînés avec cette nouvelle méthode, ces mêmes modèles open source sont devenus incroyablement bons dans ces tâches. Dans certains cas, ils ont surpassé des modèles propriétaires coûteux (comme GPT-4) qui dominent habituellement ces tests.
Aucun Humain Nécessaire : L'ensemble du jeu de données d'entraînement a été construit automatiquement par le système en utilisant les manuels d'API. Aucun humain n'a dû s'asseoir et rédiger les instructions étape par étape.

La Conclusion

GOAT est une méthode pour enseigner aux agents IA comment planifier et utiliser des outils en leur permettant de pratiquer le travail réel d'abord, puis en leur apprenant à décrire l'objectif. Elle transforme les modèles d'IA open source de « devineurs sans repères » en « planificateurs fiables » sans nécessiter d'enseignants humains coûteux. Les auteurs ont rendu leur code et leur nouvelle suite de tests (GOAT-Bench) disponibles pour que d'autres puissent les utiliser.

Résumé technique : GOAT : Un cadre d'entraînement pour un agent orienté vers les objectifs avec outils

Énoncé du problème

Les modèles de langage de grande taille (LLM) ont évolué en agents interactifs capables d'invoquer des outils externes (API). Cependant, un écart significatif subsiste dans la gestion des requêtes orientées vers les objectifs. Contrairement à des tâches plus simples impliquant des requêtes en une seule étape ou des instructions explicitement spécifiées, les tâches orientées vers les objectifs exigent qu'un agent décompose un objectif de haut niveau en une séquence d'appels API interdépendants. Cela nécessite un raisonnement complexe pour la décomposition des tâches, une planification à long horizon et la capacité d'inférer les arguments appropriés pour les fonctions API en fonction des sorties des appels précédents.

Les approches actuelles pour entraîner des agents à ces tâches sont limitées par l'absence de données d'entraînement de haute qualité. La construction de jeux de données capturant les dépendances inter-API nécessite généralement une annotation humaine coûteuse, ce qui n'est pas évolutif. Par conséquent, la plupart des méthodes existantes reposent sur une évaluation en zéro-shot, où l'on attend des modèles qu'ils effectuent un raisonnement complexe sans supervision spécifique à la tâche. Bien que les modèles propriétaires (par exemple, GPT-4) montrent une certaine capacité, les modèles open-source plus petits échouent souvent à exécuter efficacement ces scénarios complexes d'utilisation d'outils.

Méthodologie : Le cadre GOAT

Pour remédier au problème de la pénurie de données, les auteurs proposent GOAT (Goal-Oriented Agent with Tools), un cadre d'entraînement entièrement automatique qui synthétise des données d'exécution d'API orientées vers les objectifs à partir de la documentation API existante, sans annotation humaine. Le cadre repose sur le postulat que la documentation API est généralement disponible pour les domaines cibles et peut être exploitée pour construire des données d'entraînement.

1. Construction automatique de jeux de données

L'innovation centrale de GOAT est un paradigme de génération « appel d'abord », qui contraste avec les stratégies « instruction d'abord » utilisées dans les travaux antérieurs (où un LLM génère d'abord une requête puis tente de la mapper à des appels API). GOAT inverse ce flux pour éviter les biais d'auto-renforcement vers des instances « faciles ».

Le processus de construction des données comporte trois étapes principales :

Construction du graphe de dépendances API :
- Analyse : Les documents API sont analysés pour extraire les spécifications d'entrée/sortie.
- Initialisation du graphe : Un multid graphe entièrement connecté est initialisé, où les arêtes représentent les dépendances potentielles (la sortie de l'API $A$ comme entrée de l'API $B$ ).
- Filtrage progressif : Pour garantir la fiabilité, le graphe est affiné par trois étapes de filtrage :
  1. Similarité des embeddings : Filtrage grossier utilisant des embeddings SBERT pour rejeter les arêtes sémantiquement incompatibles.
  2. Vérification par LLM : Un LLM évalue la plausibilité sémantique uniquement sur la base des descriptions.
  3. Validation d'exécution : L'étape la plus rigoureuse, où le LLM génère des arguments, exécute l'API source et vérifie si la sortie peut valablement remplir les paramètres de l'API de destination. Cela garantit que seuls les flux de travail exécutables sont conservés.
Synthèse de données orientées vers les objectifs :
- Échantillonnage : Des sous-graphes connectés (représentant des séquences d'API valides) sont extraits du graphe de dépendances.
- Instantiation « appel d'abord » : Le cadre instancie et exécute la séquence d'API, générant des sorties concrètes.
- Génération de requête et de réponse : Sur la base de la séquence exécutée et des sorties, le LLM génère une requête utilisateur en langage naturel qui encapsule l'objectif de haut niveau et une réponse finale qui interprète les résultats. Cela crée un jeu de données où le signal de supervision (la séquence d'appels API) est ancré dans la réalité, et la requête est une abstraction de cette réalité.

2. Entraînement de l'agent

Le cadre affine deux composants sur le jeu de données synthétisé :

Agent LLM : Affiné par instruction pour planifier la séquence correcte d'appels, remplir les arguments (avec les valeurs d'arguments masquées pendant l'entraînement pour éviter le surapprentissage à des valeurs spécifiques) et générer la réponse finale en langage naturel.
Récupérateur : Un modèle de récupération dense (basé sur SBERT) entraîné sur des paires requête-document API de vérité terrain pour mapper les requêtes utilisateur aux spécifications API pertinentes.

Contributions clés

Cadre GOAT : Un cadre d'entraînement nouveau et entièrement automatique qui construit des jeux de données d'exécution d'API orientés vers les objectifs à partir de documentation API sans annotation humaine. Il introduit une stratégie de génération « appel d'abord » qui fournit une supervision fiable pour l'apprentissage du raisonnement complexe en ancrant les données dans des flux de travail d'API exécutables.
Performances de pointe : Des expériences extensives démontrent que les agents entraînés avec GOAT atteignent des performances de pointe sur plusieurs benchmarks existants orientés vers les objectifs en utilisant des modèles open-source, surpassant dans certains cas les modèles fermés dotés de fortes capacités de raisonnement.
GOATBench : L'introduction d'un nouveau benchmark d'évaluation à grande échelle pour les tâches orientées vers les objectifs. Construit à l'aide du pipeline GOAT avec une vérification humaine légère, il couvre des domaines divers (Divertissement, Finance, Alimentation, Voyage) et inclut à la fois des compositions d'API « vues » et « non vues » pour tester la généralisation.

Résultats expérimentaux

Les auteurs ont évalué GOAT sur RestBench, API-Bank et le nouveau GOATBench.

RestBench : Les modèles open-source (Llama-2-13B, Vicuna-13B) affinés avec GOAT ont montré des améliorations substantielles par rapport aux bases de référence en zéro-shot et aux méthodes open-source antérieures (RestGPT). Dans certains cas, ils ont surpassé des modèles fermés comme GPT-4.
API-Bank : Les modèles entraînés avec GOAT ont nettement surpassé les bases de référence en zéro-shot et d'autres approches de données synthétiques, atteignant des taux de réussite et des pourcentages de chemins corrects plus élevés.
GOATBench : Les agents entraînés avec GOAT ont démontré des gains constants par rapport aux modèles non affinés et aux modèles entraînés avec des données « instruction d'abord » (par exemple, issues de ToolLLM). Le cadre s'est avéré efficace dans les scénarios à outil unique et inter-outils (multi-API).
Études d'ablation :
- « Appel d'abord » vs « Instruction d'abord » : Les modèles entraînés avec des données « appel d'abord » ont constamment atteint des taux de réussite plus élevés que ceux entraînés avec des données « instruction d'abord », validant la capacité de la stratégie à fournir une meilleure supervision pour le raisonnement complexe.
- Généralisation : Les modèles entraînés sur GOATBench ont montré une performance améliorée sur des API non vues et une généralisation inter-benchmarks (par exemple, entraînement sur GOATBench et test sur RestBench), bien que les gains aient été plus prononcés dans le domaine.

Importance et affirmations

L'article affirme que GOAT offre une voie pratique et évolutive vers la construction d'agents LLM open-source robustes capables de raisonnement complexe et d'utilisation d'outils. En éliminant la dépendance à une annotation humaine coûteuse et en exploitant le paradigme « appel d'abord », GOAT permet une adaptation efficace par domaine des LLM. Les résultats suggèrent que les modèles open-source, lorsqu'ils sont correctement affinés avec ces données synthétiques, peuvent rivaliser avec ou dépasser les performances des modèles propriétaires dans l'utilisation d'outils orientée vers les objectifs, répondant ainsi à un goulot d'étranglement critique dans le déploiement des systèmes d'IA agentiques.

Les auteurs reconnaissent des limites, notant que si le cadre améliore les performances dans le domaine, la généralisation à des scénarios entièrement non vus reste limitée, et que la qualité des données générées dépend de la qualité de la documentation API source. Néanmoins, ce travail établit une nouvelle référence pour l'entraînement d'agents à l'utilisation d'outils interdépendants sans intervention humaine.