Plongée dans la boucle d'agent Codex : enseignements de Datadog et du lancement Android de Sora en 28 jours

Codex a permis à quatre ingénieurs de livrer l'application Android de Sora en 28 jours. Chez Datadog, plus d'un millier d'ingénieurs s'appuient aujourd'hui sur lui pour repérer des défauts systémiques que les relecteurs humains laissaient souvent passer. Ces deux histoires découlent de la même architecture : une boucle de contrôle d'apparence simple, enveloppant un modèle de langage, un ensemble d'outils et un environnement sandbox.

Si vous construisez un assistant de programmation IA, un pipeline de génération de médias, ou tout agent qui doit agir sur le monde, la boucle d'agent Codex est la référence la plus propre que vous puissiez étudier aujourd'hui. Cet article parcourt de bout en bout son fonctionnement, ce que les équipes de production en font réellement, et comment le même schéma d'architecture se transpose aux agents de génération de médias que vous pouvez construire sur hiapi.

Cet article s'appuie sur l'article d'ingénierie public d'OpenAI « Dérouler la boucle d'agent Codex » (janvier 2026), sur l'étude de cas Datadog, et sur le retour d'expérience de la livraison Android de Sora. Les prix de la plateforme Hiapi cités ci-dessous sont ceux de juin 2026.

Qu'est-ce qu'une boucle d'agent, au juste

La boucle d'agent est le flux de contrôle qui se situe entre vous, le modèle de langage et les outils que le modèle est autorisé à appeler. Du point de vue de l'utilisateur, un « tour » ressemble à un message de chat qui entre et un message de chat qui sort. Mais en réalité, un seul tour peut comprendre plusieurs allers-retours entre le modèle et des outils externes.

La forme d'un tour :

1. Préparer le prompt. L'agent assemble le prompt système, les instructions au niveau du projet (dans Codex, les fichiers AGENTS.md), l'historique de la conversation et le nouveau message de l'utilisateur.
2. Raisonner. Le modèle renvoie soit un message assistant final, soit un appel d'outil.
3. S'il s'agit d'un appel d'outil, l'agent exécute cet appel dans le sandbox, capture le résultat, l'ajoute à la conversation, puis retourne à l'étape 2.
4. S'il s'agit d'un message assistant final — du type « J'ai ajouté le architecture.md que tu demandais » — le tour se termine et le contrôle revient à l'utilisateur.

La caractéristique essentielle, c'est que la « sortie » n'est pas seulement le message assistant que vous voyez dans le terminal. L'essentiel de la sortie réelle, ce sont les effets de bord des appels d'outils : les fichiers écrits, les tests lancés, les paquets installés. Le message assistant n'est qu'un signal de terminaison.

C'est pourquoi la boucle d'agent n'est pas simplement « un chat avec quelques étapes en plus ». Le chat n'a qu'un seul aller-retour par tour. La boucle d'agent, elle, peut accomplir des dizaines de cycles « raisonnement → outil → raisonnement » au sein d'un seul tour, l'utilisateur ne voyant que le message de clôture.

Trois caractéristiques qui accélèrent la boucle

L'implémentation naïve de la boucle ci-dessus fonctionne, mais devient lente et coûteuse au bout de quelques tours. La conception de Codex résout ce problème avec trois idées qui méritent d'être reprises.

1. Le cache de préfixe sur l'API Responses. À chaque échange entre l'agent et le modèle, le prompt commence par le même long préfixe : d'abord le prompt système, puis AGENTS.md, puis les échanges antérieurs. La première requête calcule et met en cache l'état clé-valeur interne du modèle correspondant à ce préfixe. Les requêtes suivantes de la même session sautent le recalcul de tout préfixe partagé.

Une conséquence pratique : ne modifiez pas AGENTS.md en cours de session. Le prompt système est généralement le plus gros bloc mis en cache ; le modifier invalide le cache pour le reste de la session. Les propres ingénieurs de Codex citent cela comme la cause la plus fréquente de ralentissement « qu'on se cause soi-même ».

