GPT-5.6 et ChatGPT Work : Concevoir un Plan de Contrôle d'Agent de Qualité Professionnelle

Introduction

La sortie de GPT-5.6 en juillet 2026 peut facilement être perçue comme un simple lancement de modèle. Sol est la voie phare, Terra l'option équilibrée, et Luna le niveau plus rapide et moins coûteux. La version officielle comprend des évaluations approfondies couvrant le codage, le travail professionnel, les sciences, l'utilisation informatique et la sécurité.

Cette interprétation est exacte, mais incomplète.

La manière la plus utile de comprendre GPT-5.6 est opérationnelle. OpenAI a exposé plusieurs décisions que les développeurs d'agents devaient auparavant cacher dans du code d'orchestration personnalisé : combien de raisonnement allouer, quand utiliser des agents parallèles, comment coordonner les outils sans renvoyer chaque résultat intermédiaire au modèle, et comment faire correspondre la capacité du modèle à la valeur et au risque d'une tâche.

Parallèlement, ChatGPT Work intègre le modèle de tâche longue durée associé à Codex dans un espace de travail plus large incluant documents, feuilles de calcul, diapositives, sites web, applications connectées, actions de navigation, utilisation informatique et travaux planifiés.

Ces capacités créent une responsabilité d'ingénierie plus importante. Donner à un modèle plus puissant davantage d'outils ne crée pas automatiquement un travailleur numérique fiable. Cela crée un système capable de fonctionner plus longtemps, sur une frontière de données plus étendue, et d'effectuer des modifications plus conséquentes.

Une conception de production doit répondre à plusieurs questions avant le début de l'exécution :

• Qui a autorisé la tâche ?
• Que peut lire l'agent ?
• Que peut-il modifier ?
• Quelles actions nécessitent une approbation ?
• Combien de temps et d'argent peut-il dépenser ?
• Quelles preuves démontrent que le résultat est correct ?
• Comment l'équipe arrête ou récupère le flux de travail en cas de problème ?

Ce guide présente une approche de plan de contrôle pour les équipes construisant avec GPT-5.6, ChatGPT Work, Codex ou des agents personnalisés. Il sépare la capacité du modèle de l'autorité opérationnelle et fournit des scénarios concrets, des règles de routage, des conseils d'évaluation et un modèle de politique réutilisable.

Points Clés

• GPT-5.6 est mieux traité comme un menu de capacités et de calcul. Sol, Terra et Luna sont des voies de modèle, tandis que l'effort de raisonnement et l'exécution multi-agent sont des contrôles budgétaires distincts.
• ChatGPT Work change l'unité de délégation d'une réponse unique à un résultat complet pouvant couvrir des fichiers, des applications connectées, des travaux de navigation, l'utilisation informatique et des tâches planifiées.
• Un agent de production nécessite un plan de contrôle autour du modèle : classification des tâches, identité limitée, politique d'outils, points d'approbation, observabilité, évaluation, budgets et récupération.
• Les benchmarks publics sont utiles pour découvrir des modèles candidats, mais les ensembles de tâches privés sont essentiels pour les décisions de déploiement en production.
• Les équipes devraient commencer par des flux de travail réversibles et révisables, et n'étendre l'autonomie qu'après avoir collecté des preuves.

Ce qui a Réellement Changé avec GPT-5.6

GPT-5.6 rend trois niveaux de capacité disponibles dans ChatGPT, Codex et l'API :

• Sol : la voie de la plus haute capacité.
• Terra : une voie équilibrée pour le travail quotidien.
• Luna : la voie la plus rapide et la plus abordable.

OpenAI décrit ces noms comme des niveaux de capacité durables plutôt que des noms de modèle temporaires avec date. Cette distinction est utile pour les systèmes de production.

Une politique telle que "utiliser le niveau équilibré pour la maintenance de routine du référentiel" peut survivre à un futur changement de snapshot. Lorsque la reproductibilité est importante, l'équipe peut épingler un snapshot exact séparément. C'est plus propre que de disperser les identifiants de modèle dans les prompts, scripts, files d'attente de tâches et variables d'environnement.

Effort de raisonnement et exécution multi-agent

GPT-5.6 ajoute également des contrôles de calcul plus explicites.

max donne à une route de modèle plus de temps pour raisonner, explorer des alternatives, effectuer des vérifications et réviser son travail. ultra coordonne plusieurs agents à travers des flux de travail parallèles.

Ce sont des contrôles différents :

• Plus de raisonnement permet à une route d'investiguer et de vérifier plus longtemps.
• L'exécution multi-agent consacre du calcul supplémentaire à des flux de travail concurrents, puis synthétise leurs résultats.

Une tâche peut bénéficier de l'un, des deux, ou d'aucun. L'exécution parallèle n'est pas automatiquement meilleure, surtout lorsque les sous-tâches partagent la même hypothèse incertaine ou nécessitent les mêmes identifiants restreints.

Appel d'outil programmatique

OpenAI décrit l'Appel d'outil programmatique comme une manière pour un modèle d'écrire et d'exécuter des programmes légers qui coordonnent les outils, traitent les résultats intermédiaires et décident quelles informations doivent être renvoyées au modèle.

Cela peut réduire les transferts de contexte répétés. Au lieu de retourner chaque ligne de base de données, réponse de navigateur ou résultat d'outil au modèle, un programme en mémoire peut d'abord filtrer et agréger les données.

