Blog • AI / Agent

Comment fonctionnent les AI Coding Agents ? Claude Code, Codex, Xcode 27 Agent, Tool Calling et données JSON expliqués

Ouvrez Claude Code, Codex ou Xcode 27 : l’interface ressemble à un chat. Ce qui modifie vraiment le dépôt, lance les tests et tape le simulateur, ce n’est pas cette réponse en langage naturel.

Un AI Coding Agent fonctionne ainsi : le modèle décide l’étape suivante et émet du Tool Calling ; un harness local ou dans l’IDE exécute l’outil et renvoie des résultats structurés. Arguments et résultats sont presque toujours du JSON.

Cet article explique :

• Quelle couche un Coding Agent ajoute par rapport à la complétion
• La boucle partagée : observer → décider → exécuter → réinjecter
• Pourquoi les arguments de Tool Calling arrivent en chaîne JSON
• Où Claude Code, Codex et le Xcode 27 Agent placent la boîte à outils
• Quelle couche valide JSON / JSON Schema, et comment l’inspecter en local dans JSONNote

Pas une boîte de chat — une boucle

La complétion répond à « quelle est la ligne suivante ». Un Coding Agent répond à « comment finir cet objectif dans un vrai projet » : lire le contexte, choisir un outil, modifier le code, lancer une commande, lire le résultat, décider à nouveau.

Les docs officielles changent les mots. La forme reste. Claude Code l’écrit : rassembler le contexte → agir → vérifier les résultats. Xcode 27 planifie d’abord, puis modifie, puis s’auto-contrôle avec build / test / Preview / simulateur. En dessous, les deux sont :

1. 1
   Observer

   Lire des fichiers, chercher des symboles, regarder le statut git, récupérer les logs de tests en échec. Sans cette étape, le prochain patch est une conjecture.

2. 2
   Décider

   Dans le contexte, le modèle choisit l’étape suivante : relire, rechercher encore, modifier un endroit, lancer une commande, ou vous poser une question.

3. 3
   Exécuter

   Le harness reçoit le tool call et l’exécute vraiment sous les permissions et le sandbox. Le modèle ne touche pas le disque à ce moment-là.

4. 4
   Réinjecter

   Les résultats d’outils deviennent du texte ou du JSON et retournent dans le contexte. Le modèle continue à partir de cette nouvelle preuve, ou déclare le travail fini.

Vous êtes aussi dans cette boucle : interrompre, réorienter, approuver les actions à haut risque. Le modèle raisonne. Le harness possède les outils, les permissions, les sessions, et ce que « terminé » veut dire. Pour voir comment quatre produits se disputent ce contrôle, voir

Les AI Coding Agents ne se limitent plus à la complétion : que se disputent Codex, Claude Code, OpenCode et DeepSeek Harness ?

Cet article ne découpe que comment la boucle tourne et à quel saut le JSON apparaît. Pour les couches de la pile, voir

Pile technique Agent IA 2026 : comment combiner LLM, MCP, Function Calling et JSON Schema ?.

Tool Calling : les arguments sont du JSON

Le Tool Calling (aussi appelé Function Calling) n’est pas un autre nom pour « le modèle sait écrire du code ». C’est un appel de fonction structuré : le modèle choisit un nom dans les outils que vous avez déclarés, puis génère du JSON qui doit coller au contrat de paramètres.

Sur les API compatibles OpenAI, le champ parameters d’une définition d’outil est lui-même du JSON Schema :

{
  "type": "function",
  "function": {
    "name": "run_tests",
    "description": "Run the project test suite and return a structured summary.",
    "parameters": {
      "type": "object",
      "properties": {
        "suite": { "type": "string", "enum": ["unit", "integration", "e2e"] },
        "path": { "type": "string", "minLength": 1 }
      },
      "required": ["suite"],
      "additionalProperties": false
    }
  }
}

Quand le modèle répond, arguments est souvent une chaîne, pas un objet déjà parsé :

{
  "id": "call_8f21",
  "type": "function",
  "function": {
    "name": "run_tests",
    "arguments": "{\"suite\":\"unit\",\"path\":\"src/auth\"}"
  }
}