2. Les résultats des appels d'outils restent à l'intérieur de la boucle, au lieu de se superposer à elle. Chaque sortie d'outil est ajoutée à la même conversation. Cela peut sembler évident, mais cela signifie que le modèle garde une mémoire complète de chaque commande exécutée, de chaque erreur vue, de chaque fichier inspecté — sans que vous ayez à résumer quoi que ce soit à la main. Le prix à payer, c'est que la fenêtre de contexte grossit vite ; Codex y remédie par une compression automatique lorsque la conversation devient trop longue.

3. La terminaison est détectée à partir de la forme de la sortie du modèle, pas en comptant les tours. L'agent n'a pas de filet de sécurité fondé sur un nombre maximal d'itérations. Tant que le modèle continue d'émettre des appels d'outils, il boucle ; dès que le modèle émet un message assistant ordinaire, il s'arrête immédiatement. Cette décision est confiée au modèle, ce qui permet de garder le code d'orchestration minimal.

Cas n°1 : Datadog utilise cette boucle pour la revue de code au niveau système

Ce qui rend l'étude de cas Datadog la plus utile, c'est qu'elle vous dit ce que la boucle d'agent réussit en production, et ce qu'elle ne réussit pas.

L'équipe expérience de développement IA de Datadog voulait un agent de revue de code capable de détecter le type de défauts que les relecteurs humains laissent passer — pas le lint, pas le style, mais les régressions inter-services, les falaises de performance et les changements qui rejouent de vraies pannes. Ils ont souligné que la plupart des outils précédents se comportaient comme des « linters améliorés ». Ils ne signalaient que des motifs superficiels à l'intérieur d'un seul diff. Ils n'avaient aucun modèle des systèmes environnants.

Pour valider l'agent avant généralisation, l'équipe a construit un cadre de test par rejeu de pannes : ils ont reconstitué les pull requests qui avaient causé des pannes passées, les ont soumises une à une à Codex comme si elles arrivaient pour revue, puis ont demandé aux ingénieurs d'astreinte : le commentaire de Codex aurait-il changé l'issue ?

Résultat publié : Codex a produit un retour utile et nouveau sur environ 22 % des pannes historiques — plus que tout autre outil évalué par l'équipe. Comme chaque pull request avait alors déjà passé la revue humaine, ce test mesure essentiellement « ce que les relecteurs avaient manqué à l'époque ».

Aujourd'hui, plus de 1 000 ingénieurs Datadog l'utilisent sur chaque PR. Les ingénieurs réagissent aux commentaires par 👍/👎, puis soit modifient le code, soit écartent la suggestion en en donnant la raison. Le choix de conception intéressant, c'est que Datadog mesure l'impact par un canal détourné — des ingénieurs qui postent sur Slack pour mentionner une découverte utile — plutôt que par des métriques formelles dans l'outil. L'équipe considère l'agent comme un renfort, pas comme un garde-barrière ; il présente des signaux, et c'est toujours l'humain qui décide.

Le schéma à en retenir : la boucle d'agent excelle à raisonner à l'échelle du système entier (dépendances, tests, services liés), et pas seulement sur le diff sous les yeux. Cela exige de lui donner les bons outils et les bonnes permissions de lecture. La boucle d'agent est le châssis ; c'est la surface d'outils et le contexte du projet qui déterminent si elle peut exposer un risque réel.

Cas n°2 : livrer Sora pour Android en 28 jours

L'histoire de Sora Android est une preuve plus radicale. Entre le 8 octobre et le 5 novembre 2025, une équipe de quatre ingénieurs a utilisé Codex pour faire passer Sora de « iOS uniquement » à un lancement Android public — un cycle de 28 jours, avec une version interne pour les employés au 18e jour, et un lancement public dix jours plus tard. L'application a atteint le sommet du Google Play Store ; les utilisateurs ont créé plus d'un million de vidéos dans les premières 24 heures. Taux sans plantage au lancement : 99,9 %.

