GPT-6 Astra : Manuel pratique pour optimiser Codex, les agents et les coûts

Objectif :

Apprendre à distribuer intelligemment Luna, Terra, Sol et Astra pour maximiser les performances, réduire les coûts et maintenir les workflows des agents sur de longues périodes.

L'OpenAI GPT-6 Astra, annoncé le 3 septembre 2026, représente un bond majeur dans la capacité des agents à effectuer des tâches informatiques complexes qui nécessitaient auparavant une intervention humaine considérable.

Mais le véritable défi n'est plus simplement de se demander « Astra peut-elle faire cette tâche ? ».

La question importante est désormais :

Où Astra apporte-t-elle une réelle valeur ajoutée, comment devrions-nous allouer nos ressources, comment pouvons-nous faire travailler les agents plus longtemps, et comment y parvenir au coût le plus bas possible ?

Cet article s'adresse principalement à ceux qui utilisent régulièrement Codex et les agents de programmation, en particulier dans des environnements proches de la production.

Public cible

Ce manuel est conçu pour les personnes qui :

• Utilisent des agents via Codex ou l'API OpenAI dans des environnements proches de la production.
• Souhaitent alterner entre Luna, Terra, Sol et Astra pour réduire les coûts mensuels d'API ou d'infrastructure.
• Veulent construire des workflows de longue durée pour : le débogage exhaustif, les refontes importantes, l'utilisation d'outils informatiques, la vérification mathématique, les tests automatisés et les tâches nécessitant de maintenir un contexte pendant longtemps.

0. Prérequis

Déploiement, Enterprise, Daybreak et Disponibilité

Avant de tenter d'optimiser Astra, vous devez d'abord vérifier que le modèle est effectivement disponible pour votre compte et votre environnement.

Date d'annonce

3 septembre 2026 — annonce officielle

OpenAI — GPT-6 Astra

Déploiement

Selon les annonces officielles, Trusted Access/Daybreak sera l'un des premiers canaux de déploiement.

Les formules Plus, Pro, Business et Enterprise, ainsi que l'API et AWS, seraient déployées ultérieurement.

Dans les environnements d'entreprise, l'administrateur peut avoir besoin d'activer explicitement l'accès.

Points importants

• Enterprise : l'administrateur doit l'activer le cas échéant.
• Niveau gratuit : Astra n'est pas prévue comme modèle gratuit.
• Crédits : les utilisateurs des formules payantes peuvent avoir des options de crédit supplémentaires selon le produit.
• Cybersécurité : certaines capacités avancées peuvent être conditionnées à des voies d'accès spécifiques comme Daybreak.
• ID du modèle API : gpt-6-astra.

Prix standard de l'API

Selon les tarifs indiqués dans ce document :

• Entrée : 10 $ / million de tokens.
• Sortie : 50 $ / million de tokens.

Il existe différents tarifs et conditions pour certains modes, contextes longs, mise en cache et traitement prioritaire.

Règle fondamentale :

le fait qu'Astra n'apparaisse pas dans l'interface ne signifie pas nécessairement que le modèle n'existe pas pour votre organisation. Vérifiez d'abord la disponibilité, les autorisations et le déploiement.

Pendant la vérification de l'accès, la stratégie peut être construite en utilisant Sol comme modèle de base.

1. Où Astra excelle-t-elle et où Sol est-elle suffisante ?

Astra est conçue comme un modèle haut de gamme pour les tâches professionnelles, en particulier celles liées à :

• l'utilisation de l'ordinateur,
• la navigation,
• le génie logiciel,
• les agents,
• la science,
• les mathématiques,
• les tâches complexes de bout en bout.

La documentation officielle positionne les modèles haut de gamme pour les tâches de bout en bout les plus difficiles.

La stratégie correcte, cependant, n'est pas d'utiliser Astra pour absolument tout.

La stratégie correcte est :

Utilisez Astra uniquement lorsque sa capacité supérieure a un réel impact sur le résultat.

1.1. Où la différence apparaît-elle vraiment ?

