OpenAI Codex 0.160.0 fait de la fiabilité la fonctionnalité centrale de l’agent

OpenAI Codex 0.160.0 est arrivé avec quatre nouvelles fonctionnalités et six groupes de correctifs, mais sa véritable évolution est opérationnelle plutôt que cosmétique. Publiée le 1er octobre 2026, la mise à jour facilite la recherche, la reprise, la supervision et la récupération des sessions d’agents en cours après des interruptions.

Cette priorité crée un contraste révélateur. Les agents de codage sont souvent jugés sur le code qu’ils produisent lors d’une tâche unique. OpenAI investit désormais fortement dans tout ce qui entoure cette tâche, notamment l’historique, les autorisations, les transferts, la récupération de connexion et la configuration de l’environnement.

La compétition principale n’oppose plus seulement Codex à Claude Code, GitHub Copilot ou un autre assistant de programmation. Elle oppose les opérations d’agents persistants au modèle de chat jetable, où chaque session recommence à zéro et où les échecs restent isolés. La version 0.160.0 suggère qu’OpenAI s’attend à ce que les développeurs traitent le travail des agents comme un état opérationnel durable.

Ce que change réellement OpenAI Codex 0.160.0

La mise à jour transforme plusieurs points de défaillance cachés en éléments gérés du flux de travail Codex.

La version officielle 0.160.0 répartit ses changements entre nouvelles fonctionnalités, corrections de bugs, documentation et travail de maintenance. Les principaux ajouts concernent l’historique des tâches, l’interaction avec le terminal Linux, les sessions sans projet et le contexte de révision Guardian facultatif.

L’historique des tâches reçoit l’un des changements les plus visibles. Le centre de commande de l’agent n’initialisait auparavant que dix sessions récentes, sans accès direct aux travaux plus anciens. La nouvelle ligne « Afficher plus », accessible au clavier, peut découvrir jusqu’à dix tâches supplémentaires à chaque demande.

Il ne s’agit pas seulement d’une pagination ajoutée à une liste. Codex conserve des curseurs distincts et des résultats mis en mémoire tampon pour différentes sources d’historique. Il fusionne ensuite les sessions interactives et non interactives selon leur récence.

L’interface conserve également les résultats existants lorsqu’une requête ultérieure échoue. Elle remplit les emplacements vides après l’archivage ou la suppression de tâches, tout en empêchant des actualisations obsolètes de restaurer des tâches supprimées. Ces détails comptent lorsque l’historique devient un registre opérationnel plutôt qu’un simple menu pratique.

Les utilisateurs Linux bénéficient d’un autre correctif d’interaction. En mode plein écran sur les terminaux X11 locaux pris en charge, ils peuvent sélectionner du texte de transcription et le coller via la sélection principale avec un clic central. Ce comportement rapproche Codex des conventions établies des terminaux.

Les sessions sans projet reçoivent une mise à jour plus conséquente. Codex peut désormais commencer à travailler hors d’un projet reconnu en utilisant les valeurs par défaut de l’espace de travail, mais uniquement lorsque la configuration locale et la politique administrée l’autorisent.

Les tâches reprises peuvent restaurer leur profil d’autorisations enregistré, sauf si l’utilisateur le remplace explicitement. Les tours ordinaires ne doivent pas remplacer le profil enregistré par le serveur. Les choix explicites de révision des approbations restent distincts des autorisations de tâche restaurées.

La version étend également Guardian, une couche de révision automatisée qui évalue les actions proposées par l’agent. Deux capacités facultatives permettent à Guardian de récupérer des instructions utilisateur antérieures et de recevoir du contexte sélectionné à partir des transferts d’agents.

Ces deux ajouts Guardian sont désactivés par défaut. Cette distinction est importante, car les changements élargissent le contexte disponible lors de la révision des actions. OpenAI les présente comme des capacités de sécurité contrôlées, et non comme un comportement universel appliqué silencieusement à chaque session.