L'équipe a expliqué franchement ce qui a marché et — plus utile encore — ce qui n'a pas marché.

Ce qui n'a pas marché, c'est le prompt évident : « Construis l'application Android de Sora à partir du code iOS. Commence. » Ils l'ont essayé et l'ont vite abandonné. Le résultat était techniquement utilisable, mais l'expérience produit laissait à désirer. Pour reprendre leurs mots, Codex « n'est pas encore doué pour déduire ce qu'on ne lui dit pas », et sans guidage, il peine à exercer un « jugement d'architecture approfondi ».

Ce qui a marché, c'est de traiter Codex comme un traducteur sémantique entre plateformes, et de bâtir autour de lui un échafaudage solide :

• Ils ont d'abord établi les schémas d'architecture du projet — navigation, injection de dépendances, réseau — et écrit à la main quelques fonctionnalités d'exemple. Celles-ci ont fixé le standard pour le reste de la base de code.
• Ils ont utilisé les fichiers AGENTS.md pour encoder les conventions de l'équipe, afin que la sortie de Codex reste cohérente.
• Ils ont fréquemment demandé à Codex de se référer au code Swift iOS et au backend existant, en exigeant qu'il produise du Kotlin sémantiquement équivalent. Leur conclusion : « L'avenir multiplateforme, c'est Codex. »
• Ils ont traité Codex comme « un ingénieur senior qui vient d'arriver » — les humains prennent en charge l'architecture, la conception système et l'expérience utilisateur ; Codex assume le gros du travail dans des périmètres bien délimités.

D'après les rapports, la part de code générée par Codex approche les 85 %, avec un budget d'environ 5 milliards de tokens consommés en quatre semaines.

Deux enseignements sont faciles à sous-estimer ici. Premièrement, la qualité de l'agent est plafonnée par la qualité de l'échafaudage que vous construisez : les exemples, AGENTS.md, un périmètre clair. Deuxièmement, pour un projet greenfield, « une petite équipe plus un agent compétent » l'emporte sur « augmenter le nombre d'ingénieurs » — l'observation de Fred Brooks a enfin trouvé un contre-exemple entre de bonnes mains.

Les schémas transférables

Une fois retirés les détails concrets de la revue de code et de la livraison Android, il reste quatre schémas que toute équipe construisant un agent devrait reproduire.

Établir les schémas avant de passer à l'échelle. Qu'il s'agisse du schéma de navigation (Sora) ou de la définition de ce qui compte comme « changement à risque » (Datadog), le travail humain se fait en amont. Les fonctionnalités d'exemple et un AGENTS.md stable sont votre moyen de transmettre ces schémas à chaque tour suivant — et ce sont précisément les éléments que le cache de préfixe récompense.

Donner à l'agent la bonne surface d'outils, pas la plus grande. Le relecteur de Datadog a besoin d'une lecture inter-services. Le traducteur de Sora a besoin de lire le code source iOS et le backend. Les deux équipes ont soigneusement sélectionné la surface de lecture. Une liste d'outils plus grande n'est pas synonyme de mieux.

Confier l'architecture aux humains, l'implémentation à l'agent. Les deux études de cas convergent vers cette répartition. Les humains fixent les décisions structurelles ; l'agent remplit dans des périmètres bien délimités. Inverser cette répartition, c'est précisément là que les équipes perdent leur temps.

Mesurer par les résultats, pas par les métriques de l'outil. Datadog observe délibérément les réactions Slack et l'issue des pannes, plutôt que le taux de sortie de l'agent lui-même. Cela garde l'objectif d'optimisation honnête. Un outil de revue de code qui produit beaucoup de commentaires sans changer le comportement face aux pannes n'est pas un outil utile.

Appliquer cette boucle aux agents de génération de médias

