Boucles et exécutions autonomes dans Codex

Certains travaux de code consistent à répéter la même étape jusqu'à ce qu'une condition soit remplie : lancer les tests, lire l'échec, corriger le code, relancer les tests. C'est exactement ce schémamaUtiliser un logiciel pour automatiser les tâches et campagnes marketing répétitives, afin de personnaliser à grande échelle sur des canaux comme l'email, le web et le social.Voir la définition complète → que Codex a été conçu pour automatiser, non pas comme une requête unique mais comme une boucle agentique qui continue d'éditer et d'exécuter jusqu'à ce que la tâche soit réellement terminée.

La boucle agentique, concrètement

Vous savez déjà qu'un agent planifie, agit et observe. Dans Codex, cette boucle s'appuie sur un vrai espace de travail : un checkout de votre repo, un shell et la capacité d'exécuter des commandes. Chaque tour ressemble à ceci :

1. Lire la tâche et l'état actuel du repo.
2. Décider d'une action (éditer un fichier, lancer une commande).
3. L'exécuter dans le sandbox et capturer la sortie.
4. Comparer le résultat à l'objectif. Si l'objectif n'est pas atteint, boucler.

La différence déterminante avec un prompt unique, c'est l'étape observe. Codex voit stdout, les codes de sortie et les stack traces, puis les réinjecte dans la décision suivante. C'est pourquoi « fais passer les tests » fonctionne : la sortie des tests *est* le signal qui pilote l'édition suivante.

Codex existe sous deux formes qui partagent le même moteur : l'agent CLI/IDE qui tourne en local sur votre working tree, et Codex cloud, qui exécute la boucle sur l'infrastructure d'OpenAI contre un repo GitHub connecté. C'est dans la version cloud que vivent les exécutions autonomes et planifiées. Voir la documentation Codex pour le périmètre actuel.

Quand une boucle vaut mieux qu'une requête unique

Une requête unique convient quand le changement est délimité et que vous pouvez juger le diff d'un coup d'œil. Passez à une boucle quand la tâche a une condition d'arrêt vérifiable que l'agent peut contrôler lui-même :

• Itérer jusqu'à ce que les tests soient verts. La suite de tests définit le « terminé ». L'agent n'a pas besoin de vous entre deux tentatives.
• Écouler un backlog de fichiers. Migrer chaque composant hors d'une APIAPIApplication Programming Interface : une interface standardisée qui permet aux applications de communiquer et d'échanger des données sans connaître leur fonctionnement interne respectif.Voir la définition complète → dépréciée, ajouter des type hints à un répertoire, ou propager un pattern sur 40 modules. La boucle, c'est « pour chaque fichier : appliquer le changement, lancer ses tests, passer au suivant ».
• Corriger jusqu'à ce que le lint et les type checks passent. ruff, mypy, tsc : chacun renvoie un code de sortie propre contre lequel boucler.

