Outils d'agent : Appels, recherche et code

Avec GPT-5.6, nous avons publié l'Appel d'Outils Programmatique, ce qui est une bonne occasion de récapituler les outils d'agent et les moyens de garder les modèles concentrés à mesure que l'utilisation des outils augmente.

Demandez à un agent du support pourquoi la commande A-104 est en retard et il pourrait lire la commande, appeler le transporteur et expliquer le retard. Cet échange cache une boucle : le modèle demande une action, un runtime l'exécute, et le résultat revient. Les outils intégrés, MCP, les compétences, la Recherche d'Outils et l'Appel d'Outils Programmatique modifient ce que le modèle voit et ce qui revient.

1. Appel d'Outils 101 : le modèle demande ; l'application agit

Avec une fonction détenue par le client, le modèle n'exécute pas votre code. Il renvoie un nom d'outil, des arguments JSON et un ID d'appel. Votre application vérifie la demande, exécute la fonction et renvoie function_call_output avec le même ID.

La boucle d'outil détenue par le client : aucune action externe n'a lieu tant que votre application n'exécute pas l'étape 3. Généré avec GPT-Image-2 dans Codex.

En Python, renvoyer function_call_output redonne le contrôle au modèle :

1import json
2from openai import OpenAI
3
4client = OpenAI()
5
6def get_order(order_id): return {"order_id": order_id, "promised_date": "2026-07-13"}
7
8order_tool = {
9    "type": "function", "name": "get_order", "strict": True,
10    "description": "Renvoie la date de livraison promise pour une commande.",
11    "parameters": {
12        "type": "object",
13        "properties": {"order_id": {"type": "string"}},
14        "required": ["order_id"], "additionalProperties": False,
15    },
16    "output_schema": {
17        "type": "object",
18        "properties": {
19            "order_id": {"type": "string"}, "promised_date": {"type": "string"},
20        },
21        "required": ["order_id", "promised_date"], "additionalProperties": False,
22    },
23}
24
25first = client.responses.create(
26    model="gpt-5.6", tools=[order_tool], input="Pourquoi la commande A-104 est-elle en retard ?",
27    tool_choice={"type": "function", "name": "get_order"},
28)
29call = next(item for item in first.output if item.type == "function_call")
30result = get_order(**json.loads(call.arguments))
31
32final = client.responses.create(
33    model="gpt-5.6",
34    tools=[order_tool],
35    input=[*first.output, {
36        "type": "function_call_output",
37        "call_id": call.call_id,
38        "output": json.dumps(result),
39    }],
40)
41print(final.output_text)

Le harnais répète cette boucle jusqu'à ce que le modèle renvoie un message final. Les schémas stricts maintiennent des arguments bien formés ; l'exécuteur vérifie toujours les autorisations.

2. L'exécution des outils peut se faire à différents endroits

Les outils intégrés, y compris la recherche web, la recherche de fichiers et le shell hébergé, peuvent s'exécuter dans l'infrastructure d'OpenAI. Un serveur MCP distant expose et exécute des outils à distance ; Responses prend en charge ces serveurs et les connecteurs maintenus par OpenAI, demandant une approbation par défaut avant de partager des données.

Une compétence regroupe des instructions et des fichiers. Attachez-la au shell hébergé et le modèle peut suivre sa procédure ou exécuter ses scripts. Il voit d'abord le nom, la description et le chemin de la compétence, puis lit SKILL.md lorsqu'elle est sélectionnée.

1carrier_mcp = {
2    "type": "mcp",
3    "server_label": "carrier",
4    "server_url": "https://example.com/mcp",
5    "allowed_tools": ["track_package"],
6    "require_approval": "always",
7}
8incident_shell = {
9    "type": "shell",
10    "environment": {
11        "type": "container_auto",
12        "skills": [{"type": "skill_reference", "skill_id": "skill_..."}],
13    },
14}
15
16response = client.responses.create(
17    model="gpt-5.6",
18    tools=[carrier_mcp, incident_shell],
19    input="Enquêtez sur les raisons du retard de la commande A-104 en utilisant la compétence incident.",
20)

Le harnais unifie ces surfaces : MCP expose des outils distants, les compétences fournissent des procédures et des fichiers, et le harnais contrôle où les appels sont exécutés.

3. Recherche d'Outils : quand le contexte devient la contrainte

Chaque définition d'outil visible prend du contexte. Les noms, descriptions et schémas utilisent des tokens d'entrée, les outils similaires deviennent plus difficiles à distinguer, et un grand catalogue MCP devient une grande invite.

La Recherche d'Outils permet aux modèles compatibles GPT-5.4 ou ultérieur de charger des définitions différées uniquement lorsque nécessaire :