Cette efficacité s'accompagne d'un compromis opérationnel. Plus de logique se déplace dans la couche d'exécution, ce qui signifie que les équipes ont besoin de traces claires, de limites et de règles de gestion des données pour ces étapes intermédiaires.

La version GPT-5.6 introduit également une version bêta multi-agent dans l'API Responses. L'exécution parallèle devient donc une capacité au niveau de l'API, et non seulement un schéma d'orchestration côté application.

Le prix est une entrée de routage

Au lancement, les prix officiels sont :

Route	Prix d'entrée par 1M de jetons	Prix de sortie par 1M de jetons
GPT-5.6 Sol	$5,00	$30,00
GPT-5.6 Terra	$2,50	$15,00
GPT-5.6 Luna	$1,00	$6,00

Ces prix sont des entrées pour une décision de routage, et non la décision elle-même.

Un modèle moins cher peut coûter plus cher par résultat accepté s'il réessaie à plusieurs reprises, lit un contexte inutile ou produit un travail que les réviseurs rejettent. Un modèle plus fort peut être moins cher en pratique s'il termine la tâche en une seule fois avec un petit changement vérifié.

La métrique correcte n'est pas simplement le coût par jeton. C'est le coût par résultat accepté.

ChatGPT Work change l'unité de délégation

ChatGPT Work est présenté comme un agent capable de travailler sur plusieurs applications et fichiers, de continuer pendant des heures, de décomposer les objectifs en étapes plus petites et de créer des artefacts finis.

OpenAI affirme que la technologie Codex est intégrée dans le produit, mais la cible est plus large que le génie logiciel. Les flux de travail d'exemple incluent :

• Analyse budgétaire
• Briefs de campagne
• Examen des leads
• Vérifications de lancement de produit
• Recherche concurrentielle
• Documents
• Feuilles de calcul
• Présentations
• Sites Web

Le changement important est l'unité de délégation.

Un tour de chat normal demande une réponse. Une tâche Work demande un résultat.

Ce résultat peut nécessiter que le système :

1. Lise plusieurs sources.
2. Change de direction lorsque de nouvelles

informations apparaissent.
3. Créez plusieurs artefacts.
4. Attendez l'approbation humaine.
5. Continuez via une tâche planifiée pendant l'absence de l'utilisateur.
6. Utilisez des applications connectées, un navigateur intégré ou l'utilisation d'un ordinateur de bureau.

OpenAI consolide également ses surfaces produit. Chat, Work et Codex sont disponibles dans l'expérience de bureau mise à jour, tandis que les fonctionnalités du navigateur sont intégrées à l'environnement produit plus large.

Cela crée une frontière de permissions unique couvrant les fichiers locaux, les pages web, les services connectés, les actions du navigateur et les tâches de longue durée.

Les contrôles d'entreprise sont donc aussi importants que l'interface. La gestion administrative des connecteurs, les fonctionnalités de conformité et les mécanismes de révision pointent tous vers le même problème : l'agent doit agir avec la bonne identité, le contexte minimum requis, des effets visibles et une voie de récupération.

Même lorsqu'une équipe construit un agent API personnalisé plutôt que d'utiliser directement ChatGPT Work, Work constitue un modèle opérationnel de référence utile. Il expose les problèmes qui apparaissent lorsqu'un assistant devient un travailleur persistant :

• État
• Identité de l'outil
• Approbations
• Planification
• Artefacts
• Gouvernance

Termes à comprendre : Modèle, Harnais, Agent et Plan de contrôle

Modèle

Un modèle mappe le contexte d'entrée vers la sortie et les décisions d'outils. Il a des capacités, des limitations, un prix, une latence et un comportement de sécurité.

Sol, Terra et Luna sont des niveaux de modèle. Le modèle lui-même ne décide pas de l'autorité organisationnelle.

Harnais d'agent

Le harnais d'agent est le logiciel qui entoure le modèle. Il sélectionne le contexte, expose les outils, exécute les commandes, stocke l'état, réessaie en cas d'échec et décide quand une exécution est terminée.

Changer le harnais peut modifier considérablement le coût et la fiabilité, même lorsque le modèle et la tâche restent identiques. Un harnais qui envoie de manière répétée de grandes fenêtres de contexte peut coûter bien plus qu'un autre qui filtre les résultats intermédiaires.

Pour cette raison, les « performances du modèle » sont incomplètes à moins que le harnais ne soit également spécifié.

Agent

Un agent combine :

• Un modèle
• Un objectif
• Des outils
• Un état
• Un harnais

Un agent peut prendre plusieurs mesures et réagir aux résultats des outils. Un agent de longue durée peut créer des sous-tâches ou des sous-agents, mais les travailleurs parallèles ne forment pas automatiquement un système multi-agents sûr. Ils partagent toujours des budgets, des permissions et une décision finale d'acceptation.

Plan de contrôle

Le plan de contrôle est la couche de politique et d'opérations qui régit les exécutions des agents.

Il :

• Classe les tâches
• Sélectionne les routes
• Émet des identifiants limités
• Applique les approbations
• Enregistre les traces
• Évalue les résultats
• Arrête le travail
• Annule le travail

Le plan d'exécution effectue la tâche. Garder les deux séparés permet à une équipe de changer de modèles sans modifier qui est autorisé à déployer du code de production ou à envoyer des messages externes.

Porte d'approbation

Une porte d'approbation est un point de décision qu'un agent ne peut franchir sans une personne autorisée ou une politique déterministe.

Les approbations doivent être attachées à une action spécifique et à ses preuves.