Les différences les plus importantes ont tendance à apparaître dans les tâches où plusieurs facteurs se combinent :

• plusieurs fichiers ou modules,
• de nombreuses étapes consécutives,
• une utilisation intensive des outils,
• l'interaction avec des interfaces graphiques,
• des problèmes difficiles à reproduire,
• le raisonnement mathématique,
• un débogage prolongé,
• un coût élevé de l'erreur,
• la perte de contexte,
• la nécessité de maintenir une stratégie sur une longue période.

Dans les tâches quotidiennes et simples, la différence peut être beaucoup plus faible.

Par conséquent, une bonne règle est :

Ne demandez pas quel modèle est « meilleur ». Demandez quel modèle est le moins cher pour accomplir correctement cette tâche.

1.2. OSWorld, Mind2Web et la question de la vitesse

Les benchmarks comme OSWorld et Mind2Web sont utiles pour comprendre les différences entre les modèles, mais ils doivent être interprétés correctement.

Dans les simulations de latence OSWorld 2.0 mentionnées dans la documentation officielle, Astra a atteint une utilisation du processeur plus élevée que Sol et a montré environ 47 % de temps en moins par tâche dans la comparaison indiquée.

Par exemple :

• Astra : environ 40 minutes.
• Sol : environ 75 minutes.

Le score indiqué était d'environ :

• Astra : 72,6 %
• Sol : 65,7 %

De même, la documentation indique qu'Astra + le nouveau harnais Codex peut être environ 1,9× plus rapide que l'expérience Sol actuelle dans certains tests Mind2Web.

Mais rappelez-vous deux choses

1. C'est un benchmark.

Un résultat 1,9× sur Mind2Web ne signifie pas que chaque tâche interne d'une entreprise sera 1,9× plus rapide.

2. Il fournit néanmoins un signal utile.

Plus une tâche dépend de :

• écrans,
• outils,
• navigation,
• actions multiples,
• décisions intermédiaires,

plus il est logique d'évaluer une combinaison de modèle + système d'agent, plutôt que de simplement comparer les tokens par seconde.

1.3. Quand Sol est-elle suffisante ?

Utilisez d'abord Sol, Terra ou Luna lorsque :

• la réponse peut être complétée en un seul échange ;
• vous avez seulement besoin de modifier un ou deux fichiers ;
• les tests sont courts ;
• la tâche est principalement de la lecture ;
• aucune interface graphique n'est requise ;
• aucun outil complexe n'est nécessaire ;
• le coût de la répétition du travail est faible ;
• un échec n'entraîne pas de conséquences majeures.

Astra commence à avoir du sens lorsque l'inverse se produit

Par exemple :

• beaucoup de fichiers ;
• plusieurs modules ;
• de longues chaînes d'outils ;
• l'utilisation de l'ordinateur ;
• un débogage complexe ;
• une vérification mathématique ;
• des tâches où un échec implique beaucoup de reprise ;
• la perte de contexte lors d'une session longue.

2. Configuration de ChatGPT, de l'API et de Codex

2.1. ChatGPT : sélectionner Astra

Lorsqu'Astra sera disponible :

1. Ouvrez ChatGPT sur le Web ou le Bureau.
2. Vérifiez le sélecteur de modèle.
3. Sélectionnez Astra / GPT-6 Astra.
4. Si vous utilisez Codex, vérifiez que le même modèle y est disponible.
5. Si Astra n'apparaît pas : vérifiez la formule ; vérifiez les autorisations d'entreprise ; vérifiez le déploiement ; utilisez Sol comme configuration temporaire.

Les formules Pro, Business et Enterprise peuvent inclure des variantes spécifiques d'Astra. Vous ne devez pas tirer de conclusions uniquement du nom affiché dans l'interface : examinez toujours la description correspondant à la formule.

2.2. API : model = "gpt-6-astra"

La configuration de base consiste à spécifier le modèle dans l'API Responses.

Considérations importantes

