Développement IA

Un agent IA va-t-il seul sur le web, écrire du code et exécuter des tâches ? Du Browser Agent au JSON Tool Calling

Environ 15 min

Les pages produit écrivent « navigue, écrit du code et exécute des tâches de façon autonome ».La phrase d'ingénierie plus juste est : le modèle ne remplit que du JSON ; l'hôte ouvre le navigateur, modifie les fichiers et appelle les API.Ce texte va du Browser Agent au JSON Tool Calling et répond à trois questions : le fait-il lui-même ? Qui le fait vraiment ? Quel objet faut-il inspecter ?

En un coup d'œil

Idée Une ligne Atterrit sur
Browser Agent Actions structurées sur une page ou un bureau computer_use / browser JSON
Coding Agent Lire un dépôt, modifier des fichiers, lancer des commandes tool_use / Bash
Task Agent Appeler des API métier, écrire un état, transférer tool_calls / arguments
JSON Tool Calling Le contrat des noms, arguments et résultats Schema / payload

Retenez la division : le modèle propose des objets ; l'hôte exécute les effets de bord. Changez la marque ; la chaîne d'appel JSON reste.

Il fait le travail. Il ne le fait pas « lui-même »

Un agent 2026 peut ouvrir des pages, remplir des formulaires, exporter ; lire un dépôt, modifier des fichiers, lancer des tests ; consulter une commande, démarrer un remboursement, transférer. Ce sont de vrais effets de bord, pas des bulles de chat.

Le mot « lui-même » place mal le sujet. Un grand modèle ne possède pas de processus navigateur, ne spawn pas de shell et ne frappe pas votre intranet. Il n'émet qu'un objet validable : un nom d'outil, des arguments, parfois une intention suivante. Ce qui clique vraiment, c'est l'hôte.

  • Aller en ligne : le modèle émet browser_navigate ou computer_call ; le bac à sable navigateur de l'hôte exécute.
  • Écrire du code : le modèle émet Read / Edit / Bash ; l'espace de travail de l'hôte exécute.
  • Exécuter une tâche : le modèle émet tool_calls ; l'hôte appelle une API ou un flux.

Si vous confondez encore Agent, Tool Calling et Function Calling en un mot, commencez par Guide complet de l'agent IA. Cet article ne traite qu'un fait : trois coques produit, une chaîne d'appel JSON.

Trois coques, une table d'outils

Le marché nomme les produits Browser Agent, Coding Agent, Computer Use, Operator, ChatGPT Agent. Les coques diffèrent. La table non : ce qu'il peut faire dépend des outils que l'hôte expose.

  • Browser Agent : onglets, captures, clics, extrait DOM. Meilleure démo ; droits les plus faciles à sous-estimer.
  • Coding Agent : dépôt, rustine, tests, terminal. Il change le disque et les processus.
  • Task Agent : commandes, tickets, calendriers, remboursements. Il change les systèmes métier.

N'achetez pas la capacité par marque. Achetez-la par la table d'outils. Pas d'outil browser, il n'ira pas en ligne. Pas de Bash, il ne livrera pas de rustine exécutable. Pas de fonction métier, il ne remboursera pas.

JSON Tool Calling est le squelette commun

Tool Calling, Function Calling et computer_use ont des noms différents et la même forme. Un tour est souvent quatre sauts :

  1. Déclarer : l'hôte propose tools[] ou inputSchema.
  2. Proposer : le modèle remplit un nom d'outil et un objet d'arguments. Il n'exécute pas.
  3. Gater : l'hôte valide, applique une allowlist et décide s'il faut attendre un humain.
  4. Réécrire : une capture, stdout ou une réponse API devient le prochain objet visible.

C'est pourquoi le Schema vaut plus qu'un prompt. Le prompt influence ce qu'il remplit ; le Schema et l'hôte décident ce qui peut arriver. Contrat dans Pourquoi l'IA a besoin de JSON Schema ; frontière de protocole dans MCP Tool Schema vs Function Calling.

Browser Agent : ce n'est pas le modèle qui va en ligne

Un Browser Agent ressemble le plus à « il va seul sur le web ». Un onglet bouge vraiment. L'action reste un objet.

Un Browser Agent structuré — style Playwright, outils browser de Claude, beaucoup de navigateurs MCP — émet une navigation validable :