Donc la couche métier fait au moins deux choses : parser la chaîne en JSON valide, puis valider champs, types et enums contre le schema que vous avez déclaré. Guillemets manquants, virgules en trop et clés non déclarées se jouent sur ce saut — pas sur le saut « le modèle avait l’air malin ».

Le tour complet : requête avec schema → le modèle choisit un outil et génère arguments → vous parsez et validez → vous exécutez l’outil → vous renvoyez le résultat en tool message → le modèle continue. Un schema clair réussit les premiers arguments. Un schema flou fait tourner la boucle à vide.

Comment écrire le contrat, et en quoi JSON Mode diffère de Strict Schema, c’est dans

Pourquoi les AI Agents ont besoin de JSON Schema ? De Tool Calling à Structured Output.

Claude Code : outils intégrés plus une couche d’extension

La documentation officielle de Claude Code découpe l’agent en deux : un modèle qui raisonne, et des outils qui agissent. Sans outils, Claude ne peut renvoyer que du texte. Avec des outils, il peut lire le dépôt, modifier des fichiers, lancer des commandes et chercher sur le web.

Les outils intégrés tombent en cinq groupes environ : fichiers (Read / Edit / Write), recherche (Grep / Glob), exécution (Bash), web (WebSearch / WebFetch), et l’intelligence de code qui demande un plugin (aller à la définition, erreurs de types). Les sous-agents et vous poser une question sont aussi des outils — pour l’orchestration.

Un tour « réparer les tests en échec » dans la boucle peut ressembler à ceci :

1. 1
   Bash lance les tests

   Voir quelle assertion a explosé avant de toucher au code.

2. 2
   Grep / Read localisent la source

   Utiliser la pile et les symboles pour tirer le bon contexte dans la fenêtre.

3. 3
   Edit fait un remplacement précis

   Les docs exigent lire puis éditer : old_string → new_string, pour ne pas écrire à l’aveugle.

4. 4
   Relancer les tests

   Les résultats reviennent dans le contexte. En cas d’échec, ça reboucle, au lieu de dire à voix haute « ça devrait aller ».

La couche d’extension s’assoit sur cette boucle. Elle ne la remplace pas :

• CLAUDE.md : les conventions de projet que chaque session devrait connaître
• Skills : workflows à la demande, pour ne pas fourrer chaque leçon dans le prompt système
• MCP : outils pour les systèmes externes, cherchés à la demande par défaut pour garder le contexte petit
• Hooks / Permissions : blocages déterministes. Les commandes dangereuses et les chemins protégés ne doivent pas dépendre de la mémoire du modèle à chaque fois

Le compromis d’ingénierie de Claude Code est net : un agent probabiliste plus des Hooks déterministes. Les sessions atterrissent aussi en JSONL, pour reprendre et forker. Ce que vous déboguez, c’est souvent un flux d’événements d’outils, pas « un chat ».

Codex : sandbox, approbations et JSONL

Codex tourne aussi une boucle d’agent, mais le centre produit est la façon dont une commande générée par le modèle atterrit. Dans le terminal, quand vous lancez

Codex CLI, vous choisissez d’abord le sandbox et les approbations, puis vous laissez le modèle agir.

Pour l’automatisation, utilisez codex exec --json. stdout devient du JSONL : début et fin de thread / turn, exécution de commandes, changements de fichiers, appels MCP, mises à jour de plan. Les scripts CI consomment un flux d’événements, pas un paragraphe.

{"type":"item.completed","item":{"id":"item_12","type":"command_execution","command":"npm test -- src/auth","exit_code":1,"aggregated_output":"FAIL src/auth/session.test.ts"}}
{"type":"item.completed","item":{"id":"item_13","type":"file_change","path":"src/auth/session.ts","kind":"update"}}
{"type":"turn.completed","usage":{"input_tokens":18420,"output_tokens":966}}

Quand l’aval a besoin de champs stables, utilisez --output-schema pour que la réponse finale colle à un JSON Schema. C’est le même genre de contrat que les parameters de Tool Calling. Ça contraint le JSON en fin de tâche, pas chaque commande en chemin.

