Les agents de code IA changent le développement : comment Claude Code et GPT Agent appellent des outils et exécutent du code via JSON

En un coup d'œil

Idée	Une ligne	Tombe sur
Coding Agent	Un runtime qui peut lire un dépôt, éditer des fichiers et lancer des commandes	Agent loop
Claude Code	Un agent de code local dans le terminal	tool_use JSON
GPT Agent	Codage et computer use en session / bac à sable	tool_calls / code
JSON	Le contrat des noms, arguments et résultats	Schema / payload

Retenir la coupure : le modèle remplit des objets, l'hôte exécute, la boucle rend patches et tests continus. Changer de marque ; la chaîne d'appel JSON reste.

Un Coding Agent n'est pas une boîte de chat qui écrit du code

Un modèle de complétion remplit la ligne suivante. Un modèle de chat explique une fonction. Un Coding Agent est une troisième chose : un runtime qui met le modèle en boucle — observer l'état du dépôt, proposer l'étape suivante, appeler un outil externe, digérer le résultat, puis continuer, s'arrêter ou passer la main.

Un Coding Agent livrable en 2026 est en général un trio :

• Le modèle : il n'émet que du texte ou un objet structuré. Il ne touche pas le disque.
• Un catalogue d'outils : lire, éditer, lancer, chercher ; parfois un navigateur ou MCP.
• L'hôte : parser le JSON, appliquer les portes, exécuter vraiment, écrire le résultat dans le tour suivant.

Si vous pliez encore Agent, Tool Calling et Function Calling en un mot, commencez par Guide complet de l'agent IA. Cet article traite une forme de produit : un Coding Agent qui travaille contre un vrai dépôt.

Ce qui a changé, c'est la boucle, pas l'éditeur

Pendant une décennie, la complétion IDE a raccourci la frappe. Pendant deux ans, les fenêtres de chat ont rapproché les défauts. Un Coding Agent change une troisième chose : qui écrit le premier correctif exécutable.

Une journée typique n'est plus « les humains finissent, puis la CI vérifie ». Plus souvent :

1. Un humain écrit l'intention : réparer ce test en échec, ou ajouter un champ à cette API.
2. L'agent tourne la boucle : lire le dépôt, chercher des symboles, éditer des fichiers, lancer des tests, laisser une trace d'appels d'outils.
3. Les humains relisent le diff et la trace : pas chaque frappe, mais types, tests et permissions restent.

Ce n'est pas « l'IA fait votre métier ». Le premier jet vient maintenant d'une boucle ; les humains portent la forme et les effets de bord. Capturer outils et flux en Schema — voir JSON Schema et flux d'agents IA.

La boucle ne fait qu'une chose : remplir du JSON, puis le lire

Les pages produit disent « écrit du code de façon autonome ». En ingénierie, un tour est en général quatre sauts :

1. Observer : l'espace de travail, la sortie de test et le dernier résultat d'outil entrent dans le contexte.
2. Proposer : le modèle émet un nom d'outil et un objet d'arguments — il ne fait pas open() lui-même.
3. Exécuter : l'hôte valide, lance une commande ou édite un fichier. Les effets de bord se passent ici.
4. Réécrire : stdout, le correctif et le code de sortie deviennent le prochain objet visible.

Omettre une porte, et le JSON est une commande. Garder les quatre sauts, et vous avez une session rejouable. Pourquoi l'IA a besoin de JSON Schema l'a déjà dit : le Schema est le contrat, pas « veuillez renvoyer du JSON » dans un prompt.

Claude Code : une surface d'outils dans le terminal

Claude Code est l'agent de code local d'Anthropic : il tourne dans votre terminal contre le dépôt courant. Côté modèle, il utilise des blocs de contenu de l'API Messages. Ce que vous voyez chaque jour est un flux de tool_use.

La surface d'outils par défaut est étroite — et cette étroitesse rend la relecture possible :

• Read / Glob / Grep : regarder d'abord, puis éditer.
• Edit / Write : changer le dépôt par remplacement exact ou écriture de fichier entier.
• Bash : lancer des tests, installer des deps, exécuter des scripts.
• MCP : plier des systèmes externes dans la même table d'outils JSON. Détails dans MCP Tool Schema vs Function Calling.