L'architecture de boucle d'agent n'est pas réservée au code. Partout où vous avez besoin qu'un modèle agisse, observe et itère, le même flux de contrôle s'applique.

La plateforme hiapi expose tous les modèles de génération de médias via un point de terminaison asynchrone unifié — POST /v1/tasks crée une tâche de génération, GET /v1/tasks/:id récupère le résultat — si bien que l'étape « action » de la boucle est une fonction à deux appels que vous écrivez une fois et réutilisez pour tous les modèles. Concrètement, vous pouvez construire un agent de production vidéo dont la boucle ressemble à ceci :

1. L'agent reçoit un brief : « Crée un plan produit de 6 secondes, une montre posée sur du marbre. »
2. Il assemble le prompt et crée une tâche seedance-2-0 via POST /v1/tasks, puis interroge l'ID de tâche jusqu'à l'achèvement (en juin 2026, sur la plateforme hiapi, le 480P est facturé 0,15 $ par seconde de vidéo, et le 720P avec un coefficient de 2,2 — le clip de 6 secondes ci-dessus coûte donc 0,90 $ en 480P).
3. Il télécharge la vidéo générée, exécute une étape de revue rapide — « le cadran est-il vraiment visible ? L'éclairage correspond-il au brief ? » — puis soit accepte la sortie, soit modifie le prompt.
4. Si la revue échoue N fois d'affilée, l'agent escalade vers l'utilisateur avec le meilleur résultat obtenu jusque-là et une description du problème.