Les correctifs de bugs renforcent le même thème. Codex peut reprendre les messages mis en file d’attente après une reconnexion sans renvoyer aveuglément les soumissions incertaines. Il préserve davantage de paramètres du terminal, corrige plusieurs chemins de sandbox Windows et améliore l’héritage d’environnement des sous-agents.

OpenAI a également traité les blocages SQLite, les délais d’initialisation trompeurs, les catalogues de fournisseurs obsolètes, l’analyse répétée des plugins et l’espace inutilisé de la base de données de journaux. Ces changements ne modifient pas l’intelligence apparente du modèle. Ils réduisent le nombre de situations dans lesquelles un flux de travail d’agent peut devenir confus ou incohérent.

C’est pourquoi cette version compte. Elle considère le système qui entoure l’agent comme une partie du produit, et non comme une plomberie que les utilisateurs devraient tolérer.

Les anciennes tâches transforment le centre de commande en registre opérationnel

Un historique consultable et extensible transforme Codex, d’une succession de prompts, en un espace de travail doté de mémoire.

Avant cette mise à jour, le centre de commande chargeait dix sessions récentes. Les utilisateurs pouvaient rechercher parmi ce que l’interface avait chargé, mais ils ne disposaient d’aucun moyen direct de remonter davantage dans l’historique des tâches.

La nouvelle conception de pagination des tâches ajoute une ligne « Afficher plus » sélectionnable. Elle reste disponible pendant la recherche et comprend des états de chargement et de nouvelle tentative conçus pour la navigation au clavier.

Une progression de dix tâches paraît modeste. Le point important est qu’OpenAI a conçu la gestion d’état environnante pour un historique qui continue de croître.

Codex stocke des curseurs pour chaque source et met les résultats en mémoire tampon entre les requêtes. Il fusionne différents types de sessions selon leur récence plutôt que de supposer une source unifiée. Si une requête échoue, les tâches déjà chargées restent visibles.

Ce comportement répond à une situation de développement courante. Un utilisateur peut devoir revenir sur une investigation menée plusieurs jours plus tôt après qu’un nouveau bug a révélé des symptômes connexes. Perdre les lignes antérieures lors d’une actualisation échouée transformerait l’historique en index peu fiable.

La mise à jour limite également les actualisations de détails de routine aux fils récents, chargés ou explicitement demandés. Ce choix contrôle le travail en arrière-plan à mesure que l’ensemble visible de tâches s’élargit. Il indique qu’OpenAI s’attend à ce que les collections d’historique deviennent sensiblement plus grandes.

L’historique persistant met sous pression le modèle de session jetable utilisé par les assistants plus simples. Un assistant éphémère doit seulement répondre au prompt actuel. Un agent persistant doit préserver son identité, son ordre, sa configuration et ses autorisations au fil du temps.

Cette différence modifie les attentes des utilisateurs. Dès qu’une tâche apparaît dans un centre de commande, elle commence à ressembler à un élément de travail plutôt qu’à une transcription de chat. Les utilisateurs s’attendent à pouvoir la retrouver, la reprendre, la bifurquer et comprendre son état actuel.

Les équipes disposent également d’un chemin plus clair pour récupérer le raisonnement et le contexte de mise en œuvre. Une tâche peut conserver la séquence ayant produit un correctif, y compris les corrections ultérieures. Cela peut compléter une base de connaissances consultable contenant des spécifications, des décisions et des documents techniques locaux.

L’historique conserve toutefois des limites. La pagination n’équivaut pas à la recherche sémantique, au reporting de projet ou à une journalisation d’audit formelle. La version ne prétend pas fournir ces systèmes.

Le centre de commande doit également représenter des sources de tâches mixtes sans créer de fausse équivalence. Une session locale interactive peut reposer sur des hypothèses différentes de celles d’une tâche exécutée à distance. Les trier ensemble facilite leur découverte, mais n’efface pas ces différences.

L’implémentation d’OpenAI reconnaît cette complexité grâce à des curseurs par source et à un ordre fusionné. Elle empêche également que des requêtes obsolètes fassent réapparaître des tâches supprimées, une règle de cohérence subtile mais importante.