Une demande d'approbation utile est :

Approuver l'envoi de cet email finalisé à ces 412 destinataires en utilisant la liste de destinataires jointe et le contenu approuvé.

Une demande d'approbation faible est :

Approuver la tâche marketing.

Test d'acceptation

Un test d'acceptation est une preuve que le

Le résultat demandé est complet.

Il peut s'agir de :

• Un test unitaire
• Une validation de schéma
• Une révision de document rendu
• Un total de rapprochement
• Une grille d'évaluation humaine
• Un scan de sécurité
• Une approbation par le propriétaire du code

Un modèle qui dit « terminé » est une affirmation d'état, pas un test d'acceptation.

Le Plan de Contrôle de l'Agent de Production

Un plan de contrôle de production utile a huit responsabilités.

1. Classifier la Tâche

La classification doit couvrir :

• Le domaine
• L'impact
• La réversibilité
• La sensibilité des données
• L'ambiguïté
• La valeur attendue
• La force de vérification

« Mettre à jour une FAQ provisoire » et « modifier une politique d'authentification » peuvent tous deux impliquer l'édition de texte, mais ils empruntent des voies différentes.

2. Sélectionner un Modèle et un Budget d'Effort

La voie éligible la moins chère est un choix par défaut raisonnable, mais l'éligibilité doit primer sur le prix.

Exemples :

• Luna pour l'extraction à faible risque
• Terra pour l'analyse modérée avec des contrôles de source stricts
• Sol pour les revues d'architecture, les revues de sécurité ou le diagnostic difficile de dépôt
• Ultra uniquement lorsque la tâche se décompose proprement et que le coût parallèle supplémentaire est justifié

3. Créer une Identité d'Exécution Ciblée

L'agent doit recevoir des identifiants de courte durée pour les dépôts, dossiers, applications ou enregistrements exacts requis par la tâche.

Il ne doit pas hériter de la session complète du navigateur d'un développeur simplement parce que c'est pratique.

L'identité d'exécution doit être visible dans les journaux afin que l'équipe puisse attribuer chaque action externe.

4. Appliquer une Politique d'Outils

Ce sont des capacités distinctes :

• Lire
• Écrire
• Envoyer
• Acheter
• Supprimer
• Déployer
• Modifier les autorisations

Un connecteur qui peut rechercher une boîte aux lettres ne doit pas automatiquement être capable d'envoyer des e-mails. Une intégration GitHub qui peut inspecter un dépôt ne doit pas automatiquement être capable de fusionner des demandes de tirage.

5. Appliquer des Approbations et des Contrôles Déterministes

Une porte d'approbation doit apparaître immédiatement avant l'action conséquente et montrer un aperçu concis de l'effet et des preuves.

Pour le logiciel, les preuves peuvent inclure :

• Le diff
• Les tests unitaires
• Les vérifications de type
• Les scans de sécurité
• Le plan de déploiement

Pour la finance, elles peuvent inclure :

• Les totaux sources
• Le rapprochement
• La validation de formule
• Les contrôles d'écart

6. Enregistrer une Trace d'Événements

La trace doit inclure :

• Les changements d'objectif
• La récupération de sources
• Les appels d'outils
• Les approbations
• Les artefacts
• Les erreurs
• Les raisons de nouvelle tentative
• L'utilisation de jetons
• Le temps écoulé
• L'état final

Un court résumé est utile pour les opérations, mais il ne suffit pas pour la révision d'incidents.

7. Appliquer des Budgets et des Conditions d'Arrêt

Les limites utiles incluent :

• Le budget de jetons
• Le budget d'appels d'outils
• La limite de temps réel
• La limite de nouvelles tentatives
• Le plafond monétaire
• La limite de nombre de fichiers
• La limite de taille de diff

Arrêter une exécution faible ou en boucle n'est pas un échec d'autonomie. C'est une application réussie de la politique.

8. Maîtriser la Récupération

La récupération peut inclure :

• Restaurer un fichier
• Revenir sur un commit
• Révoquer des identifiants
• Annuler une tâche planifiée
• Supprimer un brouillon
• Ouvrir un incident

Si le système ne peut pas expliquer la récupération avant l'exécution, la tâche n'est pas prête pour une opération sans surveillance.

Routage de Sol, Terra et Luna par Forme de Tâche

Le routage de modèle doit être suffisamment explicite pour que les ingénieurs, les chefs de produit et les réviseurs de sécurité puissent le lire.

Le tableau suivant est un

point de départ, pas un classement universel.

Route	Type de tâche appropriée	Preuve requise	Autorité typique
Luna	Classification, extraction, mise en forme, résumés à faible risque, recherche de code restreinte	Validation de schéma, vérification d'échantillons, liens vers les sources	Accès lecture seule ou brouillon uniquement
Terra	Modifications courantes du dépôt, production de documents, workflows connus, analyse modérée	Tests ciblés, validation des artefacts, vérification humaine ponctuelle	Écriture limitée, aucune action externe irréversible
Sol	Diagnostics ambigus, analyse intersystèmes, travail d'architecture, révision de sécurité, recherche de grande valeur	Vérifications déterministes larges, justification visible par le relecteur, provenance des sources	Écriture limitée avec approbations explicites
Sol max	Raisonnement monothread difficile où davantage d'exploration et de révision peuvent améliorer la qualité	Points de contrôle, limite de coût, vérification finale	Même autorité que Sol
Sol ultra	Tâches parallélisables de grande valeur avec des flux de travail indépendants	Preuve par flux de travail, révision de synthèse, plafond budgétaire total	Identités limitées séparées si possible