Le modèle n'envoie pas un paragraphe « veuillez éditer ce fichier ». Il envoie un objet validable :

{
  "type": "tool_use",
  "id": "call_read_1",
  "name": "Read",
  "input": {
    "path": "src/billing/refund.py"
  }
}

Quand l'hôte a fini, il écrit aussi un objet. stdout peut être long ; l'entrée reste tool_result, pas une bulle de chat :

{
  "type": "tool_result",
  "tool_use_id": "call_bash_4",
  "content": {
    "stdout": "12 passed, 1 failed",
    "exit_code": 1
  }
}

Le mode auto et les portes de confirmation décident si ce saut attend un humain. Couper les portes, et la boucle finira Bash toute seule — voilà pourquoi le développement a accéléré, et pourquoi le rayon d'explosion a grandi. Pour la surface de sécurité, voir Incidents Claude et JSON d'outils et Sécurité des agents IA et validation JSON.

GPT Agent : sessions, bacs à sable et Function Calling

Le côté OpenAI a plus de noms : ChatGPT Agent, Codex, Responses API, GPT-6 Astra. Les coques diffèrent ; la forme d'appel reste Function Calling : déclarer tools[], proposer tool_calls, mettre un objet stringifié dans arguments.

Un appel lié au code ressemble à ceci :

{
  "tool_calls": [{
    "id": "call_7f2a",
    "type": "function",
    "function": {
      "name": "run_code",
      "arguments": "{\"language\":\"python\",\"code\":\"from pathlib import Path\\nprint(Path('src').exists())\"}"
    }
  }]
}

La différence avec Claude n'est pas « sait-il écrire du code ». C'est comment la surface d'outils est assemblée :

• Interpréteur de code / bac à sable : plier un calcul en plusieurs étapes en un run_code ou python pour couper les allers-retours.
• Computer use : actions navigateur et bureau sont un autre ensemble de mouvements structurés.
• Codex / CLI : plus proche d'un agent de code au niveau dépôt ; la table redevient lire, éditer, lancer.

Guide GPT-6 Astra a déjà nommé la même discipline : finir plus sûrement « choisir un outil → l'appeler → renvoyer un objet ». Pour les développeurs, cela veut dire que correctifs et sorties de test doivent être reconstructibles depuis une trace JSON — pas depuis une phrase « je l'ai déjà réparé ».

Où le code s'exécute-t-il vraiment ? Pas dans le modèle

C'est la phrase que l'on écrit mal. Un grand modèle n'exécute pas Python et ne spawn pas un processus. Il n'émet que :

• Un nom d'outil : Bash, Read, python, apply_patch.
• Un objet d'arguments : command, path, old_string, code.
• Parfois un texte de correctif : d'abord un champ, puis l'hôte l'écrit sur disque.

Ce qui exécute vraiment le code, c'est l'hôte : un processus local, un conteneur ou un bac à sable cloud. Permissions fichier et réseau appartiennent à la politique de l'hôte, pas aux poids du modèle. Un Schema d'outil resserré ressemble à ceci :

{
  "name": "Bash",
  "description": "Run a shell command in the workspace",
  "inputSchema": {
    "type": "object",
    "properties": {
      "command": { "type": "string" },
      "timeout_ms": { "type": "integer", "maximum": 120000 }
    },
    "required": ["command"],
    "additionalProperties": false
  }
}

additionalProperties: false n'est pas de la pédanterie. Un object large laisse le modèle glisser un hôte cible ou un script en plus. Secrets, cookies et bases internes restent sur l'hôte. Ils n'entrent pas dans l'objet d'arguments.

Claude Code contre GPT Agent : vous n'achetez pas la même coque

Pas plus malin / moins malin — où vous accrochez la boucle :

Changer de marque ; la boucle reste. Stabilisez le contrat d'outils et le monde d'exécution, pas une peau de chat. DeepSeek a fait de l'hôte une infrastructure remplaçable — voir DeepSeek Harness et infrastructure d'agents de code.

Inspecter la trace, pas la bulle

Après qu'un agent a écrit du code, relisez-le comme le PR d'un collègue : diff, tests, permissions. La couche en plus est la trace d'outils.