La même forme s'applique aux agents de génération d'images : brief → appel texte-vers-image (par exemple gpt-image-2 à 0,03 $ l'image en 1K, ou Nano-Banana-2 à 0,085 $ en 1K) → vérification visuelle → modification → nouvelle tentative. Le schéma de Codex — « mettre en cache de préfixe un prompt système stable, et laisser les sorties d'appels d'outils s'accumuler dans la conversation » — s'applique directement : placez la définition du rôle et les directives de marque dans le prompt système, et laissez la boucle accumuler chaque tentative de génération et chaque revue comme des tours d'un même fil.

Quelques transpositions pratiques des enseignements de Codex vers un agent de médias :

• AGENTS.md devient le fichier de directives de marque. Stable, chargé une seule fois, jamais modifié en cours de session. C'est exactement ce que le cache de préfixe récompense.
• Les fonctionnalités d'exemple deviennent des sorties de référence. Des images sélectionnées à la main montrant « à quoi ressemble un bon résultat », pour que l'étape de revue puisse comparer.
• Le sandbox devient un plafond de débit et de dépense. Un agent de médias qui n'a pas appris quand s'arrêter peut accumuler un grand nombre de générations. Fixez un plafond de dépense par tour, comme Codex limite par défaut les écritures sur le système de fichiers.
• Le signal de terminaison est exactement le même. La boucle se termine lorsque l'étape de revue renvoie « accepter » au lieu d'une nouvelle demande de génération.

Si vous voulez d'abord essayer les modèles de base qui sous-tendent ce type de boucle, sans écrire tout de suite la logique d'orchestration, la page de tarifs hiapi présente le prix actuel par image et par seconde de vidéo, et les pages de détail de chaque modèle disposent d'un Playground pour lancer un prompt avant de décider quoi brancher dans votre agent.

FAQ

Qu'est-ce que la boucle d'agent Codex ?

C'est le flux de contrôle interne à Codex CLI, qui orchestre les allers-retours entre vous, le modèle et les outils que le modèle est autorisé à appeler. Chaque « tour » peut contenir plusieurs cycles raisonnement du modèle → appel d'outil, et se termine lorsque le modèle émet un message assistant ordinaire au lieu d'un nouvel appel d'outil.

Pourquoi le cache de préfixe est-il si important pour un agent ?

Parce que chaque tour renvoie un long préfixe — prompt système, instructions de projet, historique de conversation. Sans cache, le modèle réencode tout cela à chaque requête, ce qui est lent et coûteux. Avec le cache, le préfixe partagé n'est calculé qu'une fois et réutilisé dans les tours suivants de la même session. Conséquence pratique : ne modifiez pas les instructions de projet (par exemple AGENTS.md) en cours de session, car cela invaliderait le cache pour le reste de la session.

Combien d'ingénieurs faut-il pour livrer quelque chose comme Sora pour Android ?

Le chiffre publié par OpenAI est de quatre ingénieurs sur 28 jours, avec près de 85 % de la base de code générée par Codex selon les rapports, et environ 5 milliards de tokens consommés sur l'ensemble du projet. L'équipe a explicitement choisi de rester petite — en citant Brooks, « ajouter des personnes à un projet déjà en retard ne fait que le retarder davantage » — et de s'appuyer fortement sur l'agent pour l'implémentation.

Qu'a réellement détecté Codex dans l'évaluation Datadog ?

Dans la méthode de « rejeu de pannes » de l'équipe, ils ont rejoué via Codex les PR qui avaient historiquement causé des pannes, et ont demandé aux ingénieurs d'astreinte si le retour aurait changé l'issue. Codex a fourni un retour exploitable sur environ 22 % des pannes — par exemple des régressions inter-services et des changements de performance que les relecteurs humains avaient manqués lors de la mise en production initiale.

Puis-je utiliser le même schéma de boucle d'agent pour la génération d'images ou de vidéos ?

Oui. Ce schéma d'architecture — préparer le prompt, appeler le modèle, exécuter les outils, ajouter les résultats, boucler jusqu'à la terminaison — est indépendant du modèle. Vous pouvez le brancher sur les points de terminaison de génération de médias de hiapi (modèles d'image comme gpt-image-2 ou nano-banana-2, modèles vidéo comme seedance-2-0) et suivre les mêmes enseignements : prompt système stable pour le cache de préfixe, exemples pour garantir la qualité, plafond de dépense en sandbox pour la sécurité, étape de revue pour décider de la terminaison.

Que dois-je mettre dans AGENTS.md ?

Spécifiquement pour Codex : les conventions du projet, les commandes de build/test/lint, les règles de style de code, et toute limite « ne pas toucher ». Les équipes Sora et Datadog dont les travaux sont publiés le traitent comme le document d'accueil de l'agent — les choses que vous diriez à un ingénieur senior le premier jour. Gardez-le stable pendant la session afin qu'il reste dans le cache de préfixe.

Points clés à retenir

• La boucle d'agent Codex est un flux de contrôle simple : préparer le prompt → raisonnement du modèle → appel d'outil optionnel → ajouter le résultat → répéter, jusqu'à ce que le modèle émette un message assistant ordinaire.
• Trois détails d'implémentation la rendent apte à la production : le cache de préfixe, les résultats d'appels d'outils conservés dans la conversation, et la détection de terminaison pilotée par la forme de la sortie du modèle.
• Datadog utilise cette boucle pour la revue de code au niveau système de plus de 1 000 ingénieurs ; son cadre de test par rejeu de pannes montre que Codex a détecté environ 22 % des problèmes liés aux pannes historiques que les relecteurs humains avaient manqués.
• OpenAI a livré l'application Android de Sora en 28 jours avec quatre ingénieurs, environ 85 % du code généré par Codex, et un taux sans plantage de 99,9 % au lancement — grâce à un échafaudage intensif d'exemples et de AGENTS.md, et non en se contentant de demander « construis-le ».
• La même architecture de boucle d'agent se transpose proprement aux pipelines de génération de médias que vous pouvez construire sur hiapi : chaque modèle texte-vers-image et texte-vers-vidéo utilise la même forme asynchrone /v1/tasks, et les approches de Codex en matière de cache de préfixe, de sandbox et d'exemples se transposent une à une aux agents d'image et de vidéo.