La dernière colonne est la plus importante.

La capacité du modèle ne doit pas augmenter l'autorité.

Passer de Luna à Sol ne peut pas ajouter silencieusement un accès en écriture. Augmenter l'effort de raisonnement ne peut pas transformer un brouillon en message externe approuvé. Ultra ne doit pas créer plusieurs travailleurs qui partagent toutes les identifiants de production sans restrictions.

Escalade basée sur les preuves

Une route Luna peut escalader lorsque :

• La confiance tombe en dessous d'un seuil.
• Les champs requis ne peuvent pas être extraits.
• Les sources sont en conflit.
• La validation échoue.

Une tâche de codage Terra peut escalader lorsque :

• Un test échoué reste inexpliqué après deux tentatives limitées.
• La modification franchit une limite de sécurité.
• Le diff dépasse le nombre de fichiers attendu.

Une route Sol doit s'arrêter et demander à un humain lorsque les exigences sont en conflit ou que la seule action restante est irréversible.

La rétrogradation est également utile

Une fois que Sol a produit un plan, Terra ou Luna peuvent exécuter des sous-tâches répétitives sous des contrôles restreints.

Un modèle puissant peut examiner un échantillon plutôt que de traiter chaque élément. Cela sépare le jugement du volume et peut réduire considérablement les coûts.

Architecture des autorisations et limites d'approbation

Un système d'autorisations doit commencer par des verbes.

lire
rechercher
créer_brouillon
modifier
envoyer
fusionner
déployer
supprimer
acheter
accorder_accès

Ces verbes ont des conséquences différentes.

De nombreuses intégrations de produits placent plusieurs actions derrière une seule portée OAuth large. Le plan de contrôle peut donc avoir besoin d'un proxy côté application qui expose des opérations plus restreintes.

Lier les verbes aux ressources

« Lire Google Drive » est trop large pour de nombreux workflows.

Une règle plus restreinte pourrait être :

Lire le dossier de planification du T3 et le dossier de modèles de marque approuvés jusqu'à 18h00 UTC.

Pour les dépôts, l'accès peut être limité à un seul arbre de travail avec accès réseau désactivé. Pour les bases de données, une réplique en lecture ou une vue gouvernée est généralement plus sûre que des identifiants de production.

Ajouter des conditions

Exemples :

• Un brouillon d'e-mail peut être créé automatiquement, mais son envoi nécessite une approbation.
• Une pull request peut être ouverte automatiquement, mais sa fusion nécessite un CI vert et un propriétaire de code.
• Une tâche planifiée peut actualiser un tableau de bord, mais

La modification de la source de données nécessite un administrateur.

Préserver la séparation des tâches

L'agent qui initie un changement ne doit pas être le seul juge de sa validité.

Des preuves utiles peuvent provenir :

• D'un outil d'exécution de tests déterministe
• D'un modèle de révision distinct
• D'un responsable humain

Un second modèle ne remplace pas un humain responsable, mais il peut révéler un désaccord avant qu'une action ne devienne externe.

Les protections du fournisseur ne sont qu'une seule couche. Elles ne peuvent pas savoir si l'utilisateur est autorisé à tester un dépôt spécifique, si un client a approuvé un changement, ou si la fenêtre de maintenance de production est ouverte.

L'autorisation de l'application reste la responsabilité du développeur.

Scénarios concrets et modes de défaillance

Scénario 1 : Agent de préparation au déploiement

Une équipe demande à ChatGPT Work ou à un agent personnalisé d'examiner :

• Un plan de lancement
• Des tickets Jira
• Un dépôt
• Un document de mise sur le marché

Le livrable requis est un rapport de préparation listant les responsables et les blocages.

L'agent peut lire les quatre sources et créer le rapport. Il ne peut pas modifier le statut des tickets ou contacter les responsables sans approbation.

Mode de défaillance : Contexte obsolète

Le rapport cite un ticket déjà résolu car l'agent a utilisé un document mis en cache.

Le plan de contrôle doit exiger des liens directs vers les sources et des horodatages.

Mode de défaillance : Achèvement trompeur

L'agent déclare le déploiement prêt parce que chaque ligne de la liste de contrôle contient du texte.

Le test d'acceptation devrait plutôt exiger que chaque dépendance bloquante ait un propriétaire vérifié, une date et un statut actuel.

Scénario 2 : Mise à jour de dépendance par un agent de codage

La tâche consiste à mettre à jour une bibliothèque dans un monorepo.

Terra démarre car la migration est documentée et la suite de tests est solide. Il crée une branche, modifie le fichier de verrouillage et les paquets concernés, et exécute des vérifications ciblées.

Une erreur du compilateur révèle un changement d'API non documenté dans le module d'authentification. Cela déclenche une escalade vers Sol.

Le modèle change, mais pas l'autorité.

Sol reçoit la même arborescence de travail et aucun jeton de déploiement. Si la différence touche la logique d'autorisation, la politique ajoute une porte de révision de sécurité.

L'achèvement nécessite :

• Des tests unitaires
• Des vérifications de types
• Un audit des dépendances
• Une note de migration approuvée par un relecteur

Un correctif qui semble fonctionner mais ignore ces vérifications n'est pas accepté.

Scénario 3 : Flux de travail programmé pour les retours clients

Chaque matin, un agent lit les nouveaux tickets de support, regroupe les thèmes et met à jour une fiche produit.