{
  "type": "tool_use",
  "id": "call_nav_1",
  "name": "browser_navigate",
  "input": {
    "url": "https://docs.example.com/api/orders",
    "wait_until": "domcontentloaded"
  }
}

Le computer use / Operator d'OpenAI est plus proche des actions par coordonnées. Le modèle voit une capture ou un arbre d'accessibilité et émet clic, saisie, défilement :

{
  "type": "computer_call",
  "call_id": "call_8c12",
  "action": {
    "type": "click",
    "x": 412,
    "y": 268
  }
}

Ne lisez aucune des deux formes comme « le modèle a vu la page, donc il a cliqué ». Ce qui est entré dans le contexte, ce sont des pixels ou un arbre ; ce qui a cliqué, c'est l'hôte. Verrouillez les arguments, pas le texte marketing :

  • Allowlist d'URL : par défaut docs, pages de statut et domaines déclarés.
  • Pas d'en-têtes en plus : Cookie et Authorization ne doivent pas entrer dans l'objet d'arguments.
  • Extraire avec un Schema : exportez des champs, pas une page HTML entière.
  • La session reste sur l'hôte : l'état de connexion est une politique de bac à sable, pas des poids de modèle.

Un Schema de navigation resserré ressemble à ceci. additionalProperties: false n'est pas de la pédanterie — un object large laisse le modèle glisser une URL intranet ou un script :

{
  "name": "browser_navigate",
  "description": "Open a URL in the isolated browser",
  "inputSchema": {
    "type": "object",
    "properties": {
      "url": { "type": "string", "format": "uri" },
      "wait_until": {
        "type": "string",
        "enum": ["load", "domcontentloaded"]
      }
    },
    "required": ["url"],
    "additionalProperties": false
  }
}

Guide GPT-6 Astra écrit browsing et computer use comme une seule capacité. En ingénierie, ce reste du JSON d'outil. Un outil navigateur large donne la session à la boucle ; surface de sécurité dans Sécurité des agents IA et validation JSON.

Coding Agent : ce n'est pas le modèle qui écrit sur le disque

Agents de code IA et chaîne d'appel JSON a déjà ouvert Claude Code et GPT Agent. Une phrase pour s'aligner sur le Browser Agent : écrire du code, c'est aussi remplir du JSON.

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

Le modèle ne fait pas open() sur un fichier. L'hôte le lit et écrit un tool_result. Ce n'est qu'alors que le tour suivant peut émettre Edit ou Bash.

La différence avec le web n'est que la surface d'outils : d'un côté url / selector / capture ; de l'autre path / command / rustine. La boucle est la même.

Exécuter une tâche : les effets de bord vivent dans l'API, pas dans les poids

« Exécuter une tâche » est la phrase que le texte produit avale en premier. Remboursements, routage de tickets, écritures calendrier — ce sont des Task Agents. La forme reste Function Calling :

{
  "tool_calls": [{
    "id": "call_task_3",
    "type": "function",
    "function": {
      "name": "create_ticket",
      "arguments": "{\"title\":\"Refund A-1042\",\"priority\":\"high\"}"
    }
  }]
}

Le danger ici n'est pas la prose. C'est un object large. Plafonds de montant, enum et additionalProperties: false appartiennent au Schema, pas à « soyez prudent ».

Le transfert multi-agents est aussi du JSON. Un objet handoff est plus auditable que « donnez ça à la facturation ». Outils et flux en Schema — voir JSON Schema et flux d'agents IA.

Un tour, c'est quatre sauts

Les pages produit écrivent « termine le job de façon autonome ». En ingénierie, Browser, Coding et Task marchent les mêmes quatre sauts :

  1. Observer : une capture, l'état du dépôt 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.
  3. Exécuter : l'hôte ouvre une page, modifie un fichier ou frappe une API. Les effets de bord ont lieu ici.
  4. Réécrire : un résumé DOM, stdout ou un corps de réponse devient le prochain objet visible.

Sautez une porte et le JSON est une commande. L'auto-mode signifie que vous avez pré-approuvé une classe d'objets. Changez la coque ; la boucle reste.

Trois tables, une chaîne

La question n'est pas qui est plus intelligent. C'est quelle table d'outils l'hôte accroche à la boucle :