Par défaut, codex exec est un sandbox en lecture seule. Pour modifier des fichiers, ajoutez --sandbox workspace-write explicitement. S’il faut plus de répertoires, préférez --add-dir plutôt que de passer tout de suite à danger-full-access.

Xcode 27 Agent : plan, validation, outils d’éditeur

À la WWDC 2026, Apple a positionné Xcode 27 comme l’endroit où écrire du code avec des agents sur les plateformes Apple. Contrairement à un agent terminal, sa boîte à outils vit dans l’IDE.

L’article Newsroom d’Apple et

Xcode, agents, and you,

What’s new in Xcode 27 clarifient quelques points :

• La conversation vit dans un volet éditeur, pour la partager avec le code et relire diffs et artefacts
• /plan explorer d’abord le dépôt et produire un plan, sans encore modifier le source ; des sous-agents peuvent collecter le contexte en parallèle
• Pendant l’implémentation, il valide avec les outils d’Xcode : compiler, lancer les tests, rendre les SwiftUI Preview, taper l’app dans un simulateur ou Device Hub
• Les erreurs de build reviennent directement à l’agent, qui remodifie et recompile à partir du log d’échec
• Les modèles ne sont pas verrouillés à un éditeur : Anthropic, Google, OpenAI, et les modèles locaux
• MCP connecte les outils externes ; ACP amène des agents externes (y compris ceux comme OpenCode) dans Xcode

Un lab WWDC a cadré Chat versus Agent comme un écart de capacités, pas un écart de texte : Chat a un petit jeu d’outils fixe ; le mode Agent ajoute la ligne de commande et les outils internes d’Xcode (build, test, Preview, simulateur). Le mode de sécurité par défaut, ce sont des invites de permission — l’agent atteint ce dont la tâche a besoin, mais ne peut pas flâner sur le disque.

Pour les développeurs JSON, l’enjeu de ce saut dans Xcode, c’est que les résultats de validation sont aussi une réinjection structurée. Échecs de build, résumés de tests et artefacts Preview deviennent la prochaine entrée de l’agent. Sur votre backend, vous voyez encore votre propre JSON d’API. Dans l’IDE, la même boucle consomme la sortie des outils Xcode.

Siri AI au niveau système utilise App Intents, pas cet agent d’éditeur. Ne fusionnez pas les deux en « Apple n’a qu’une sorte d’agent ». Voir

Siri AI va-t-elle devenir un Agent IA ?.

Trois produits, une boucle, des boîtes à outils différentes

Les listes de fonctionnalités continueront de se ressembler. La différence, c’est les outils par défaut, la frontière d’exécution, et comment un résultat devient le contexte du tour suivant.

Le choix peut rester court : dépôts généraux multilingues et Skills réutilisables → Claude Code ; tourner sur une vraie machine et encoder les permissions dans la CI → Codex ; plateformes Apple où la validation doit passer par la toolchain Xcode → Xcode 27. ACP veut dire que la dernière option n’a pas à rejeter les deux premières — un agent externe peut entrer dans l’éditeur, mais build et Preview restent des outils Xcode.

Où se trouve le JSON, et qui le valide

Les trois interfaces diffèrent. L’endroit où le JSON apparaît est stable :

La phrase clé : le schema côté API guide la génération ; le schema côté métier refuse les données sales. Ni l’un ni l’autre ne se remplace. Pourquoi la sortie IA a d’abord besoin d’un schema, c’est dans

Pourquoi l’IA a besoin de JSON Schema ?.

Pour un schema d’outil de Coding Agent, écrivez quand appeler et quand ne pas appeler. Mettez les options dans enum, pas enfouies dans description :

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "required": ["action", "path"],
  "properties": {
    "action": { "type": "string", "enum": ["read", "edit", "test"] },
    "path": { "type": "string", "minLength": 1 },
    "suite": { "type": "string", "enum": ["unit", "integration"] },
    "old_string": { "type": "string" },
    "new_string": { "type": "string" }
  },
  "additionalProperties": false,
  "allOf": [
    {
      "if": { "properties": { "action": { "const": "edit" } } },
      "then": { "required": ["old_string", "new_string"] }
    },
    {
      "if": { "properties": { "action": { "const": "test" } } },
      "then": { "required": ["suite"] }
    }
  ]
}