Cela positionne l’historique des sessions comme une infrastructure partagée. La reprise, la bifurcation, la recherche, la suppression et l’archivage dépendent tous du comportement prévisible de ce même registre.

Claude Code et GitHub Copilot font face à la même pression produit plus large, même lorsque leurs interfaces diffèrent. À mesure que les assistants de programmation assument des missions plus longues, les utilisateurs exigeront des historiques durables plutôt que des fenêtres conversationnelles isolées.

La question concurrentielle n’est donc pas de savoir qui affiche la liste la plus longue. Elle est de savoir quel produit peut rendre l’ancien travail des agents suffisamment fiable pour être réutilisé.

Pour OpenAI, « Afficher plus » est le contrôle visible. L’évolution plus large consiste à accepter que l’historique des agents exige la même gestion d’état rigoureuse que les autres systèmes destinés aux développeurs.

Les correctifs de reconnexion traitent le type d’ambiguïté le plus coûteux

Un agent de programmation doit distinguer un travail qui a échoué d’un travail dont l’état est simplement inconnu.

Les interruptions réseau créent un problème difficile pour tout agent avec état. Un client peut perdre sa connexion après avoir envoyé un message, mais avant d’avoir reçu confirmation. Renvoyer ce message pourrait dupliquer une action, tandis que l’abandonner pourrait laisser le travail demandé inachevé.

Le correctif de reconnexion d’OpenAI sépare les messages non envoyés des messages soumis sans confirmation de livraison. Codex réconcilie les prompts et les messages de pilotage à l’aide d’identifiants exacts de messages client trouvés dans l’historique restauré, les événements mis en mémoire tampon et les accusés de réception ultérieurs.

Les soumissions confirmées quittent la file récupérée. Les messages qui n’ont jamais été envoyés peuvent reprendre après relecture. Les soumissions incertaines restent en pause plutôt que d’être transmises à nouveau.

L’interface identifie également le message dont la livraison n’a pas pu être confirmée. Elle donne ainsi à l’utilisateur une ambiguïté précise à résoudre plutôt qu’un avertissement de connexion générique.

Cette distinction est importante, car les prompts d’agents peuvent provoquer des effets de bord. Une requête répétée pourrait modifier deux fois le même fichier, invoquer à nouveau une action externe ou créer un second résultat après que le premier a réussi.

Les clients de chat traditionnels peuvent souvent tolérer du texte dupliqué. Un système d’agents ne peut pas supposer que la répétition est inoffensive. Ses messages peuvent correspondre à des actions, et non à la seule conversation.

OpenAI a conservé les pauses pour les conversations indisponibles, les demandes de compaction ou de révision en attente et les échecs de récupération existants. En d’autres termes, la reprise automatique ne s’applique que lorsque le client peut établir un état sûr.

C’est un exemple pratique de la pression exercée par l’idempotence. L’idempotence signifie que répéter une opération produit le même effet que l’exécuter une seule fois. De nombreuses actions d’agents ne sont pas naturellement idempotentes ; le client doit donc éviter les relectures imprudentes.

La version ne prétend pas assurer une récupération parfaite dans toutes les conditions de défaillance. Un historique manquant ou des confirmations retardées peuvent toujours rendre une soumission incertaine. Le comportement le plus sûr consiste à exposer cette incertitude.

Ce choix révèle le compromis central des agents persistants. Davantage d’automatisation peut réduire les frictions, mais la récupération automatique peut créer des risques lorsque le système ne dispose pas de suffisamment d’éléments.

OpenAI résout ce compromis particulier en ne reprenant que les entrées connues comme non envoyées. Il met en pause le cas ambigu et demande à l’utilisateur de l’examiner. C’est moins fluide qu’une relecture inconditionnelle, mais cela protège contre les exécutions en double.