• formater les tool_use / tool_calls et vérifiez que le nom et les arguments sont le saut que vous pensiez.
• Utilisez extraire JSONPath pour extraire name, command et path. Ne scannez pas la prose à l'œil.
• JSON Diff contre la trace verte de la semaine dernière. Si la boucle a dérivé, inspectez la table d'outils et la forme des arguments avant de blâmer le modèle.
• Le stdout d'un test en échec appartient à la trace. « Je l'ai réparé » n'est pas un enregistrement.
• Ne collez pas de secrets de production, de dumps clients ou d'URL internes dans un formateur public. JSONSort tourne dans le navigateur sans envoi — adapté à ces objets.

Si la trace peut être reconstruite, la session peut être relue. C'est le prix pour mettre un Coding Agent dans un flux d'équipe, pas un bonus.

Pièges

• Traiter un Coding Agent comme une autocomplétion plus maline. L'autocomplétion édite une ligne ; un agent édite la boucle.
• Croire que le modèle a exécuté le code. L'exécution est sur l'hôte.
• Relire seulement le diff de fichiers, pas le JSON d'outils. La commande a peut-être déjà tourné.
• Donner à Bash un chèque en blanc. Pas de cwd, de délai ni de porte réseau, et la boucle est un incident de production.
• Remplacer le Schema par un prompt. Un contrat doit être validable.
• Stocker la session comme des bulles de chat. Sans tool_result, il n'y a pas d'enregistrement de développement rejouable.

FAQ

Lequel convient mieux à une équipe : Claude Code ou GPT Agent ?

Regardez le monde d'exécution. Si le dépôt est sur votre machine et que vous avez besoin de MCP plus de tests locaux, Claude Code ou Codex CLI est plus proche. Si vous voulez du calcul en bac à sable ou du computer use en session, prenez GPT Agent / Responses. Verrouillez d'abord le Schema d'outils, puis choisissez une coque.

Le modèle peut-il lancer en secret une commande que je n'ai pas approuvée ?

Le modèle ne peut que proposer. Qu'elle tourne dépend des portes de confirmation, d'une allowlist et de l'isolement réseau sur l'hôte. Le mode auto signifie que vous avez pré-approuvé une classe de JSON.

En quoi cela diffère-t-il du Function Calling ordinaire ?

Même forme, rayon différent. Une recherche support est souvent en lecture seule. Les outils d'un Coding Agent peuvent muter le disque et lancer des processus. Schema, délais et audit doivent être plus serrés.

Pourquoi insister sur le JSON plutôt qu'un meilleur prompt ?

Les effets de bord arrivent après le parsing de l'objet. Un prompt influence ce que le modèle remplit ; le Schema et l'hôte décident ce qui peut tourner. Au débogage, les objets battent les adjectifs.

L'agent doit-il pousser en production ?

Non. Laissez-le ouvrir une branche, lancer des tests et laisser une trace. Merge et publication restent des portes stratégiques humaines. La boucle rédige ; la porte expédie.

Conclusion

Les agents de code IA changent le développement non pas en rendant l'éditeur meilleur pour deviner la ligne suivante, mais en faisant de « lire le dépôt → remplir le JSON d'outils → l'hôte exécute → réécrire le résultat » la boucle par défaut. Claude Code et GPT Agent sont deux coques.

À partir d'aujourd'hui, moins débattre de quel modèle écrit mieux le code. Mettez d'abord le Schema d'outils, le monde d'exécution et la trace de session dans le dépôt. Les modèles tournent ; cette chaîne d'appel JSON devrait se stabiliser d'abord.

Pour aller plus loin

• Qu'est-ce qu'un agent IA ? Guide complet Runtime, Tool Calling et contrat JSON
• Ce que DeepSeek Harness a changé Du framework à un hôte d'agent de code remplaçable
• MCP Tool Schema vs Function Calling Frontières de protocole du JSON d'outils
• Pourquoi l'IA a besoin de JSON Schema Schema / Function Calling / Structured Output
• Sécurité des agents IA et validation JSON Ce que la validation peut arrêter — et ce qu'elle ne peut pas
• Boîte à outils locale JSONSort Formater, valider, Diff
• Tous les articles Plus de notes sur JSON et le développement IA

Journal : 2026-09-17 Première publication