Si le modèle renvoie {"action":"edit","path":"src/a.ts"} sans old_string, le schema l’arrête à la couche d’exécution. C’est moins cher que de lire un diff après coup.

Déboguer les arguments d’outils dans JSONNote

La partie la plus lente du travail d’agent n’est souvent pas le prompt. C’est un tool call en échec. JSONNote tourne en local dans le navigateur. Clés et contenus de dépôt ne sont pas envoyés.

1. 1
   Voir si arguments peut se parser

   Déposez la chaîne renvoyée par le modèle dans Formatage JSON. Guillemets manquants, virgules finales et hashs tronqués par une app de chat apparaissent ici.

2. 2
   Puis valider contre le schema

   Mettez la définition d’outil et les arguments réels dans JSON Schema. Un enum faux, un required manquant ou des champs en trop valent mieux qu’un « sorry » du modèle.

3. 3
   Comparer deux appels

   Après avoir changé une description ou posé additionalProperties: false, utilisez JSON Diff pour voir les régressions d’arguments.

4. 4
   Partager la scène de débogage

   Utilisez Partage Hash d’URL pour embarquer un JSON d’outil dans un lien. Un collègue ouvre et reproduit. Les données ne touchent jamais un serveur.

FAQ

Quelle est la différence essentielle entre un AI Coding Agent et la complétion de code ?

La complétion ne propose que la ligne suivante. Un Coding Agent peut lire un dépôt, modifier des fichiers, lancer des commandes, appeler des outils externes, et continuer à décider dans une boucle selon les résultats d’outils. La différence n’est pas la qualité de la prose. C’est s’il peut agir.

Le modèle modifie-t-il directement les fichiers sur mon disque ?

Non. Le modèle n’émet qu’un tool call, en général un payload JSON. C’est le harness local qui écrit les fichiers, lance le shell et tape le simulateur. Sans outil, si la permission est refusée, ou si la validation des arguments échoue, rien ne se passe sur le disque.

Lequel est le meilleur : Claude Code, Codex ou le Xcode 27 Agent ?

Il n’y a pas de champion unique. Prenez Claude Code pour les dépôts généraux plus Skills et MCP. Prenez Codex pour le sandbox, les approbations et les événements JSONL en CI. Prenez le Xcode 27 Agent pour les plateformes Apple quand il faut valider par build, Preview et simulateur. Xcode peut aussi attacher un agent externe via ACP.

Pourquoi valider le JSON soi-même si le modèle a déjà rempli le schema ?

Les arguments remplis par le modèle sont une contrainte souple. arguments est souvent une chaîne : champs manquants, mauvais type, ou clés non déclarées. La production a toujours besoin de parse plus JSON Schema, puis de la couche métier. Codex --output-schema ne contraint que la réponse finale. Ça ne remplace pas les contrôles sur chaque résultat d’outil.

Le Xcode 27 Agent ne peut-il utiliser que les modèles d’Apple ?

Non. Xcode 27 relie les modèles et agents d’Anthropic, Google et OpenAI au même flux éditeur. Il gère aussi les modèles locaux, ACP pour les agents externes, et MCP pour les outils externes. Ce qui change, c’est la boîte à outils et la façon de valider le travail — pas la boucle elle-même.

Résumé

Les trois produits continueront de ressembler à un chat. La phrase en dessous ne change pas :

Coding Agent = décisions du modèle × Tool Calling × exécution du harness. JSON est la forme partagée des arguments d’outils et des résultats réinjectés.

Voyez d’abord la boucle, puis choisissez une boîte à outils : Claude Code renforce un agent général, Codex possède le sandbox et les événements, Xcode 27 transforme build et Preview en outils de validation. Écrivez le schema dans la déclaration, validez à la couche d’exécution, et gardez le débogage dans le navigateur local.

← Retour au blog