Le même principe apparaît ailleurs dans OpenAI Codex 0.160.0. Les sessions sans projet reçoivent les valeurs par défaut de l’espace de travail uniquement lorsque la politique l’autorise. Guardian ne reçoit de contexte supplémentaire que via des fonctionnalités facultatives. Les sous-agents conservent les environnements en attente au lieu de prétendre que ces environnements sont prêts.

Ces changements privilégient un état explicite aux hypothèses optimistes. Cette approche peut sembler prudente, mais elle devient plus précieuse à mesure que les agents gèrent des séquences plus longues et des outils aux conséquences plus importantes.

L’interface utilisateur du terminal préserve également les paramètres du fournisseur serveur, du résumé de raisonnement et de verbosité. Les historiques de reprise et de bifurcation utilisent désormais la bonne recherche de fournisseur de modèle. Ces corrections empêchent qu’une session récupérée paraisse équivalente tout en utilisant silencieusement une configuration différente.

Pour un développeur individuel, l’avantage est la continuité. Une interruption de connexion ne devrait ni effacer le travail mis en file d’attente ni dupliquer une requête.

Pour les utilisateurs en entreprise, les enjeux sont plus élevés. Les soumissions incertaines compliquent la responsabilité, en particulier lorsqu’un agent peut modifier des dépôts ou interagir avec des services connectés. L’état récupérable doit préserver à la fois l’intention et les preuves.

C’est là que les opérations d’agents persistantes prennent l’avantage sur les discussions éphémères. Une session jetable peut simplement échouer. Un système durable doit expliquer ce qui s’est passé, conserver ce qui reste valide et s’arrêter là où s’arrête la certitude.

Guardian gagne en contexte, mais davantage de contexte ne signifie pas automatiquement davantage de sécurité

Guardian peut examiner une plus grande part de l’intention de l’utilisateur, mais la qualité de cet examen dépend toujours de la sélection du contexte et de la politique en vigueur.

Un évaluateur automatisé ne peut analyser que les éléments qui lui sont fournis. Si un agent propose une action après une longue conversation, le dernier segment de transcription peut omettre l’instruction qui l’autorisait initialement.

La nouvelle fonctionnalité facultative de récupération de l’historique répond à cette lacune. Lorsqu’elle est activée avec Apps, Guardian peut rechercher et lire les messages antérieurs de l’utilisateur via la connexion active et l’identité de conversation de la session parente.

Le cas d’usage visé est précis. Une transcription tronquée peut omettre des instructions antérieures, des restrictions ou des autorisations révoquées. Guardian a besoin d’un historique pertinent avant d’approuver une action ayant des effets de bord.

L’implémentation vérifie à nouveau la politique actuelle du parent concernant les apps et les outils à chaque appel. Les outils désactivés restent indisponibles, et les appels nécessitant une approbation sont refusés. Un outil précédemment disponible ne devient pas autorisé de manière permanente grâce au contexte historique.

OpenAI demande également à l’évaluateur de distinguer l’autorisation de l’utilisateur du contexte généré par l’assistant. Cela empêche qu’une déclaration antérieure de l’assistant soit considérée comme équivalente à l’autorisation de l’utilisateur.

Les révocations ultérieures comptent elles aussi. Si un utilisateur a auparavant autorisé une action puis retiré cette autorisation, l’instruction la plus récente doit prévaloir lors de l’examen. La conception de la récupération prend explicitement en compte les résultats incomplets et l’évolution des autorisations.

Les réponses d’historique utilisent une limite par défaut estimée à 4 000 tokens. Les administrateurs peuvent configurer ce plafond, tandis que des limites plus strictes du parent ou de l’évaluateur continuent de s’appliquer.

La seconde capacité facultative sélectionne le contexte racine autour des transmissions entre agents. Pour chaque transmission pertinente, Guardian peut recevoir les trois messages racine précédents. Il peut aussi recevoir les trois derniers messages racine afin que les annulations récentes restent visibles.

Cela aide lorsqu’un agent parent délègue du travail à un sous-agent. La transcription locale de l’enfant peut expliquer la tâche attribuée tout en omettant l’autorisation plus large qui rendait cette tâche acceptable.