Luna peut classer les tickets après suppression des champs sensibles. Terra peut rédiger la fiche avec des liens vers les sources.

Aucune des deux voies ne peut :

• Clôturer les tickets
• Promettre une fonctionnalité
• Contacter les clients

Mode de défaillance : Dérive progressive du périmètre

Une nouvelle instruction indique que l'agent doit « également gérer les réponses évidentes ».

Cela transforme un flux de travail d'analyse interne en communication externe.

Le classificateur de tâches doit détecter le nouveau verbe « envoyer » et exiger une politique distincte, un modèle approuvé, un plan d'échantillonnage et un responsable humain.

Scénario 4 : Tâche de recherche à haute valeur

Une entreprise évalue trois options d'architecture.

Sol ultra attribue des flux de travail distincts à :

• La performance
• La sécurité
• Le coût de migration
• Le risque fournisseur

L'exécution parallèle est justifiée car les flux de travail sont

indépendante et la décision a de la valeur. Chaque travailleur reçoit des exigences de source et un budget fixe.

Mode de défaillance : Preuves corrélées

Tous les travailleurs citent le même benchmark de fournisseur et semblent d'accord.

La porte de synthèse doit mesurer la diversité des sources, signaler les hypothèses non étayées partagées et exiger au moins un contre-argument pour chaque option.

D'autres agents peuvent amplifier une mauvaise prémisse aussi facilement qu'ils peuvent améliorer la couverture.

Pourquoi les benchmarks de code public sont des outils de découverte

Les benchmarks publics sont utiles, mais ils ne devraient pas déterminer directement une valeur par défaut de production.

L'audit d'OpenAI sur SWE-Bench Pro a rapporté qu'une part substantielle des tâches publiques présentait des problèmes tels que :

• Tests trop stricts
• Consignes sous-spécifiées
• Tests à faible couverture
• Consignes orientant vers un comportement incompatible avec des tests cachés

Cela ne signifie pas que chaque benchmark public est inutile.

Cela signifie que le score hérite de l'erreur de mesure de son ensemble de données et de son harnais.

Les évaluations publiques sont utiles pour :

• Découvrir des modèles candidats
• Comparer des méthodes publiées
• Identifier des changements de capacités générales
• Construire une file d'évaluation interne

Elles ne peuvent pas répondre à la question de savoir si un modèle apportera des modifications sûres dans un monorepo spécifique, un flux de travail métier ou un environnement de données.

Un plan de contrôle doit stocker la provenance du benchmark avec chaque décision de routage :

• Version de l'ensemble de données
• Exclusions de tâches
• Harnais
• Configuration de l'outil
• Effort de raisonnement
• Nombre d'essais
• Hypothèses de coût

Sans ces détails, un score de benchmark devient un langage marketing.

Construire une évaluation privée à partir de travaux réels

Databricks fournit un exemple utile avec son évaluation de code base de plusieurs millions de lignes.

L'équipe a construit des tâches à partir de véritables demandes de tirage (pull requests) rédigées par des humains, couvrant :

• Python
• Go
• TypeScript
• Scala
• Rust
• Java
• Protobuf
• gRPC
• Bazel

Elle a sélectionné des modifications récentes et représentatives avec des tests significatifs, réécrit les descriptions des tâches pour préserver l'intention sans révéler la solution, et examiné manuellement chaque échantillon.

L'équipe a également découvert une fuite dans sa configuration initiale. Les agents pouvaient récupérer les commits futurs à partir de l'historique Git. Lors des exécutions d'évaluation, l'arbre de travail (worktree) était isolé de l'historique du dépôt.

Ce détail est plus important que le classement final. Il montre comment un benchmark peut accidentellement mesurer la découverte de raccourcis plutôt que la capacité d'ingénierie.

Construire un ensemble interne plus petit

Une équipe peut commencer par 30 à 60 tâches.

Utilisez des modifications historiques acceptées qui ont :

• Un problème clair
• Des tests significatifs
• Une portée limitée

Incluez un mélange de :

• Maintenance de routine
• Diagnostic de bugs
• Refactorisation multi-fichiers
• Travail frontend
• Configuration
• Un ou deux exemples sensibles à la sécurité

Préservez l'état du dépôt avant la modification et cachez le correctif final.

Évaluer d'abord avec des preuves déterministes

Utilisez des tests déterministes avant le jugement humain ou celui du modèle.

Ajoutez ensuite une revue humaine pour :

• La fidélité aux exigences
• La qualité du diff
• La maintenabilité
• Les changements inutiles

Ne laissez pas un modèle LLM remplacer chaque vérification de correction. Un modèle juge peut récompenser une réponse qui semble correcte.

Mesurer le modèle et le harnais ensemble

Enregistrez :

• Taux de réussite
• Coût total
• Temps écoulé
• Contexte total envoyé
• Appels d'outils
• Tentatives

Fichiers modifiés

• Corrections des relecteurs
• Taux de retour en arrière

La meilleure voie est celle qui produit un travail accepté dans les contraintes de l'équipe, pas celle avec le score public le plus élevé.

Un modèle de politique d'agent réutilisable

Le YAML suivant est un artefact de politique, pas un schéma d'API. Adaptez-le à votre fournisseur d'identité, file d'attente de tâches, connecteurs, contrôles de référentiel et système d'audit.

policy_version: 1
workflow: release_readiness
owner: product-operations

classification:
  impact: medium
  reversibility: high
  data_sensitivity: internal
  ambiguity: medium
  verification: strong