• Pour les appels d'outils, utilisez de préférence l'API Responses.
• Astra ne prend pas en charge reasoning.effort = "none".
• Si vous utilisez un faible niveau de raisonnement, commencez par une petite configuration et n'augmentez que lorsque cela est nécessaire.
• Certains paramètres traditionnels, comme temperature ou top_p, peuvent ne pas être disponibles.
• La résidence des données dans l'UE peut imposer des restrictions sur Fast/Priority.
• La configuration du cache peut être migrée vers prompt_cache_options.ttl.

2.3. Codex : gestion expérimentale du contexte

Pour les sessions longues, Codex peut utiliser des mécanismes de gestion de contexte qui vont au-delà de la simple compression de l'historique.

L'idée est de conserver des informations importantes telles que :

• les hypothèses étudiées ;
• les hypothèses rejetées ;
• les fichiers inspectés ;
• les tests exécutés ;
• les résultats obtenus ;
• les décisions prises.

Une configuration conceptuelle peut être :

La configuration expérimentale de la gestion du contexte doit être traitée comme telle et vérifiée par rapport à la version actuelle de Codex avant d'être adoptée comme standard d'équipe.

Pourquoi est-ce important ?

Dans une session de débogage de plusieurs heures, la perte de contexte peut forcer l'agent à ré-investiguer :

• quelles hypothèses ont déjà été rejetées ;
• quels fichiers ont déjà été examinés ;
• quelles commandes ont déjà fonctionné ;
• quels tests ont déjà été exécutés.

La prise de notes réduit cette répétition.

Important :

ne stockez jamais d'informations confidentielles, de secrets, de clés API ou de données sensibles dans les notes persistantes de l'agent.

2.4. Approbations et bac à sable

L'objectif de l'automatisation ne devrait pas être :

« Que l'agent puisse faire absolument tout. »

L'objectif devrait être :

Automatisez tout ce qui est réversible et maintenez l'intervention humaine uniquement aux points irréversibles ou à haut risque.

Configuration interactive recommandée comme point de départ :

L'agent peut s'occuper de :

• lire les fichiers ;
• exécuter les tests ;
• analyser les journaux ;
• apporter des modifications locales ;
• créer des commits ;
• préparer une Pull Request ;
• revoir son propre travail ;
• corriger les erreurs.

L'humain doit garder le contrôle sur :

• la production ;
• les déploiements ;
• la fusion finale ;
• la publication ;
• l'envoi d'informations externes ;
• la modification des autorisations ;
• les opérations irréversibles ;
• les informations confidentielles.

L'approbation doit devenir le dernier point de contrôle, pas une interruption constante tout au long du processus.

2.5. AGENTS.md et Skills

Avant de commencer un travail important avec Codex, l'agent doit connaître les règles du projet.

Une architecture utile est :

AGENTS.md

Contient :

• les règles permanentes ;
• le périmètre autorisé ;
• les restrictions ;
• les conditions d'achèvement ;
• les tests obligatoires ;
• les points d'approbation humaine.

Skills

Contiennent :

• les procédures répétitives ;
• les workflows ;
• les listes de contrôle opérationnelles ;
• les processus spécialisés.

MCP

Utilisé pour :

• les connexions externes ;
• les services ;
• les outils ;
• les sources de données.

Une division simple serait :

AGENTS.md = règles

Skills = procédures

MCP = connexions

Exemple minimal d'AGENTS.md

3. Comment rédiger des instructions qui tirent parti d'Astra

La qualité des instructions a un impact énorme sur les agents de longue durée.

Astra peut être très sensible à :

• les ambiguïtés ;
• les contradictions ;
• les instructions obsolètes ;
• les Skills incohérents ;
• les règles en double.

Par conséquent, une bonne configuration peut améliorer les performances autant que le changement de modèle.

3.1. Augmenter l'autonomie

Au lieu de créer des instructions qui obligent l'agent à demander constamment une confirmation, définissez clairement l'espace dans lequel il peut agir de manière autonome.

3.2. Approbation après des résultats vérifiables

