Aller au contenu principal
Cas d’usageAvancé8 min de lecture

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

i
iaLocale Team
•
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 :

VoieHypothèse de coût10 000 tâchesCoû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 :

  1. É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.
  2. 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.
  3. 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.
  4. 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

Partager :

Vous avez aimé cet article ?

Abonnez-vous à la newsletter pour recevoir de nouveaux tutoriels et guides.

Après l'inscription, vous recevez un e-mail de confirmation (double opt-in). Sans confirmation, nous n'envoyons rien. Pas de spam, promis.

Articles Correlés

Ressources liées

Outils et ressources des archives iaLocale pertinents pour ce contenu.

🧩

JunctionBox

Plateforme de pilotage pour agents de coding (Claude Code, Codex, Grok) et modèles Ollama sur votre propre matériel : mémoire partagée entre agents, tool use gardé pour les petits modèles, modèles locaux même sans GPU (BitNet testé à ~16 tokens/s avec moins de 2 Go de RAM). Inclut des applis TV, un lanceur pour tablette et des plugins extensibles.

🌐

Kitesurf

Logiciel

Navigateur web stateless open source de Cloudflare, conçu pour les agents IA : aucune session persistante, un environnement propre pour chaque tâche d'automatisation web. Annoncé en 2026, open-sourcé en novembre 2026.

🦉

Qwen3.8-Flash-Next

Modèles

MoE open-weight de la famille Qwen3.8 pensé pour l'agentique : 125B de paramètres avec seulement 6B activés, plus 51B d'embedding n-gram et 4B de MTP. Attention hybride sur 48 couches (12 micro-blocs : 3× Gated DeltaNet → MoE, 1× Qwen Sparse Attention → MoE), 512 experts dont 10 routés + 1 partagé. Contexte natif 262K, extensible à 1M avec scaling RoPE (YaRN).

🌊

Ripple-65B Preview

Modèles

Modèle dense de 64,8 milliards de paramètres de Ricursive Intelligence, Apache 2.0 : préentraînement depuis zéro sur 12 000 milliards de token, contexte jusqu'à 1M, architecture thin-and-deep (d_model 5120, 80 couches). Visé sur le coding agentique : 80,5 sur TerminalBench 2.1, devant des MoE open-weight jusqu'à 10x plus grands. Checkpoint NVFP4 (MLP 4 bits, attention BF16) pensé pour une seule workstation à 128 Go unifiés (DGX Spark), ~19,5 tok/s en une requête.