routing:
  default:
    model_tier: terra
    reasoning_effort: medium
  escalate_to_sol_when:
    - conflicting_sources
    - unresolved_blocker_after_2_attempts
    - security_boundary_detected
  ultra:
    allowed: false

budget:
  max_wall_minutes: 45
  max_tool_calls: 120
  max_retries_per_step: 2
  max_estimated_usd: 12

access:
  jira:
    verbs: [read]
    projects: [NX]
  github:
    verbs: [read]
    repositories: [We0 AI/product]
  drive:
    verbs: [read, create_draft]
    folders: [launch-plans]
  external_send: deny
  deploy: deny
  grant_access: deny

approvals:
  - action: publish_report
    role: product-director
    evidence:
      - source_links_present
      - blockers_have_owner_and_date
      - unresolved_conflicts_listed

acceptance:
  required_checks:
    - schema_valid
    - all_sources_fresh_within_24h
    - no_unattributed_claims
    - human_approval_recorded

recovery:
  on_budget_exceeded: stop_and_notify
  on_tool_error_repeat: stop_and_attach_trace
  on_policy_violation: revoke_credentials_and_open_incident

Ce modèle fait plusieurs choix délibérés :

• L'escalade modifie les capacités, pas les autorisations.
• Ultra reste désactivé sauf si le propriétaire du workflow l'active explicitement.
• L'envoi externe et le déploiement sont des refus distincts.
• L'acceptation est exprimée sous forme de vérifications plutôt que de confiance du modèle.
• La récupération est définie avant l'exécution.

Pour les workflows de codage, remplacez les vérifications de rapport par :

• Tests ciblés
• Vérifications de type
• Linting
• Analyses de sécurité
• Limitations de taille de diff
• Revue par le propriétaire du code

Pour les workflows de tableur, exigez :

• Validation des formules
• Rapprochement des sources
• Inspection rendue

La structure du plan de contrôle reste stable tandis que les preuves changent.

Observabilité, budgets et récupération

Les agents à longue durée d'exécution créent un nouveau problème d'observabilité.

Un journal de requêtes traditionnel peut montrer un appel API. Une trace d'agent peut contenir des centaines de décisions, d'appels d'outils, de tentatives et d'artefacts intermédiaires.

Les équipes ont besoin des deux :

1. Une trace complète pour l'investigation.
2. Un registre d'exécution concis pour les opérations.

Champs du registre d'exécution

Un registre utile comprend :

• ID d'exécution stable
• Utilisateur initiateur
• Version de la politique
• Objectif
• Niveau de modèle et instantané
• Effort de raisonnement
• Nombre de sous-agents
• Portées des outils
• Approbations
• Coût
• Temps écoulé
• Vérifications d'acceptation
• Liens vers les artefacts finaux
• État final
• Raison de l'escalade

Cela permet de répondre à des questions telles que :

• Est-ce que Sol a amélioré l'acceptation après l'échec de Terra ?
• Quel workflow consomme le plus de temps de relecteur ?
• Quel outil provoque le plus de tentatives ?
• Quelle voie produit le taux de retour en arrière le plus élevé ?

Utiliser

Budgets Multi-Dimensionnels

Une limite monétaire seule peut permettre à un modèle bon marché de boucler trop longtemps.

Une limite de temps seule peut permettre une rafale de travaux parallèles coûteux.

Les dimensions budgétaires utiles incluent :

• Argent
• Temps réel
• Utilisation de jetons
• Appels d'outils
• Tentatives
• Nombre de fichiers
• Taille des diffs
• Nombre de sous-agents

Rétablissement des Tests

Le rétablissement doit être testé comme toute autre fonctionnalité.

Les tests utiles incluent :

1. Retirer un connecteur en cours d'exécution.
2. Confirmer que l'agent ne répète pas une action externe après une tentative.
3. Faire expirer ses identifiants et confirmer que la trace explique l'échec.
4. Annuler une tâche planifiée et confirmer que les exécutions futures s'arrêtent.
5. Revenir sur un commit généré et marquer les artefacts associés comme obsolètes.

Les examens d'incidents doivent distinguer :

• Défaillance du modèle
• Défaillance du harnais
• Défaillance de la politique
• Défaillance de l'outil
• Défaillance de l'approbation humaine

Blâmer « l'IA » cache le composant qui peut réellement être amélioré.

Guide d'Adoption et Liste de Vérification

Commencez par un workflow fréquent, mesurable et réversible.

Les bons candidats incluent :

• Rapports de préparation à la publication
• Tri des problèmes
• Actualisations de la documentation
• Résumés d'échecs de tests
• Briefs de recherche interne

Évitez de faire le premier déploiement sur :

• Communication externe
• Modifications de production
• Paiements
• Octrois d'accès
• Workflows de suppression

Enregistrez la Référence Humaine

Mesurez :

• La durée du workflow
• Les sources utilisées
• Les erreurs qui se produisent
• Les preuves attendues par les examinateurs

Sans référence, une sortie plus rapide de l'agent peut simplement transférer plus de travail vers la correction.

Exécutez en Mode Furtif

Laissez l'agent produire un artefact tandis qu'un humain réalise indépendamment le workflow réel.

Comparez les résultats et étiquetez les modes d'échec. Utilisez ces exécutions pour construire l'évaluation privée avant d'augmenter les permissions.

Liste de Vérification

Avant de passer d'un accès en mode brouillon à un accès en écriture limité, confirmez :