1shipping = {
2    "type": "namespace", "name": "shipping",
3    "description": "Outils de suivi de commande et de livraison.",
4    "tools": [{
5        "type": "function", "name": "get_delivery_eta",
6        "description": "Renvoie l'ETA pour une commande.",
7        "defer_loading": True,
8        "parameters": {
9            "type": "object", "required": ["order_id"],
10            "properties": {"order_id": {"type": "string"}},
11            "additionalProperties": False,
12        },
13    }],
14}
15
16response = client.responses.create(
17    model="gpt-5.6",
18    input="Quand la commande A-104 arrivera-t-elle ?",
19    tools=[shipping, {"type": "tool_search"}],
20)

La Recherche d'Outils Hébergée choisit parmi les outils déclarés dans la demande ; la recherche exécutée par le client peut renvoyer des outils pour le locataire ou le projet en cours. La recherche ajoute une étape, donc les petits catalogues peuvent en tirer peu de bénéfice. Une fonction différée expose toujours son nom et sa description, tandis qu'un namespace ou un serveur MCP peut commencer par une courte description. Les outils chargés sont ajoutés pour préserver le préfixe du cache. Les compétences diffèrent les instructions et les fichiers ; la Recherche d'Outils diffère les schémas appelables.

4. Appel d'Outils Programmatique pour un travail multi-outils prévisible

Les appels directs renvoient chaque résultat au modèle. C'est utile lorsqu'un résultat change la décision suivante, mais les jointures simples, les filtres et les recherches parallèles peuvent remplir le contexte avec des données que le code pourrait réduire.

L'Appel d'Outils Programmatique permet à GPT-5.6 d'écrire du JavaScript qui s'exécute dans un runtime V8 frais et isolé. V8 exécute JavaScript dans Chrome, mais ce n'est ni un navigateur ni Node.js. Il prend en charge await de niveau supérieur, les boucles, les conditions et les appels parallèles, sans installation de paquets, accès réseau direct, système de fichiers à usage général, sous-processus, console ou état persistant.

Trois appels directs comparés à trois appels parallèles dans le runtime V8 isolé. Généré avec GPT-Image-2 dans Codex.

Lorsqu'un programme atteint une fonction détenue par le client, il se met en pause pendant que votre application exécute l'appel ; le renvoi de son call_id et de son caller le reprend. carrier_mcp peut également se mettre en pause pour approbation, et output_schema indique à JavaScript quels champs il peut inspecter.

1for tool in (order_tool, carrier_mcp):
2    tool["allowed_callers"] = ["programmatic"]
3
4response = client.responses.create(
5    model="gpt-5.6",
6    tools=[
7        order_tool,
8        carrier_mcp,
9        {"type": "programmatic_tool_calling"},
10    ],
11    input="Comparez la commande A-104 avec le statut du transporteur et renvoyez les preuves du retard.",
12)

Les programmes peuvent appeler des outils de fonction et personnalisés, MCP, apply_patch, shell et interpréteur de code, mais pas la recherche web ou la recherche de fichiers. La Recherche d'Outils de niveau supérieur doit charger un outil différé avant le démarrage du programme ; un programme en cours d'exécution ne peut pas rechercher d'outils.

Gardez les appels directs lorsque l'étape suivante nécessite un jugement du modèle, une approbation, des citations ou un effet secondaire. Utilisez un programme lorsque des règles claires permettent au code de renvoyer un résultat plus petit sans perdre de preuves. L'exécution hébergée modifie l'endroit où le travail s'exécute, la Recherche d'Outils modifie les définitions qui entrent dans le contexte, et les appels programmatiques modifient les résultats renvoyés. Combinez-les lorsqu'une évaluation montre que l'exactitude est maintenue tandis que les tokens, la latence ou le coût s'améliorent.

Bonus : gardez les longues boucles d'outils sur une seule connexion

Si un agent bascule à plusieurs reprises entre le modèle et les outils détenus par le client, le mode WebSocket de Responses peut réduire la surcharge de continuation. Le socket connecte votre harnais à Responses ; il ne fait pas fonctionner les outils plus rapidement. Il accepte les mêmes champs response.create pour les fonctions, MCP, la Recherche d'Outils et l'Appel d'Outils Programmatique, bien que la documentation ne mesure pas toutes les combinaisons. OpenAI a observé jusqu'à 40 % d'exécution plus rapide dans les déploiements avec 20 appels ou plus, alors mesurez votre flux de travail.

Essayez-le avec votre agent

Prenez un Appshot de cet article, ouvrez votre projet d'agent dans Codex et collez :

Utilisez cet article et la base de code actuelle pour améliorer le chemin d'outils de cet agent. Regroupez les outils volumineux ou peu utilisés et activez la Recherche d'Outils pour les différer. Trouvez les étapes délimitées où l'Appel d'Outils Programmatique peut exécuter des appels en parallèle et renvoyer des résultats compacts. Conservez les décisions sémantiques, les approbations, les citations et les effets secondaires comme des appels directs. Comparez les deux chemins en termes de justesse, de couverture des preuves, de succès des outils, de tokens, de latence, de tentatives et de coût avant de modifier le routage de production.