L'une des meilleures règles pour les agents autonomes est :

Produisez d'abord un résultat vérifiable ; demandez ensuite l'approbation pour l'étape irréversible.

Cela évite le schéma :

agent → question → humain → agent → question → humain

et le remplace par :

agent → investigate → implémente → teste → prépare le résultat → humain approuve → action finale

3.3. Questions qui ne bloquent pas la tâche principale

Dans les sessions longues, il peut être utile d'autoriser des questions indépendantes sans arrêter le flux principal.

Une bonne règle est :

La tâche principale a une condition d'achèvement fixe en une phrase. Si une question indépendante apparaît pendant l'exécution, répondez-y brièvement sans interrompre la tâche principale. N'arrêtez le workflow principal que lorsque la question change la direction de la tâche, le périmètre, les autorisations ou le résultat attendu.

L'API peut également utiliser des mécanismes pour envoyer des instructions supplémentaires pendant une exécution et des outils asynchrones pour un travail prolongé.

3.4. Délégation aux sous-agents

Lorsqu'une tâche peut être parallélisée, faites-le explicitement.

Si la parallélisation est susceptible de réduire le temps d'exécution ou d'améliorer la qualité, déléguez les sous-tâches indépendantes à d'autres agents. Privilégiez le travail en parallèle pour les investigations indépendantes, les modifications au niveau des modules, la vérification des tests, les vérifications de la documentation et la revue de code. Gardez les messages entre agents concis, explicites et lisibles.

Exemples de parallélisation :

• Agent A → investigate le module d'authentification.
• Agent B → analyse les tests.
• Agent C → révise les types.
• Agent D → révise la documentation.

Ensuite, l'agent principal intègre les résultats.

3.5. Contrôler le volume des tests

Plus de tests ne signifient pas toujours un meilleur résultat.

Pour les petites modifications :

L'objectif est d'empêcher qu'une modification triviale ne déclenche une énorme batterie de tests inutiles.

3.6. Modèle pour un débogage prolongé

3.7. Modèle pour les tâches informatiques et de navigation

4. Maximiser la valeur, pas le nombre de tokens

La bonne question n'est pas :

« Comment puis-je dépenser tous les tokens d'Astra ? »

La bonne question est :

« Comment puis-je obtenir plus de travail accompli pour chaque dollar dépensé ? »

Selon les tarifs indiqués :

Astra est clairement plus chère par token.

Mais le prix par token ne représente pas nécessairement le coût réel de l'accomplissement d'une tâche.

Si Astra permet :

• moins d'erreurs ;
• moins d'itérations ;
• moins de reprises ;
• moins d'appels d'outils ;
• un temps total plus faible ;
• un taux de réussite plus élevé ;

alors le coût par tâche accomplie peut être compétitif, voire inférieur.

4.1. Table de routage pratique

La règle générale :

Luna/Terra pour le volume → Sol pour le travail standard → Astra pour les tâches qui justifient vraiment leur coût.

4.2. Habitudes qui réduisent les coûts

1. Écrivez d'abord la condition d'achèvement

Cela réduit l'exploration inutile.

1. Évitez les monologues intermédiaires

Privilégiez :

État → Action suivante → Résultat

au lieu d'explications interminables.

1. Envoyez les vérifications simples aux modèles économiques

Ne gaspillez pas Astra pour :

• vérifier le format ;
• résumer de petits journaux ;
• classer des fichiers ;
• effectuer des tâches répétitives.

1. Stabilisez le préfixe d'instruction

Maintenir des instructions système/développeur cohérentes peut favoriser une utilisation efficace du cache.

1. Utilisez les modes rapides uniquement lorsqu'ils ajoutent de la valeur

Si un mode coûte plus cher, il doit être justifié par une réelle réduction du temps d'exécution.

4.3. Audit hebdomadaire des coûts

Chaque semaine, examinez :