Axe Browser Agent Coding Agent Task Agent
Ce qu'il voit Capture / DOM / arbre a11y Fichiers, tests, sortie terminal Objets métier, état du saut précédent
Ce qu'il émet navigate / click / type Read / Edit / Bash lookup / create / handoff
Où atterrissent les effets de bord Bac à sable navigateur, état de connexion Disque de l'espace de travail, processus API métier, systèmes en aval
Ce que vous verrouillez URL, Cookie, Schema d'extrait cwd, délai, porte réseau Montant, enum, champs requis

Changez la marque ; la boucle reste. Stabilisez le contrat d'outils et le monde d'exécution, pas une vidéo de démo.

Inspectez les objets, pas la vidéo de démo

Après qu'un agent « est allé en ligne, a écrit du code et a lancé le job », n'examinez pas la dernière phrase « c'est fait ». Examinez la trace.

  • formater tool_use / tool_calls / computer_call et vérifiez que le nom et les arguments sont le saut que vous pensiez.
  • Utilisez extraction JSONPath pour extraire url, command et name. Ne scannez pas la prose à l'œil.
  • JSON Diff contre une trace qui passait la semaine dernière. Si la boucle a dérivé, regardez d'abord la table d'outils et la forme des arguments, puis le modèle.
  • Captures, stdout et réponses API appartiennent à la trace. Une phrase « terminé » non.
  • Ne collez pas cookies, sessions ou URL intranet dans un formateur public. JSONSort tourne localement dans le navigateur ; c'est le bon endroit pour lire ces objets.

Si la trace se reconstruit, la session se relit. C'est le billet d'entrée en production, pas un bonus.

Pièges

  • Croire que le modèle a ouvert la page. C'est le processus navigateur de l'hôte qui l'a ouverte.
  • Croire que le modèle a exécuté le code. L'exécution vit sur l'hôte, pas dans les poids.
  • Regarder la démo et sauter le JSON d'outil. Le clic ou la commande a peut-être déjà eu lieu.
  • Donner un chèque en blanc au navigateur. Sans porte d'URL ni isolation des cookies, la boucle est une fuite de session.
  • Remplacer le Schema par un prompt. Le contrat doit être validable.
  • Traiter trois agents comme trois intelligences. Ce sont trois tables d'outils, pas trois cerveaux.

FAQ

Un agent IA peut-il vraiment aller seul sur le web aujourd'hui ?

Il peut ouvrir des pages, cliquer, extraire. Il ne possède pas le navigateur. Le modèle remplit du JSON ; le bac à sable de l'hôte exécute. Pas d'outil browser, il n'ira pas en ligne.

Quelle est la différence entre un Browser Agent et Computer Use ?

Les deux opèrent une interface. Un Browser Agent utilise souvent sélecteurs, navigation et extrait DOM ; Computer Use / Operator plus souvent captures et coordonnées. Les deux sont des appels structurés — pas un modèle qui a poussé des mains.

Écrire du code et exécuter des tâches, est-ce un autre protocole ?

Non. Read / Bash d'un Coding Agent et Function Calling d'un Task Agent partagent la même chaîne d'appel JSON qu'un Browser Agent. Ce qui change, c'est la table d'outils et le rayon des effets de bord.

Pourquoi parler de JSON plutôt que d'un modèle plus intelligent ?

Parce que les effets de bord arrivent après l'analyse de l'objet. Un modèle plus intelligent peut encore remplir la mauvaise URL ou le mauvais montant. Le Schema et les portes de l'hôte décident ce qui peut arriver.

Faut-il laisser un agent toucher un état de connexion ou une base de production ?

Non. Laissez-le rédiger dans un navigateur et un espace isolés, et gardez la trace. Connexion, secrets et mise en production restent des portes stratégiques humaines. La boucle rédige ; la porte expédie.

Conclusion

« Un agent IA va sur le web, écrit du code et exécute des tâches » n'est vrai qu'à moitié. La moitié vraie, c'est que les effets de bord ont déjà lieu. La moitié fausse, c'est le sujet. Le sujet est l'hôte, le verbe est exécuter, le complément est le JSON rempli par le modèle.

À partir d'aujourd'hui, discutez moins de savoir s'il « le fait lui-même ». Mettez d'abord les trois tables d'outils Browser, Coding, Task, le Schema et la trace de session dans le dépôt. Les modèles tournent ; cette chaîne JSON Tool Calling devrait se stabiliser d'abord. Comment les incidents poussent sur la même chaîne : Incidents Claude et JSON d'outil.

Pour aller plus loin

Journal : Première publication