Cependant, un contexte supplémentaire ne garantit pas une compréhension complète. La récupération peut manquer un passage pertinent, et les fenêtres de transmission sélectionnées peuvent exclure une instruction située hors de leurs limites. Une transcription plus longue peut également contenir des demandes contradictoires.

La fonctionnalité reste désactivée par défaut, ce qui limite son exposition immédiate. Ce statut signifie aussi que les utilisateurs ne doivent pas supposer que chaque examen effectué par Guardian consulte désormais l’intégralité de leur historique de conversation.

La confidentialité et le traitement des données méritent une attention particulière. Lorsque l’option est activée, l’implémentation utilise la connexion Apps active et l’identité de conversation du parent. Les organisations doivent comprendre quels messages deviennent accessibles au circuit d’examen.

Le système d’évaluation préserve également une distinction entre l’autorisation et le contexte de la tâche. Cette frontière est essentielle. Savoir pourquoi un agent a reçu une tâche n’autorise pas automatiquement chacune des actions qu’il pourrait choisir d’effectuer.

C’est le compromis central de cette version. Les agents persistants ont besoin de davantage de contexte pour éviter des malentendus dangereux, mais un contexte plus large accroît la quantité d’informations qu’un évaluateur doit traiter correctement.

Les garde-fous d’OpenAI répondent à plusieurs modes de défaillance évidents. Ils incluent des contrôles de politique en direct, des limites de messages, des paramètres désactivés par défaut, la prise en compte des révocations et des règles d’isolation pour les sessions dotées de registres d’extensions explicites.

Néanmoins, les pull requests publiques fournissent des descriptions d’implémentation et une couverture de tests, pas des preuves indépendantes de l’exactitude des évaluations dans le monde réel. Les utilisateurs devraient éviter de considérer Guardian comme un substitut à des autorisations limitées et à une confirmation humaine.

Cette fonctionnalité se comprend mieux comme une défense en profondeur. Elle peut aider un évaluateur à localiser des éléments pertinents. Elle ne peut pas garantir que chaque autorisation ambiguë recevra la bonne interprétation.

Cette incertitude doit guider l’adoption. Les équipes peuvent activer la fonctionnalité pour des flux de travail contrôlés, examiner le comportement des évaluations et maintenir les actions importantes derrière des approbations explicites.

Les sessions sans projet élargissent l’accès sans abandonner la politique

Codex démarre désormais plus facilement en dehors d’un projet formel, tout en conservant les contrôles d’autorisation comme frontière déterminante.

Le travail de programmation ne commence pas toujours dans un dépôt. Les développeurs examinent des répertoires de configuration, des exports temporaires, des journaux, des fichiers générés et des dossiers qui ne sont pas encore devenus des projets.

Les hypothèses antérieures liées aux projets pouvaient ajouter de la friction dans ces situations. OpenAI Codex 0.160.0 introduit des sessions de terminal sans projet qui utilisent les valeurs par défaut de l’espace de travail lorsque l’exécution locale, la configuration et la politique gérée le permettent.

L’implémentation peut ignorer les invites de confiance de dossier pour les répertoires locaux sans projet découverts localement et dépourvus de décision de confiance enregistrée. Elle applique les autorisations d’écriture dans l’espace de travail et les paramètres d’approbation granulaires par défaut uniquement lorsque la politique concernée les autorise.

Windows bénéficie d’une protection supplémentaire. Codex demande la configuration du sandbox si nécessaire avant d’activer des autorisations implicites d’écriture dans l’espace de travail.

La mise à jour restaure également les autorisations de tâche enregistrées lors d’une reprise, sauf si l’utilisateur les remplace explicitement. Cela évite qu’une tâche reprise revienne silencieusement avec un profil d’autorisation différent.

Les tours de conversation ordinaires ne doivent pas écraser le profil enregistré sur le serveur. Les choix explicites effectués via un évaluateur d’approbation restent suivis séparément. Cette séparation réduit les modifications accidentelles de la politique durable des tâches.