• les tâches exécutées avec Astra ;
• la raison pour laquelle elle a été utilisée ;
• le résultat ;
• le coût approximatif ;
• si Sol aurait suffi ;
• si Terra aurait suffi ;
• le nombre d'itérations ;
• les échecs ;
• les reprises.

Règle simple

Si vous ne pouvez pas expliquer par écrit :

« Astra était nécessaire parce que... »

envisagez de déplacer cette catégorie de tâches vers un modèle inférieur.

5. Workflow recommandé

5.1. Débogage long

Étape 1 — Classification

S'il y a plusieurs fichiers, une reproduction complexe ou de nombreux outils :

Astra.

Si c'est simple :

Sol/Terra.

Étape 2 — Limites

Définissez dans AGENTS.md :

• fichiers autorisés ;
• fichiers interdits ;
• commandes autorisées ;
• tests obligatoires ;
• points d'approbation.

Étape 3 — Configuration

model = "gpt-6-astra" approval_policy = "on-request" sandbox_mode = "workspace-write" [features.context_management] experimental_mode = true

Étape 4 — Démarrage

Commencez toujours par une condition d'achèvement claire.

Étape 5 — Journalisation

Conservez :

• les hypothèses ;
• les tests ;
• les résultats ;
• les fichiers examinés ;
• les décisions.

Étape 6 — Interruptions

Les questions indépendantes ne doivent pas détruire le contexte de la tâche principale.

Étape 7 — Livrable

L'agent peut aller jusqu'à :

Pull Request prête pour la revue.

La fusion finale reste sous contrôle humain.

Étape 8 — Apprentissage

Si le même problème apparaît de manière répétée :

transformez-le en

Skill

.

5.2. Refonte à grande échelle

Une stratégie en deux étapes fonctionne bien :

Étape 1 — Investigation économique

Utilisez :

Luna → Terra → Sol

pour construire :

• la carte des dépendances ;
• l'impact ;
• les modules affectés ;
• les risques ;
• le plan d'exécution.

Étape 2 — Implémentation

Utilisez :

Astra

pour les modules qui nécessitent réellement une capacité supérieure.

Étape 3 — Parallélisation

Sous-agents pour :

• les tests ;
• la vérification de type ;
• la revue ;
• les modules indépendants.

Étape 4 — Revue humaine

L'humain se concentre sur :

• l'architecture ;
• les API publiques ;
• la compatibilité ;
• les décisions irréversibles.

5.3. Utilisation de l'ordinateur

Pour les tâches de navigation ou d'interface graphique :

1. Définissez clairement l'écran cible.
2. Définissez les opérations interdites.
3. Utilisez Astra lorsque la tâche est longue ou visuellement complexe.
4. Utilisez le dernier harnais Codex lorsque applicable.
5. Journalisez les états et les procédures.
6. Transformez le résultat en un livrable vérifiable.

Le chiffre 1,9× dans Mind2Web doit être interprété uniquement comme un benchmark, pas comme une garantie de performance interne.

5.4. Agent basé sur l'API

Configuration conceptuelle :

Model : gpt-6-astra API : Responses Reasoning : low → high si nécessaire Tools : activés Long-running tools : asynchrones si approprié Human gate : action irréversible finale

Pour les outils de longue durée :

Utilisez l'exécution asynchrone des outils lorsque la durée d'exécution de l'outil est suffisamment longue pour que l'exécution synchrone bloquante réduise le débit.

Si le niveau de difficulté change pendant l'exécution :

Augmentez l'effort de raisonnement uniquement lorsque la tâche devient réellement difficile. Revenez à un niveau de raisonnement inférieur pour l'exécution de routine lorsque cela est approprié.

L'idée est de réserver les ressources les plus coûteuses pour les moments qui en ont vraiment besoin.

6. À faire et à ne pas faire

À faire