Le fil commun : il existe un oracle vérifiable par la machine. Si le « terminé » est subjectif (« rends l'UI plus jolie »), une boucle ne fait que brûler du budget en poursuivant une cible qu'elle ne peut pas mesurer. Gardez ces cas en session interactive.

Itérer jusqu'à ce que les tests soient verts

Voici la boucle canonique. Vous donnez à Codex l'objectif, la commande qui le vérifie et un plafond. En local, cela se traduit par un prompt plus une config ; dans le cloud, vous le configurez par tâche. Ce YAML est le genre de spécification de tâche que vous confieriez à une exécution Codex planifiée :

task: Fix the failing tests in the billing module.
repo: acme/payments
branch: fix/billing-tests
setup:
  - pip install -e ".[dev]"
verify:
  command: pytest tests/billing -q
  success_when: exit_code == 0
limits:
  max_iterations: 8
  max_wall_clock_minutes: 20
on_success:
  open_pull_request: true
  reviewers: [payments-team]

La boucle que l'agent exécute réellement est triviale en pseudocode, et mérite d'être vue pour savoir exactement ce qu'il optimise :

for attempt in range(max_iterations):
    result = run("pytest tests/billing -q")
    if result.exit_code == 0:
        commit("fix: billing tests green")
        break
    # Codex lit result.stdout, édite les fichiers concernés,
    # puis la boucle relance la même commande.
    apply_fix(diagnose(result.stdout))
else:
    report("gave up after max_iterations; latest diff attached")

Deux éléments rendent cela sûr plutôt qu'incontrôlable. D'abord, verify.command est la *seule* définition du succès, donc l'agent ne peut pas s'autoproclamer vainqueur au feeling. Ensuite, la boucle se termine soit sur des tests verts soit sur un plafond strict. Il n'existe aucun chemin où elle tourne indéfiniment.

Lancer des exécutions autonomes et planifiées

Dans Codex cloud, vous connectez un repo GitHub, puis vous démarrez des tâches qui s'exécutent sans vous. Trois manières d'en déclencher une :

• À la demande. Décrivez la tâche, choisissez le repo et la branche, et Codex crcrLe pourcentage de visiteurs ou de prospects qui réalisent une action attendue (achat, inscription, formulaire de contact), calculé en divisant les conversions par le nombre total d'opportunités.Voir la définition complète →ée un environnement, exécute la boucle et ouvre une PR quand il a fini.
• Planifiée. Codex prend en charge les exécutions récurrentes, le même mécanisme que celui derrière les tâches planifiées de ChatGPT. Un job nocturne « lance la suite complète sur main, corrige les tests instables, ouvre une PR » est l'usage classique.
• Déclenchée par événement, via l'API. Branchez une exécution sur la CI ou un webhook (une nouvelle issue étiquetée codex, par exemple) avec l'API Responses et des tools, ou orchestrez un contrôle multi-étapes avec l'Agents SDK.

Le modèle mental : une exécution à la demande, c'est vous qui appuyez sur le bouton. Une exécution planifiée, c'est un cron job qui se trouve être un agent. Les deux déposent leur travail dans une branche et une pull request, jamais directement sur `main`.

Un exemple de backlog planifié

Supposons que vous migriez une codebase hors d'un appel de logging déprécié. Vous ne voulez pas surveiller 40 fichiers. Planifiez une exécution nocturne :

« Pour un maximum de 6 fichiers utilisant encore old_logger, remplace-le par structlog conformément à docs/logging.md, lance pytest pour chaque module touché, et ouvre une seule PR intitulée chore: migrate logging (batch). Ignore les fichiers dont les tests échouent après le changement et signale-les dans la description de la PR. »

Cette spécification comporte une taille de batch (contrôle du coût), une étape de vérification par fichier (justesse) et une porte de sortie explicite pour les cas difficiles (ne pas forcer un changement cassé). En une semaine, le backlog s'écoule tout seul, une PR relisible à la fois.

Conditions d'arrarrL'Annual Recurring Revenue (ARR) est le revenu normalisé et prévisible qu'une entreprise par abonnement attend de ses contrats actifs sur une année.Voir la définition complète →êt : ce qui met réellement fin à une boucle

Une boucle sans surveillance a besoin de plus d'une sortie. Prévoyez toutes celles-ci :

• Condition de succès atteinte. La commande de vérification renvoie le code de sortie 0. C'est le chemin heureux.
• Plafond d'itérations. max_iterations arrête la spirale « éditer, toujours rouge, rééditer ». Si huit tentatives ne rendent pas les tests verts, en ajouter d'autres n'y changera rarement quelque chose.
• Plafond de temps / de budget. Une limite de durée ou de tokenstokensUn token est l'unité de base de texte que traitent les modèles de langage : le plus souvent un fragment de mot, un mot entier ou un signe de ponctuation, plutôt qu'un simple caractère.Voir la définition complète →. Quand Codex n'arrive pas à converger, vous voulez qu'il s'arrête *à bas coût* et vous remette un diff, pas qu'il s'acharne.
• Détection d'absence de progrès. Si deux tentatives consécutives produisent la même sortie en échec, l'agent est bloqué. Une bonne boucle traite cela comme un arrêt, pas comme une raison de retenter le même correctif.

Énoncez chaque plafond explicitement. Le mode de défaillance des exécutions autonomes n'est généralement pas une mauvaise édition ; c'est un agent qui s'acharne sur un problème qu'il ne peut pas résoudre pendant que le compteur tourne.

Plafonds de coût et sandbox

Chaque exécution Codex cloud se déroule dans un conteneur isolé : un environnement neuf avec votre repo, sans accès à vos autres systèmes sauf si vous l'accordez. Cette isolation est votre première frontière de coût et de sécurité, car une boucle qui ne peut pas toucher la production ne peut pas provoquer d'incident en production.

Maîtrisez la dépense à deux niveaux :

• Par exécution : les plafonds d'itérations et de temps ci-dessus. Un plafond de 20 minutes sur un job nocturne borne le pire cas.
• Par compte : définissez des limites d'usage dans les paramètres de facturation de la plateforme OpenAI pour qu'une planification mal configurée ne tourne pas discrètement toute la nuit pendant une semaine.

Maîtrisez aussi ce que la boucle peut atteindre. L'accès réseau dans l'environnement Codex est configurable ; pour un job de correction de tests, l'agent a besoin de votre repo et des installations de packages, pas de l'internet ouvert. Restreignez l'environnement à ce que la tâche exige. Une boucle avec moins de capacités est une boucle avec moins de façons de vous surprendre.

Portes de relecture : faire confiance, mais vérifier le diff

La propriété de sécurité la plus importante : une exécution Codex autonome produit une pull request, pas un merge. La sortie de la boucle arrive sur une branche et attend un humain. Vos protections GitHub existantes s'appliquent toujours, et vous devriez vous appuyer dessus :

• Revues obligatoires. La protection de branche signifie qu'une PR Codex ne peut pas être mergée sans validation humaine (ou CI). Traitez l'agent comme un contributeur dont les PR nécessitent toujours une relecture.
• La CI comme second oracle. L'agent a lancé les tests localement dans son sandbox ; la CI les relance dans votre vrai pipelinepipelineL'ensemble des opportunités commerciales actives réparties selon les étapes du processus de vente, avec leur valeur potentielle cumulée et leur probabilité de conclusion.Voir la définition complète →. Si la CI n'est pas d'accord, le « vert » de la boucle était spécifique à l'environnement, et vous venez de le détecter.
• Diffs cadrés. Les limites de taille de batch (six fichiers, un module) gardent les PR assez petites pour être réellement relues. Un diff autonome de 3 000 lignes n'est pas relisible et va à l'encontre de l'objectif.

Voyez cela comme un funnelfunnelLe parcours client de la découverte à l'achat, généralement Awareness, Interest, Consideration, Decision, Action, avec des prospects de moins en moins nombreux à chaque étape.Voir la définition complète → : la boucle itère librement à l'intérieur du sandbox, mais la sortie est une porte étroite et relisible. Liberté *à l'intérieur*, contrôle *à la frontière*.

Relire une PR Codex rapidement

Comme l'exécution journalise chaque action, ses PR viennent avec une trace : les commandes lancées, la sortie observée, et la raison de chaque édition. À la relecture, vérifiez trois choses : le diff correspond-il à l'objectif annoncé, la commande de vérification est-elle réellement passée (et non désactivée ou marquée @skip), et le changement est-il cadré sur ce que vous avez demandé. Une boucle qui « fait passer les tests » en supprimant le test en échec est la triche classique. Relisez en la cherchant.

Assembler le tout

Une exécution autonome bien conçue se lit comme un contrat. Un objectif, une définition du « terminé » vérifiable par la machine, des plafonds stricts d'itérations et de temps, un environnement restreint, et une sortie uniquement par PR. Donnez ces cinq éléments à Codex et vous pouvez le laisser seul toute la nuit avec la même confiance que vous accorderiez à un ingénieur junior travaillant sur un ticket bien spécifié : soit il termine le ticket, soit il vous explique pourquoi il n'a pas pu.

Points clés

• N'utilisez une boucle que si le « terminé » est vérifiable par la machine. Tests qui passent, lint propre, code de sortie d'un type check. Si la cible est subjective, restez en interactif.
• Fixez toujours trois plafonds : condition de succès, limite d'itérations et plafond de temps/budget. La défaillance dangereuse est un agent qui s'acharne sur un problème insoluble, pas une seule mauvaise édition.
• Planifiez le travail récurrent (migrations de backlog, corrections de tests nocturnes) avec des tailles de batch et une vérification par élément, pour que chaque exécution vide la file en petites PR relisibles.
• Gardez le sandbox restreint. N'accordez que l'accès au repo et le réseau dont la tâche a besoin ; définissez des limites d'usage au niveau du compte pour qu'une planification mal configurée ne fasse pas exploser les coûts.
• La sortie est une pull request, jamais un merge. Appliquez la protection de branche, relancez les tests en CI, et relisez toujours le diff pour repérer la triche du « test en échec supprimé ».