• La définition de la tâche est-elle suffisamment spécifique pour être notée ?
• Le niveau de modèle et l'effort de raisonnement sont-ils sélectionnés par politique ?
• L'escalade peut-elle se produire sans élargir l'autorité ?
• Chaque outil a-t-il des verbes explicites et une portée de ressources ?
• Les identifiants sont-ils de courte durée et attribuables à l'exécution ?
• Chaque action irréversible ou visible de l'extérieur est-elle verrouillée ?
• Les vérifications d'acceptation sont-elles indépendantes de la revendication d'achèvement du modèle ?
• La trace inclut-elle les sources, actions, approbations, erreurs et coûts ?
• Les budgets couvrent-ils l'argent, le temps, les tentatives, les outils et le rayon d'explosion ?
• La révocation des identifiants, l'annulation et le rollback ont-ils été testés ?
• L'évaluation privée inclut-elle les cas limites courants et à haut risque ?
• Un propriétaire humain nommé est-il responsable du résultat du workflow ?

N'étendez qu'une seule dimension à la fois.

Une équipe peut ajouter une nouvelle source de données tout en gardant une sortie en mode brouillon, ou ajouter un accès en écriture limité tout en gardant le même modèle et la même tâche.

Changer le modèle, les outils, les permissions et le calendrier ensemble rend les régressions difficiles à attribuer.

Ce Que Les Constructeurs Devraient Faire Maintenant

GPT-5.6 et ChatGPT Work sont la preuve que l'infrastructure des agents devient une catégorie de produit à part entière.

La couche modèle continuera de changer. Le travail durable est le plan de contrôle qui rend

Ces modifications du modèle sont sûres.

Créer un registre des itinéraires

Créez un petit registre pour Sol, Terra, Luna et tout candidat non-OpenAI.

Stockez :

• L'éligibilité
• La politique de données
• La gamme d'effort autorisée
• Les hypothèses de coût
• Les modes de défaillance connus

Ajoutez une file d'attente d'évaluation privée afin qu'un nouveau modèle ne puisse pas devenir la valeur par défaut de production uniquement sur la base d'impressions sur les réseaux sociaux.

Ajouter un proxy d'autorisation

Placez un proxy d'autorisation entre les agents et les outils conséquents.

Exposez :

• Des verbes étroits
• Des identifiants à courte durée de vie
• Des crochets d'approbation
• Des clés d'idempotence

Maintenez la même frontière que la tâche commence dans ChatGPT Work, Codex, une application personnalisée ou un travail planifié en backend.

Définir l'acceptation avant l'autonomie

Une équipe qui peut expliquer comment une tâche est vérifiée peut l'automatiser en toute sécurité par étapes.

Une équipe qui ne peut pas définir la vérification n'est pas prête à laisser un agent fonctionner pendant des heures, quel que soit son score de référence.

Examiner les coûts au niveau des résultats

Suivez les dollars et les minutes humaines par :

• Artefact accepté
• Modification fusionnée
• Ticket résolu
• Analyse approuvée

Cela aligne le routage du modèle, l'efficacité du harnais et la charge de travail du réviseur.

Cela donne également à l'équipe une réponse fondée lorsque le prochain modèle phare arrive.

Limites et questions ouvertes

Plusieurs affirmations dans les documents de version restent déclarées par le fournisseur.

Les comparaisons de référence entre fournisseurs utilisent des éléments différents :

• Harnais
• Paramètres de raisonnement
• Hypothèses de tarification
• Configurations d'outils
• Ensembles de données

Traitez ces affirmations comme des hypothèses pour les tests internes.

L'appel d'outils programmatique et l'exécution multi-agent peuvent réduire la surcharge de contexte, mais ils peuvent également rendre la logique intermédiaire moins visible lorsque le traçage est faible.

Avant d'utiliser ces fonctionnalités dans des flux de travail réglementés, vérifiez :

• Ce que l'API enregistre
• Ce que les journaux d'application conservent
• Comment les données intermédiaires sensibles sont traitées
• Si le flux de travail est compatible avec la politique de conservation requise

Les applications connectées de ChatGPT Work et les capacités d'utilisation de l'ordinateur augmentent l'utilité tout en élargissant la frontière d'autorité. La disponibilité, les contrôles administratifs et les autorisations de connecteur peuvent différer selon le plan et le déploiement.

Une annonce de produit ne remplace pas une revue de sécurité spécifique à l'espace de travail.

Il existe également un problème humain-système. Lorsque les agents continuent pendant des heures, les utilisateurs peuvent approuver un travail qu'ils n'ont pas observé de près. De meilleurs résumés aident, mais la qualité de l'approbation dépend de la présentation de l'effet proposé, de l'incertitude et des vérifications échouées au moment de la décision.

La conception du produit doit protéger l'attention humaine, pas simplement demander un clic.

Le modèle le plus fort n'est donc pas l'architecture finale.

La qualité de production provient de la relation entre :

• Le modèle
• Le harnais
• La politique
• Les outils
• Les preuves
• Le propriétaire responsable

C'est ce que le plan de contrôle de l'agent rend explicite.

Foire aux questions

Qu'est-ce que GPT-5.6 ?

GPT-5.6 est la famille de modèles d'OpenAI de juillet 2026, organisée en niveaux de capacité Sol, Terra et Luna. Sol est l'itinéraire de plus haute capacité, Terra équilibre capacité et coût, et Luna priorise la vitesse et l'abordabilité.

Qu'est-ce que ChatGPT Work ?