• Réservez Astra pour les tâches où elle fait une réelle différence.
• Examinez les incohérences entre AGENTS.md et les Skills.
• Gardez les approbations comme dernier point de contrôle.
• Générez des résultats vérifiables avant de demander une autorisation.
• Activez la gestion du contexte pour les tâches longues lorsque applicable.
• Journalisez les hypothèses, les tests et les résultats.
• Traitez les benchmarks comme des indications, pas comme un KPI interne.
• Mesurez le taux de réussite et le temps par tâche.
• Vérifiez dès le début si une tâche nécessite Daybreak.
• Gardez les informations confidentielles hors des notes persistantes.

À ne pas faire

• N'utilisez pas Astra pour chaque petite question.
• N'interprétez pas les phrases promotionnelles comme des spécifications techniques.
• Ne traitez pas les expériences individuelles sur X ou Reddit comme une documentation officielle.
• Ne déclarez pas un déploiement d'entreprise avant que l'administrateur ne l'active.
• Ne donnez pas un accès automatique aux opérations irréversibles.
• Ne stockez pas de secrets ou d'informations confidentielles dans les fichiers de contexte.
• N'exécutez pas d'énormes batteries de tests pour des modifications triviales.
• N'utilisez pas de benchmarks externes comme substitut aux métriques internes.

7. Plan de mise en œuvre en 60 minutes

0–5 minutes

Vérifiez si gpt-6-astra est disponible :

• sélecteur de modèle ;
• API ;
• Codex.

S'il s'agit d'Enterprise, vérifiez les autorisations de l'administrateur.

5–15 minutes

Vérifiez :

model = "gpt-6-astra" approval_policy = "on-request" sandbox_mode = "workspace-write"

Et, pour les expériences de contexte :

[features.context_management] experimental_mode = true

Redémarrez Codex si nécessaire.

15–25 minutes

Mettez à jour AGENTS.md :

• périmètre ;
• restrictions ;
• tests ;
• conditions d'achèvement ;
• points d'approbation.

25–35 minutes

Créez une table de routage :

Luna → Terra → Sol → Astra

35–55 minutes

Exécutez une tâche de débogage réelle de portée limitée avec Astra.

Utilisez une condition d'achèvement explicite.

55–60 minutes

Journalisez :

• Astra était-elle vraiment nécessaire ?
• Sol aurait-elle suffi ?
• Quelle quantité de reprise a-t-elle évitée ?
• Quelle configuration a fonctionné ?
• Qu'est-ce qui devrait devenir un Skill ?

C'est suffisant.

Vous n'avez pas besoin de tester toutes les fonctionnalités disponibles.

Distribution + limites + sessions longues = la base pour tirer parti d'Astra.

8. Modèles pratiques récurrents

1. Fusée à deux étages

Modèle économique → Astra

D'abord :

• investigation ;
• définition du périmètre ;
• analyse.

Ensuite :

• implémentation complexe ;
• intégration ;
• vérification.

2. Condition d'achèvement dès le départ

Pour les agents longs, écrivez dans la première partie de l'instruction :

« La tâche sera terminée quand... »

Cela évite une exploration sans but.

3. Contexte et prise de notes

Pour les travaux longs, conservez :

• les hypothèses ;
• les résultats ;
• les décisions ;
• les tests ;
• les fichiers importants.

Ne vous fiez pas exclusivement à la mémoire compressée de l'agent.

4. L'approbation doit être la dernière étape

N'interrompez pas constamment.

Mieux vaut :

Investiguer → implémenter → tester → préparer le résultat → revoir → approuver → exécuter l'action irréversible

5. Les benchmarks comme guide

Mind2Web et OSWorld peuvent vous aider à décider quoi tester.

Mais les vrais KPI doivent être internes :

• taux de réussite ;
• temps d'exécution ;
• coût par tâche ;
• nombre d'itérations ;
• reprise ;
• intervention humaine.

9. Erreurs courantes

Avant de conclure :

« Astra est faible. »

vérifiez d'abord, dans cet ordre :

1. Visibilité

Le modèle est-il réellement disponible ?

1. Cadre

Codex est-il mis à jour et correctement configuré ?

1. Prompt

Les instructions sont-elles claires ?

1. AGENTS.md

Y a-t-il des règles contradictoires ?