Les changements de répertoire reçoivent un traitement similaire. La commande /cd peut demander la confiance du dossier et proposer une option « Conserver le répertoire actuel ». Codex vérifie à nouveau l’activité de la tâche et les terminaux en arrière-plan avant de changer d’emplacement.

Il applique aussi les exigences d’autorisation de la destination. Un changement de répertoire demeure donc une transition de politique, et non une simple mise à jour de chemin.

L’avantage immédiat est la flexibilité. Un développeur peut commencer une enquête autour d’un groupe de fichiers isolés sans devoir d’abord les organiser dans une structure de projet reconnue.

L’implication plus large concerne l’identité de l’espace de travail. Si un agent peut fonctionner en dehors des dépôts, la frontière du projet ne peut plus porter à elle seule toutes les hypothèses de confiance, de stockage et d’autorisations.

Cela accroît la pression en faveur d’une politique explicite. Les valeurs par défaut de l’espace de travail, les profils de tâche enregistrés, la confiance dans les répertoires et l’état de préparation du sandbox deviennent les mécanismes qui définissent le comportement autorisé.

La mise à jour ne supprime pas le consentement. Elle modifie l’endroit où ce consentement est représenté et le moment auquel Codex peut déduire une valeur par défaut sûre.

Cette distinction importe pour les utilisateurs qui comparent les flux de travail d’OpenAI Codex avec Claude Code ou GitHub Copilot. Un point d’entrée flexible n’est utile que si la reprise, le changement de répertoire et la restauration des autorisations produisent des résultats prévisibles.

Le fonctionnement sans projet peut aussi rendre l’usage d’agents pertinent pour davantage de tâches de travail intellectuel. Les investigations techniques combinent souvent du code source avec des spécifications, des journaux, des notes de réunion et des rapports générés.

Les développeurs peuvent réunir ce contexte grâce au knowledge blending, puis demander à un agent de travailler sur les éléments de preuve ainsi rassemblés. La frontière des autorisations doit rester claire lorsque ces sources contiennent des informations sensibles.

Le point de vue sceptique est simple. Les valeurs par défaut peuvent réduire la friction tout en rendant les changements d’autorisation moins visibles. Les utilisateurs risquent de confondre « autorisé par la politique » avec « sûr pour cette tâche précise ».

OpenAI répond en partie à ce risque en séparant les autorisations stockées des choix explicites de l’évaluateur. L’entreprise préserve aussi le consentement au répertoire lorsqu’une destination requiert une décision de confiance différente.

Les notes de version ne fournissent ni données d’adoption ni résultats d’incidents en entreprise. Rien ne permet d’affirmer que les sessions sans projet sont plus sûres que les sessions liées à un dépôt dans tous les environnements.

Le changement significatif est plus limité. Codex peut commencer à travailler dans davantage d’endroits sans abandonner son modèle de politique. La question de savoir si les organisations accepteront cet équilibre dépendra de leur configuration gérée et de leurs besoins d’audit.

Trois signaux montreront si la stratégie de fiabilité fonctionne

Le prochain test consistera à déterminer si ces améliorations de gestion de l’état restent compréhensibles sous de vraies charges de travail.

Le premier signal sera l’adoption des fonctionnalités facultatives de contexte de Guardian. OpenAI devrait observer si les utilisateurs activent la récupération de l’historique des conversations et l’examen tenant compte des transmissions dans des flux de travail durables.

Si l’adoption augmente sans hausse correspondante des approbations déroutantes, la stratégie de contexte gagnera en crédibilité. Si les équipes maintiennent ces options désactivées, cette capacité supplémentaire pourrait être trop difficile à gouverner.

Les éléments les plus utiles décriraient les fausses approbations, les blocages inutiles, les révocations manquées et la latence de l’évaluateur. Un simple indicateur de fonctionnalité ne peut pas montrer si Guardian interprète correctement les instructions récupérées.