ChatGPT Work est un espace de travail agentique pour des tâches de longue durée à travers les fichiers, les applications, les actions du navigateur, l'utilisation de l'ordinateur, et les actions en

travail planifié. Contrairement à un tour de discussion normal, une tâche de type Travail est conçue autour d'un résultat ou d'un artefact finalisé.

Qu'est-ce qu'un plan de contrôle d'agent ?

Un plan de contrôle d'agent est la couche de politiques et d'opérations qui régit l'exécution des agents. Il classe les tâches, choisit une route de modèle, délivre des identifiants avec des périmètres définis, applique des restrictions d'outils, impose des approbations, enregistre les traces, évalue les résultats, contrôle les budgets et gère la reprise.

En quoi un harnais d'agent diffère-t-il d'un plan de contrôle ?

Le harnais est le logiciel qui assemble le contexte, expose les outils, stocke l'état, exécute les actions et gère les tentatives. Le plan de contrôle régit la manière dont ce harnais peut fonctionner, y compris l'autorité, le routage, les budgets, les approbations, l'évaluation et la reprise.

Quand les équipes doivent-elles utiliser Sol, Terra ou Luna ?

Luna convient à l'extraction, la classification et le formatage à faible risque. Terra est adapté au travail de dépôt de code courant, à la production de documents et à l'analyse modérée avec des contrôles stricts. Sol est plus approprié pour le diagnostic ambigu, l'architecture, la revue de sécurité et la recherche à forte valeur ajoutée.

Le passage à Sol donne-t-il plus d'autorisations à l'agent ?

Non. La capacité du modèle et l'autorité opérationnelle doivent rester séparées. Passer de Luna ou Terra à Sol devrait modifier la capacité de raisonnement, et non l'accès aux outils, les droits d'écriture, les droits de déploiement ou les exigences d'approbation.

Pourquoi les benchmarks publics ne suffisent-ils pas pour la sélection en production ?

Les benchmarks publics peuvent contenir des tâches imparfaites, des hypothèses spécifiques au harnais ou des fuites. Ils sont utiles pour découvrir des candidats, mais une évaluation privée construite à partir de travaux internes réels est nécessaire pour mesurer le coût, la fiabilité, la charge de révision et la sécurité dans l'environnement réel.

Que faut-il consigner dans les logs pour un agent à longue exécution ?

Le journal doit inclure l'objectif, la route du modèle, l'effort de raisonnement, les appels d'outils, les sources, les approbations, les erreurs, les tentatives, l'utilisation de tokens, le coût, le temps écoulé, les artefacts, les résultats de validation, les raisons de l'escalade et l'état final.

Outils connexes

• ChatGPT : L'interface produit d'OpenAI pour le chat, le Travail, les outils connectés et les tâches de longue durée.
• API OpenAI : La plateforme officielle pour créer des applications avec GPT-5.6 et l'API Responses.
• Codex : La plateforme d'agent de codage d'OpenAI pour le travail sur les dépôts, le génie logiciel et les compétences d'agent.
• Appel d'outils programmatique : Le guide officiel d'OpenAI pour coordonner les outils et traiter les résultats intermédiaires avec des programmes en mémoire.
• Cadre de gestion des risques liés à l'IA du NIST : Un cadre de gouvernance pour identifier, mesurer et gérer les risques liés à l'IA.
• Databricks : Une plateforme de données et d'IA dont l'équipe d'ingénierie a publié une évaluation privée d'agent de codage basée sur des modifications réelles de dépôt.

Liens connexes

• Disponibilité générale de GPT-5.6 : La publication officielle de GPT-5.6 par OpenAI, incluant les niveaux de modèle, les détails des capacités, la disponibilité et les prix.
• Aperçu de GPT-5.6 Sol :

aperçu technique antérieur du modèle Sol.

• ChatGPT pour un travail ambitieux : L'annonce officielle d'OpenAI décrivant ChatGPT Work et son modèle de tâches à longue durée d'exécution.
• Documentation sur l'appel d'outils programmatique : Documentation officielle pour développeurs sur la coordination programmatique des appels d'outils.
• Séparer le signal du bruit dans les évaluations de codage : Audit et discussion d'OpenAI sur les problèmes de fiabilité dans les benchmarks publics de codage.
• Fiche technique de GPT-5.6 : Document officiel d'évaluation de la sécurité et des capacités d'OpenAI pour GPT-5.6.
• Benchmark d'agent de codage Databricks : Une évaluation privée construite à partir de demandes de tirage réelles dans une base de code de plusieurs millions de lignes.

Résumé

GPT-5.6 offre aux équipes un menu plus clair de capacités, de coûts, d'effort de raisonnement et d'exécution multi-agents. ChatGPT Work étend ces capacités à des tâches persistantes à travers fichiers, applications, navigateurs et workflows planifiés.

Le défi de la production ne consiste pas simplement à sélectionner le modèle le plus puissant. Les équipes ont également besoin d'une identité cadrée, d'autorisations d'outils restreintes, de points d'approbation, de contrôles d'acceptation indépendants, de traces complètes, de budgets multidimensionnels, d'évaluations privées et de procédures de reprise testées.

Commencez par un workflow réversible, enregistrez la référence humaine, exécutez en mode masqué et n'augmentez qu'une seule dimension d'autorité à la fois.

Un agent de qualité production n'est pas simplement un modèle puissant avec des outils. C'est un modèle opérant au sein d'un plan de contrôle mesurable, réversible et responsable.