1. Skills

Y a-t-il des procédures anciennes ou incohérentes ?

1. Routage

Utilisez-vous le bon modèle pour le travail ?

Souvent, le problème n'est pas la capacité du modèle.

C'est l'environnement dans lequel le modèle travaille.

10. Liste de contrôle de mise en œuvre pour les équipes

• Définissez qui utilisera Astra.
• Activez les autorisations administratives nécessaires.
• Établissez un responsable et une date limite.
• Créez une table de routage Luna/Terra/Sol/Astra.
• Créez un AGENTS.md minimal.
• Définissez approval_policy.
• Définissez sandbox_mode.
• Définissez les points d'intervention humaine.
• Documentez les opérations confidentielles.
• Établissez une revue hebdomadaire des coûts.
• Journalisez les tâches qui nécessitent réellement Astra.
• Convertissez les erreurs répétitives en Skills.

La priorité devrait être de réduire les erreurs et les reprises de l'équipe, pas simplement de maximiser la vitesse d'un agent individuel.

11. Arbre de décision : Sol vs. Astra

Utilisez cette séquence au début d'une tâche :

1. Peut-elle être complétée en un seul échange ?

Oui → Luna / Terra / Sol

Non → continuez.

1. Nécessite-t-elle une interface graphique, des outils ou de nombreuses étapes ?

Oui → Astra

Non → continuez.

1. Le coût de l'échec est-il élevé ?

Oui → Astra

Non → Sol/Terra

1. La difficulté de la tâche peut-elle changer pendant l'exécution ?

Oui → envisagez Astra + ajustement dynamique du raisonnement.

1. Astra est-elle toujours indisponible ?

Exécutez le même workflow avec Sol.

Quand Astra apparaît, changez uniquement le modèle et conservez la structure.

12. Migration de l'API vers Astra

L'ordre recommandé est :

1. Changez le modèle

model = "gpt-6-astra"

1. Utilisez l'API Responses

Surtout s'il y a des appels d'outils.

1. Révisez le raisonnement

Astra n'utilise pas :

reasoning.effort = "none"

Commencez avec un niveau bas lorsque cela est suffisant.

1. Supprimez les paramètres inutiles

Révisez les paramètres comme :

temperature top_p

si le modèle ou le point de terminaison ne les prend plus en charge.

1. Révisez le cache

Migrez vers :

prompt_cache_options.ttl

lorsque applicable.

1. Révisez la résidence des données

Si vous utilisez des exigences d'infrastructure ou de résidence dans l'UE, vérifiez les restrictions correspondantes.

1. Ajustez le raisonnement dynamiquement

Pendant une tâche difficile :

Augmentez l'effort de raisonnement lorsque la tâche devient réellement difficile.

Pendant les opérations de routine :

Revenez à un niveau de raisonnement inférieur lorsque le raisonnement supplémentaire n'est plus utile.

1. Outils longs

Envisagez l'exécution asynchrone lorsque le temps d'outil le justifie.

13. Configuration minimale de Codex

Une configuration initiale peut être :

model = "gpt-6-astra" model_reasoning_effort = "high" approval_policy = "on-request" sandbox_mode = "workspace-write" [features.context_management] experimental_mode = true

Et le dépôt doit contenir un AGENTS.md qui définit :

AGENTS.md

Objectif

• Limiter les modifications au strict nécessaire.
• La tâche n'est terminée que lorsque tous les tests requis sont validés.

Périmètre autorisé

• src/
• tests/

Points de validation

• Déploiement en production
• Transmission de données externes
• Modifications des autorisations
• Fusion finale

Comportement opérationnel

• Travailler de manière autonome dans le périmètre autorisé.
• Privilégier les actions réversibles.
• Produire des résultats vérifiables avant de demander une approbation.
• Ne pas poser de questions de confirmation inutiles.

Après avoir modifié la configuration :

1. redémarrer Codex ;
2. exécuter une petite tâche de lecture ;
3. vérifier que l'environnement fonctionne ;
4. démarrer la tâche principale.

