L'appel de fonction classique a une forme que chaque développeur d'agent connaît par cœur. Le modèle demande un appel d'outil, votre application l'exécute, vous ajoutez le résultat, et le modèle demande le suivant. Quatre outils, quatre allers-retours. Quarante outils, quarante. Chaque passage ajoute de la latence réseau et un contexte refacturé. Lorsque OpenAI a rendu GPT-5.6 généralement disponible le 9 juillet 2026, il a mis fin à ce cycle répétitif : l'appel d'outil programmatique dans l'API de Réponses.
L'idée est directe. Au lieu de renvoyer les appels d'outils un par un pour que votre code les exécute en boucle, le modèle écrit du JavaScript qui orchestre lui-même plusieurs appels d'outils. Ce code s'exécute dans un environnement d'exécution V8 isolé, sans accès réseau. Vos outils restent le seul moyen pour le code d'interagir avec le monde extérieur, de sorte que la limite de sécurité que vous prenez déjà en compte avec les appels de fonction OpenAI reste exactement la même. Ce qui change, c'est l'orchestration : les boucles, les conditions et l'agrégation qui résidaient auparavant dans votre application.
Ce changement impacte également votre côté de l'API. Chaque outil que vous exposez est désormais un contrat que le modèle peut appeler par salves de dizaines plutôt qu'un seul appel prudent par tour. La précision du schéma, la forme des erreurs et le comportement de débit sont plus importants qu'ils ne l'étaient la semaine dernière. Cet article couvre ce qui a été livré, pourquoi l'ancienne boucle est problématique, ce qui reste inchangé, et comment préparer vos points d'accès d'outils avec Apidog avant de les confier au modèle.
TL;DR
- GPT-5.6 a été mis à la disposition générale le 9 juillet 2026. Lors de cette mise à disposition, l'API de Réponses a gagné l'appel d'outil programmatique, confirmé dans la documentation développeur d'OpenAI.
- Au lieu d'un appel d'outil par aller-retour, le modèle écrit du JavaScript qui compose des boucles, des conditions et des agrégations sur vos outils.
- Le code généré s'exécute dans un bac à sable V8 isolé sans accès réseau. Vos définitions d'outils restent le seul chemin vers les systèmes externes, donc la limite de sécurité ne change pas.
- La latence et le coût des jetons ne se cumulent plus avec le nombre d'appels d'outils, ce qui était le point faible des boucles d'agents classiques.
- La fonctionnalité est récente ; les paramètres de requête exacts et les limites se trouvent dans la référence de l'API d'OpenAI, alors lisez-la avant de développer.
- Testez et simulez chaque point d'accès d'outil avant que le modèle ne l'orchestre ; une ambiguïté de schéma devient un bug répété en boucle.
Ce qui a été livré le 9 juillet
GPT-5.6 est arrivé sous la forme d'une famille à trois niveaux : gpt-5.6-sol pour un raisonnement approfondi, gpt-5.6-terra pour un travail équilibré, et gpt-5.6-luna pour un volume rapide et rentable. L'alias simple gpt-5.6 redirige vers Sol. Les trois sont disponibles en libre-service via l'API sans restriction de plan, après une prévisualisation limitée de deux semaines qui s'est terminée lorsque la restriction d'accès a été levée le 8 juillet.
La famille de modèles a reçu la majeure partie de l'attention le jour du lancement, mais la nouvelle surface d'API est l'histoire la plus importante pour les développeurs d'agents. Selon la couverture du lancement de MarkTechPost et la propre documentation d'OpenAI, l'API de Réponses a intégré quatre nouveautés lors de sa disponibilité générale : l'appel d'outil programmatique, une version bêta multi-agents, le raisonnement persistant entre les tours, et des paramètres de détails visuels qui préservent les dimensions originales des images.
L'appel d'outil programmatique est le point central. OpenAI le décrit comme le modèle écrivant du JavaScript pour orchestrer les appels d'outils, exécuté dans un environnement d'exécution V8 isolé sans accès réseau. Le modèle cesse d'être un demandeur tour par tour et devient l'auteur de la couche d'orchestration.
La boucle que l'appel d'outil programmatique remplace
Voici l'appel de fonction classique contre l'API de Réponses, la forme que presque tous les agents de production utilisent aujourd'hui :
import OpenAI from "openai";
const client = new OpenAI();
const tools = [
{
type: "function",
name: "get_flight_status",
description: "Return live status for a flight by IATA flight number.",
parameters: {
type: "object",
properties: {
flight_number: {
type: "string",
description: "IATA flight number, for example SQ317"
}
},
required: ["flight_number"]
}
}
];
let response = await client.responses.create({
model: "gpt-5.6",
input: "Which of these 12 flights are delayed: SQ317, BA15, UA857...",
tools
});
Le modèle ne peut pas répondre sans données, il émet donc un appel de fonction. Votre code effectue la recherche, ajoute un élément function_call_output et appelle à nouveau l'API :
// One round trip per tool call. This loop is the tax.
while (hasFunctionCalls(response)) {
const outputs = await executeToolCalls(response); // your code, your infra
response = await client.responses.create({
model: "gpt-5.6",
previous_response_id: response.id,
input: outputs,
tools
});
}
Pour 12 vols, cette boucle peut s'exécuter 12 fois, et chaque itération paie doublement. Premièrement en latence : un aller-retour réseau complet vers OpenAI plus le temps du modèle, sérialisé, car l'appel N+1 dépend du modèle voyant le résultat N. Deuxièmement en jetons : les résultats des outils s'accumulent dans le contexte, de sorte que les dernières itérations retraitent tout ce que les premières ont produit. Enchaînez les agents et l'accumulation devient problématique : un agent en cinq étapes où chaque étape enveloppe une boucle de dix appels représente cinquante invocations de modèle facturées.
Rien de cette boucle n'est de l'intelligence. C'est de la plomberie, et jusqu'à cette semaine, le modèle n'avait aucun moyen d'écrire la plomberie lui-même.
Comment le mode programmatique change la forme
Avec l'appel d'outil programmatique, le modèle répond différemment à la question du vol : il écrit un court programme JavaScript qui parcourt les douze numéros de vol, appelle get_flight_status pour chacun, filtre les statuts retardés, trie par durée de retard, et renvoie l'agrégat. Le bac à sable exécute ce programme. Vos outils font toujours le vrai travail ; le flux de contrôle autour d'eux appartient désormais au modèle.
Trois propriétés rendent cela fonctionnel plutôt qu'alarmant :
- L'environnement d'exécution est isolé. OpenAI exécute le JavaScript généré dans un bac à sable V8 sans accès réseau. Le code ne peut pas récupérer une URL, ouvrir une socket ou exfiltrer quoi que ce soit par lui-même.
- Les outils sont la seule sortie. Chaque effet externe passe par la surface d'outils que vous avez définie. Si vous n'avez pas exposé un outil
delete_record, aucun code généré ne peut supprimer un enregistrement. - Le flux de contrôle devient expressif. Boucles, conditions, sorties anticipées, agrégation des résultats : des schémas qui prenaient N allers-retours se produisent désormais à l'intérieur d'un seul cycle de réponse.
| Appel de fonction classique | Appel d'outil programmatique | |
|---|---|---|
| Qui écrit le flux de contrôle | Votre application | Le modèle, en JavaScript |
| Allers-retours pour N appels d'outils | N, sérialisé | Un cycle de réponse |
| Où l'orchestration s'exécute | Votre infrastructure | Bac à sable V8 isolé, pas de réseau |
| Comment les outils s'exécutent | Votre code les invoque | Toujours via votre surface d'outils déclarée |
| Limite de sécurité | Définitions d'outils | Définitions d'outils, inchangées |
Ce qui reste inchangé
Vous définissez toujours les outils avec des noms, des descriptions et des paramètres de schéma JSON, exactement comme dans le code ci-dessus. Le modèle ne peut composer des appels qu'aux outils que vous avez déclarés, ce qui signifie que la question « que peut faire cet agent à mes systèmes » a la même réponse qu'auparavant : tout ce que votre surface d'outils permet, et rien d'autre.
La qualité du schéma est plus importante maintenant, et non moins. Dans la boucle classique, une description de paramètre vague produisait un mauvais appel que vous pouviez détecter et corriger avant le prochain aller-retour. En mode programmatique, la même imprécision peut être intégrée dans une boucle et répétée à chaque itération avant que vous ne voyiez un seul résultat. Les habitudes que vous avez développées pour les sorties structurées se transfèrent directement : types stricts, énumérations pour les ensembles fermés, descriptions indiquant les unités et les formats, champs requis qui sont réellement requis.
Limites et questions ouvertes
Cette capacité est récente. Quelques précautions avant de reconstruire votre pile d'agents autour de cela :
- Les paramètres de requête exacts, les limites d'exécution et le comportement de dépassement de délai appartiennent à la référence de l'API et au guide du modèle d'OpenAI. Les noms des paramètres peuvent changer lors du peaufinage qui suit tout lancement GA, alors lisez la référence avant d'écrire du code pour cette fonctionnalité.
- Le débogage est une nouvelle surface. Lorsque l'orchestration résidait dans votre référentiel, vous pouviez définir un point d'arrêt ; maintenant, une partie du flux de contrôle est générée à nouveau pour chaque requête. La journalisation de la séquence d'appels d'outils effectuée par le bac à sable devient une tâche d'observabilité essentielle.
- Il n'y a pas encore d'historique de production. Les notes de Simon Willison sur GPT-5.6 dès le premier jour constituent un bon enregistrement de ce que les tests indépendants révèlent ; attendez-vous à y voir apparaître des arêtes vives avant que les documents officiels ne les mentionnent.
- Un ordre de déploiement judicieux : commencez par des outils en lecture seule, observez l'orchestration générée, vérifiez la comptabilisation des jetons par rapport à votre ancienne boucle, et seulement ensuite exposez les outils avec des effets secondaires.
Vos outils sont désormais une API appelée par le code de quelqu'un d'autre
Avec l'appel de fonction classique, un outil était appelé une fois par aller-retour, avec une boucle écrite par un humain décidant du rythme et de l'ordre. Avec l'appel d'outil programmatique, le code généré appelle vos outils par salves, se ramifie en fonction de leurs réponses, et agrège leur sortie. Chaque outil est un contrat d'API consommé par un client écrit par une machine que vous ne révisez jamais avant son exécution.
Cela élève le niveau d'exigence sur quatre points :
- Précision du schéma. Indiquez les unités, les formats et les plages dans chaque description de paramètre. Un format de date ambigu n'est plus un seul mauvais appel ; c'est une boucle d'appels.
- Formes d'erreur. Le code généré se ramifiera en cas d'échec. Un outil qui renvoie un 200 avec un message d'erreur enfoui dans une chaîne trompera toute orchestration écrite contre votre schéma. Retournez des codes de statut honnêtes et des corps d'erreur structurés.
- Idempotence et comportement de débit. Douze appels qui arrivaient autrefois sur une minute peuvent maintenant arriver en une seule salve. Sachez ce que votre point d'accès fait sous ce schéma avant que le modèle ne le découvre pour vous.
- Latence. Un outil qui prend huit secondes était tolérable une fois par tour. À l'intérieur d'une boucle de douze itérations, cela définit votre temps de réponse.
C'est là qu'un véritable établi d'API trouve sa place. Définissez ou importez la spécification de chaque point d'accès d'outil, envoyez des requêtes de test et confirmez que le schéma de réponse correspond à ce que votre définition d'outil promet. Puis allez plus loin : simulez l'API de l'outil afin de pouvoir exercer l'orchestration avec des données factices prévisibles sans toucher à la production. Téléchargez Apidog et son serveur de maquette intégré servira des réponses conformes au schéma pour chaque point d'accès que vous avez défini, afin que vous puissiez donner au modèle une surface d'outils complète et observer comment il orchestre avant de toucher un seul enregistrement réel.
Les autres fonctionnalités GA en bref
L'appel d'outil programmatique n'est pas arrivé seul. Deux ajouts adjacents à l'API de Réponses sont importants ici :
- Multi-agents, en bêta : exécution parallèle de sous-agents gérée par l'API. Stade précoce, à surveiller plutôt qu'à parier dessus.
- Raisonnement persistant : contexte de raisonnement réutilisé entre les tours via
reasoning.context, de sorte que les longues sessions d'agents cessent de redériver les mêmes conclusions à chaque tour.
Les deux se combinent avec l'appel d'outil programmatique : un agent qui conserve son raisonnement entre les tours et écrit sa propre orchestration effectue beaucoup moins de travail redondant par tâche.
Appel d'outil programmatique vs mode Ultra
Le lancement a également apporté le mode Ultra, et les deux sont confondus car ils font tous deux plus par requête. Ils résolvent des goulots d'étranglement différents.
Ultra est un paramètre multi-agents qui exécute quatre agents en parallèle par défaut, dépensant délibérément plus de jetons pour réduire le temps réel ; selon OpenAI, il élève Terminal-Bench 2.1 de 88,8% à 91,9%. Il est disponible dans ChatGPT Work pour les plans Pro et Entreprise, et dans Codex à partir du plan Plus. L'appel d'outil programmatique est une capacité d'API où un agent orchestre ses outils en code. Ultra parallélise la réflexion ; l'appel d'outil programmatique réduit les allers-retours d'exécution. L'analyse complète se trouve dans notre article sur le mode Ultra de GPT-5.6, mais en bref : si votre goulot d'étranglement est la latence des appels d'outils, vous voulez l'appel d'outil programmatique ; si c'est le temps de délibération sur des problèmes difficiles, vous voulez le mode Ultra.
FAQ
Dois-je réécrire mes définitions d'outils existantes ?
Non. Les outils conservent la même forme de schéma JSON que celle présentée dans le code ci-dessus, et les définitions écrites pour l'appel de fonction classique sont transférables. Le travail utile consiste à les affiner : ajoutez des énumérations, spécifiez les formats et rendez les descriptions suffisamment précises pour que le code généré ne puisse pas les mal interpréter.
Le JavaScript généré peut-il accéder à Internet ?
Non. Le code s'exécute dans un environnement d'exécution V8 isolé sans accès réseau, et vos outils déclarés sont son seul moyen d'affecter quoi que ce soit en dehors du bac à sable. Cela fait de votre surface d'outils l'intégralité du modèle de risque, alors auditez les outils que vous exposez avec la même prudence que vous accorderiez à une API publique.
Quels modèles GPT-5.6 prennent en charge l'appel d'outil programmatique ?
OpenAI le documente comme surface d'API de Réponses pour la famille GPT-5.6, et les trois niveaux (gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna) sont en libre-service pour tout compte API. Vérifiez la référence de l'API pour les détails spécifiques à chaque niveau avant de vous engager sur l'un d'eux. Pour une configuration clé et un premier aperçu des requêtes, consultez comment utiliser l'API GPT-5.6.
En quoi cela diffère-t-il de l'interprète de code ?
L'interprète de code exécute le code comme livrable : analyses, graphiques, transformations de fichiers. L'appel d'outil programmatique génère du code dont le seul travail est de coordonner vos outils déclarés ; le livrable est le résultat agrégé des outils, et non le code lui-même.
Où cela vous mène
La boucle d'aller-retour était la partie la moins intéressante de chaque agent que vous avez déployé, et GPT-5.6 l'a rendue facultative. L'orchestration est passée au modèle ; la responsabilité de disposer d'API d'outils propres, précises et bien conçues vous incombe désormais, avec plus de poids qu'auparavant.
La prochaine étape est concrète. Choisissez un flux de travail à forte lecture, écrivez ou affinez les schémas d'outils dont il a besoin, et soumettez chaque point d'accès au client API et au serveur de maquette d'Apidog jusqu'à ce que le contrat tienne bon sous les appels en rafale et les mauvaises entrées. Lorsque le modèle commencera à écrire du code contre vos outils, vous voudrez que ce code lise à partir d'une surface que vous avez déjà testée.