Le deuxième signal concerne le comportement de récupération lors de connexions instables. La nouvelle logique de file d’attente distingue les messages non envoyés des soumissions dont le statut demeure incertain. Les sessions réelles mettront cette distinction à l’épreuve sur de longues tâches, plusieurs appareils et des accusés de réception serveur retardés.

Un nombre réduit d’actions en double renforcerait la thèse d’OpenAI sur l’espace de travail persistant. Des notifications fréquentes d’incertitude l’affaibliraient, même si la mise en pause reste plus sûre qu’une répétition automatique.

Les utilisateurs devraient aussi vérifier si les prochaines versions appliquent le même modèle de rapprochement à davantage de types d’événements. Les systèmes d’agents produisent des appels d’outils, des évaluations, des transmissions, des changements d’environnement et des sorties de terminal au-delà des simples prompts.

Le troisième signal sera de savoir si l’historique du centre de commande devient le socle d’une gestion des tâches plus étendue. La pagination permet l’accès aux sessions plus anciennes, mais une adoption durable créera une demande pour une récupération et une organisation plus solides.

Parmi les prochaines étapes utiles pourraient figurer des filtres plus riches, des statuts de tâche plus clairs, des libellés persistants ou de meilleurs liens entre les sessions et les modifications de code qui en résultent. Ces possibilités ne sont pas des fonctionnalités annoncées ; elles restent donc des points d’observation plutôt que des promesses.

Le même signal s’applique aux concurrents. Si d’autres agents de programmation mettent l’accent sur les tâches reprenables, la continuité des autorisations et un état récupérable, le marché valide les opérations persistantes comme catégorie de produit fondamentale.

Les prochaines versions d’OpenAI devraient également montrer à quel point cette architecture s’étend aux sous-agents. La version 0.160.0 préserve déjà les environnements encore en cours de démarrage lorsqu’un agent enfant est créé.

L’enfant reçoit la configuration ultérieure ou l’échec de l’environnement d’origine, au lieu de perdre cet environnement. Les attentes de configuration en cours peuvent aussi survivre aux nouvelles tentatives de l’exécuteur.

Cela réduit une condition de concurrence, qui survient lorsque le timing modifie le résultat d’une opération. Un enfant démarrant légèrement plus tôt ne devrait pas recevoir un environnement différent uniquement parce que la préparation n’est pas terminée.

L’orientation est cohérente dans l’ensemble de cette version. Les sessions anciennes restent accessibles. Les messages en file d’attente survivent aux reconnexions. Les autorisations reviennent avec les tâches reprises. Guardian peut retrouver le contexte d’autorisation pertinent. Les sous-agents conservent les environnements encore en préparation.

Aucune de ces modifications ne garantit un meilleur code généré. Ensemble, elles répondent à la question de savoir si les utilisateurs peuvent faire confiance au processus qui entoure la génération de code.

Ce processus devient le terrain de la concurrence. La qualité des modèles reste importante, mais le travail durable avec des agents dépend aussi de la récupération, des frontières d’autorisation, de la provenance du contexte et de l’incertitude visible.

OpenAI Codex 0.160.0 n’est donc pas un lancement spectaculaire de capacités. Il s’agit d’une version d’infrastructure visant à faire en sorte que les agents se comportent comme des collaborateurs persistants plutôt que comme des répondeurs de prompts jetables.

Les développeurs devraient tester la mise à jour sur leurs flux de travail les moins ordonnés. Reprenez une ancienne tâche, interrompez une connexion, démarrez en dehors d’un dépôt et vérifiez quelles autorisations sont rétablies.

Les équipes qui évaluent des agents de programmation devraient poser une question directe : le système peut-il expliquer ce qui a été conservé, ce qui a changé et ce qui demeure incertain après une interruption ?

Si la réponse reste claire dans le cadre d’un travail réel, la stratégie de fiabilité d’OpenAI porte ses fruits. Si les utilisateurs doivent reconstituer manuellement l’état, le centre de commande ne reste qu’une interface soignée reposant sur des sessions fragiles.