14. Définir « l'utilisation maximale » en une seule phrase

Dans ce document, l'utilisation maximale ne signifie pas consommer le nombre maximum de tokens.

Cela signifie :

Concentrer Astra sur les tâches où elle peut vraiment faire la différence, exécuter tout le reste de manière économique, et construire une base solide d'instructions, de limites, d'approbations et de gestion du contexte qui permet d'achever les tâches longues sans interruptions inutiles.

Plusieurs décisions découlent de cette définition :

• Il vaut mieux mettre à jour la table de routage chaque semaine que de changer de modèle arbitrairement.
• Il vaut mieux effectuer un véritable test de débogage que d'essayer chaque nouvelle fonctionnalité.
• Il vaut mieux mesurer le succès et le temps par tâche que de courir après les benchmarks.
• Nous ne devons pas transformer des phrases promotionnelles en spécifications internes.
• Si Astra n'est pas disponible, Sol peut être utilisée comme substitut temporaire.

15. Les trois livrables fondamentaux

En fin de compte, l'ensemble de ce système doit produire trois éléments :

1. Table d'allocation dynamique

Définit quand utiliser :

Luna / Terra / Sol / Astra

2. AGENTS.md

Définit :

• les règles ;
• le périmètre ;
• les restrictions ;
• les tests ;
• les conditions d'achèvement ;
• les points de contrôle humains.

3. Prompt opérationnel long

Doit définir :

• le rôle ;
• l'objectif ;
• les conditions d'achèvement ;
• la procédure ;
• les limites ;
• les outils ;
• la validation ;
• le format de sortie.

Ces trois éléments sont plus importants que de mémoriser l'intégralité du catalogue de fonctionnalités.

16. Fiche de classification à copier

Utilisez cette fiche au début de chaque session importante :

La fiche n'a pas besoin d'être parfaite.

Son objectif est de créer une habitude de classification.

Si vous recommandez Astra alors que la tâche ne nécessite que des réponses courtes, vous surdimensionnez probablement le modèle.

Si Sol échoue de manière répétée en raison d'une perte de contexte ou de l'incapacité à terminer une longue chaîne d'actions, il est probablement temps de passer à Astra.

17. Comment vraiment réfléchir au prix

Les tarifs par million de tokens ne sont qu'une partie de l'équation.

Par exemple :

Astra

• Entrée : 10 $
• Sortie : 50 $

Sol

• Entrée : 4 $
• Sortie : 20 $

Astra coûte plus cher.

Mais imaginons :

Sol

5 $ de tokens + 4 tentatives + 2 échecs + retravail humain = coût réel élevé

Astra

12 $ de tokens + 1 tentative + résultat correct = coût total par tâche plus faible

Par conséquent, pour les tâches courtes :

Le prix par token compte énormément.

Pour les tâches longues :

Le coût par tâche terminée compte bien davantage.

La métrique finale devrait être :

Coût × taux de réussite × temps × intervention humaine

et pas seulement :

$/1M tokens

Conclusion

L'objectif d'Astra ne devrait pas être d'en faire le modèle par défaut pour tout.

L'objectif devrait être de construire un système où chaque modèle effectue le travail pour lequel il est le plus efficace.

Luna

Volume et tâches simples.

Terra

Équilibre entre coût et capacité.

Sol

Travail standard et programmation générale.

Astra

Tâches complexes, longues, agentiques, GUI, mathématiques, de débogage, et travaux où l'échec coûte cher.

Le modèle le plus puissant est :

Enquêter à moindre coût → planifier → exécuter avec Astra si nécessaire → vérifier → préparer un résultat vérifiable → intervention humaine uniquement au point de contrôle final.

La véritable optimisation ne consiste pas à utiliser Astra davantage.

Il s'agit de savoir exactement quand Astra en vaut la peine.

Et plus les agents sont complexes, plus l'infrastructure qui les entoure est importante : AGENTS.md, compétences, bac à sable, approbations, gestion du contexte.**