SynthAPI : environnements synthétiques et scaling laws pour entraîner des agents tool-use

Un agent tool-use apprend à utiliser les outils de deux façons : le training le lui enseigne, ou il l'apprend au fil du contexte. La première, toutefois, demande un environnement d'entraînement : des outils qui répondent, des erreurs qui reviennent, des tâches qui se répètent. L'environnement le plus confortable est votre serveur local, mais les outils réels — les vraies API avec lesquelles l'agent devra compter en production — coûtent, changent et parfois ne doivent pas être touchés.
Le paper SynthAPI, publié sur arXiv, part de là : construire des environnements synthétiques contrôlés où entraîner des agents qui utilisent des outils, sans toucher aux API réelles.
Le problème : entraîner un agent demande de la répétition
Un modèle qui doit faire du tool calling n'apprend pas en regardant des exemples : il apprend en essayant. Chaque tâche — « réserve un vol », « exporte le rapport en CSV » — produit une séquence d'appels, de réponses, d'erreurs, de corrections. Pour atteindre un niveau fiable sur un ensemble de tâches, il faut répéter ce cycle des milliers de fois, avec des variantes : des entrées légèrement différentes, des outils qui échouent de façons différentes, des réponses plus longues ou plus courtes.
Dans un environnement réel, cette répétition a un prix triple :
- Coût : chaque appel d'un agent passe des tokens de contexte (prompt, résultats d'outils, raisonnement) au modèle ; avec un modèle frontier via API, chaque tâche répétée est de l'argent qui part vers un fournisseur externe.
- Fragilité : les API réelles changent, appliquent des limites de débit, modifient leur schéma. Une tâche d'entraînement qui se basait sur le comportement d'hier échoue aujourd'hui à cause d'un champ modifié, pas à cause de l'agent.
- Bruit : les échecs réels sont imprévisibles. Si vous mesurez l'amélioration de l'agent, une erreur 500 inattendue du backend salit la métrique.
L'idée : un environnement synthétique aux échecs réglables
SynthAPI propose de remplacer les outils réels par des simulations : des API synthétiques qui ont le même schéma que les vraies (mêmes endpoints, mêmes champs), mais dont le comportement est sous votre contrôle. Le point clé est la maîtrise des échecs : vous pouvez faire échouer l'outil simulé avec une probabilité que vous fixez, de façons que vous fixez.
Pourquoi c'est utile pour l'entraînement. Un agent qui n'a jamais vu d'erreur n'apprend pas à la gérer : au premier 429 en production, il se bloque. Dans un environnement synthétique, vous pouvez injecter exactement le mélange d'échecs que vous voulez — timeout, champs manquants, limite de débit — et mesurer si la politique de l'agent s'améliore ou se dégrade selon ce mélange. C'est l'équivalent du simulateur de vol pour les pilotes : ce n'est pas le ciel, mais c'est là que s'entraîne le comportement qu'on ne peut pas tester dans le ciel.
Les scaling laws du paper : combien de tâches, et comment elles changent
SynthAPI ne s'arrête pas à « faisons un environnement synthétique ». Il étudie comment composer les données synthétiques et comment le nombre de tâches nécessaires évolue avec l'objectif. Le résultat central, formulé dans le paper comme une relation logarithmique : le nombre de tâches synthétiques nécessaires pour atteindre un certain taux de réussite croît logarithmiquement avec ce taux.
En pratique, traduit en exemples (les constantes exactes dépendent du jeu de données et du modèle, le rapport est celui du paper) :
- pour atteindre 90 % de réussite sur un ensemble de 200 tâches, il faut de l'ordre de 3 500 tâches synthétiques ;
- pour atteindre 95 %, il faut de l'ordre de 7 100 tâches synthétiques.
Lecture : de 90 à 95 points de pourcentage, le coût en données double. C'est le genre de fait qui change un plan de projet : si votre cas d'usage n'a pas besoin de 95 %, ne payez pas ce doublon. Le paper montre aussi que la qualité des données synthétiques — variété des tâches, distribution des échecs — pèse plus que la quantité pure : à nombre égal de tâches, un environnement qui couvre bien la distribution des échecs bat un environnement qui répète le même schéma.
Le calcul : synthétique local vs API frontier
Le point, en revanche, est le où. L'environnement synthétique tourne mieux — et coûte moins — si le modèle qui génère les tâches et fait les répétitions est à vous. Calculons sur 10 000 tâches synthétiques, chacune avec environ 5 000 tokens de contexte (prompt + appels d'outils + réponses), sur un batch de génération d'environ 150 heures-GPU de travail :
| Voie | Hypothèse de coût | 10 000 tâches | Coût par tâche |
|---|---|---|---|
| GPU 24 Go à vous (RTX 4090, ~0,25 kWh/10 000 tâches, 0,25 €/kWh) | énergie : 6,25 kWh → ~1,60 € | ~1,60 € (amortissement du matériel exclu) | ~0,0002 € |
| GPU serverless (1,50 €/h) | 150 h → 225 € | 225 € | 0,0225 € |
| API frontier (3 $/M tokens input, ~20 % output) | 50 M input + 10 M output ≈ 170 $ | ~158 € | ~0,016 € |
Le chiffre qui compte : un environnement d'entraînement qui coûte ~158 € en API frontier pour 10 000 tâches coûte ~1,60 € d'énergie sur du matériel que vous avez déjà — et les données ne quittent pas votre machine. Ce n'est pas un argument de 10 000 euros, mais c'est le genre de multiplicateur qui rend raisonnable de faire plus d'itérations : et dans le paper, la qualité croît avec la quantité de tâches, pas avec l'élégance du montage. Les prix d'API et l'énergie sont les hypothèses d'un batch typique ; remesurez-les pour votre cas.
Et les limites ?
Honnêteté, car le synthétique a une frontière que le paper lui-même délimite :
- Distribution décalée : l'environnement synthétique imite le schéma des outils, pas les bizarreries réelles — réponses inattendues, messages d'erreur, latence qui varie. Un agent trop entraîné sur le synthétique peut bien performer en simulation et moins bien en production. Le paper le gère en calibrant le taux d'échec ; vous le gérerez en validant l'agent sur une série d'appels réels tenus de côté, avant de vous fier à quoi que ce soit.
- Plafond du modèle : les tâches synthétiques améliorent la politique d'un modèle, elles ne créent pas des capacités qui n'existent pas. Un modèle qui ne sait pas faire de tool calling à la base n'apprend pas par magie avec les tâches synthétiques.
- Validation : le taux de réussite mesuré dans un environnement synthétique est un proxy. La métrique qui compte reste celle sur l'environnement de destination, même s'il est petit.
Comment l'utiliser, en pratique
Si vous construisez un agent local qui doit apprendre vos outils, le pattern que le paper suggère se réduit à quatre étapes :
- Écrivez le schéma de vos outils (nom, paramètres, types de réponse, modes d'échec) — c'est le contrat que l'environnement synthétique doit respecter.
- Générez les tâches synthétiques en local : un modèle sur votre matériel produit entrées, résultats d'outils, scénarios d'erreur. C'est là qu'il faut un grand contexte et de la répétition — et c'est précisément le cas où la KV cache vous fait sentir la RAM que vous avez, pas celle que vous auriez attendue.
- Réglez le mélange d'échecs et mesurez le taux de réussite sur un sous-ensemble de validation qui n'entre pas dans l'entraînement.
- Validez en production avec une série d'appels réels : si l'écart entre le synthétique et le réel est petit, le montage a fonctionné.
Si votre pile d'agents tourne déjà sur Ollama, la comparaison des moteurs vous dit où est le goulot d'étranglement — parce que dans un pipeline de génération de tâches synthétiques, le goulot est presque toujours l'inférence, pas les données.
Sources
En résumé
SynthAPI montre qu'un agent tool-use peut s'entraîner dans un environnement synthétique contrôlé, avec la même structure que les outils réels mais des échecs réglables. Le nombre de tâches synthétiques croît logarithmiquement avec le taux de réussite visé : de 90 à 95 points de pourcentage, le coût en données double, et tous les cas d'usage ne paient pas ce saut. Faire tourner le batch de génération sur votre propre matériel — le calcul ci-dessus montre ~1,60 € d'énergie contre ~158 € d'API pour 10 000 tâches — multiplie le nombre d'itérations possibles à budget égal, et garde les données d'entraînement chez vous. La limite est la fidélité à la distribution réelle : la validation sur des appels réels reste le dernier arbitre.
Article généré par IA
Dans ces parcours
Vous avez aimé cet article ?
Abonnez-vous à la newsletter pour recevoir de nouveaux tutoriels et guides.

