GPT-6 Astra: Manuale pratico per massimizzare Codex, agenti e costi

Obiettivo:

imparare a distribuire Luna, Terra, Sol e Astra in modo intelligente per massimizzare le prestazioni, ridurre i costi e mantenere i flussi di lavoro degli agenti in esecuzione per lunghi periodi.

Il GPT-6 Astra di OpenAI, annunciato il 3 settembre 2026, rappresenta un salto significativo nella capacità degli agenti di eseguire compiti informatici complessi che in precedenza richiedevano un considerevole intervento umano.

Ma la vera sfida non è più semplicemente chiedersi "Astra può svolgere questo compito?".

La domanda importante ora è:

Dove aggiunge veramente valore Astra, come dovremmo allocare le nostre risorse, come possiamo far lavorare gli agenti più a lungo e come possiamo ottenere tutto questo al minor costo possibile?

Questo articolo è principalmente rivolto a coloro che utilizzano Codex e agenti di programmazione su base regolare, specialmente in ambienti quasi di produzione.

Pubblico di destinazione

Questo manuale è progettato per persone che:

• Utilizzano agenti tramite Codex o l'API OpenAI in ambienti quasi di produzione.
• Vogliono alternare tra Luna, Terra, Sol e Astra per ridurre i costi mensili dell'API o dell'infrastruttura.
• Vogliono costruire flussi di lavoro a lunga esecuzione per: debug esaustivo, refactoring di grandi dimensioni, utilizzo di strumenti informatici, verifica matematica, test automatizzati e attività che richiedono il mantenimento del contesto per molto tempo.

0. Prerequisiti

Distribuzione, Enterprise, Daybreak e Disponibilità

Prima di tentare di ottimizzare Astra, devi prima verificare che il modello sia effettivamente disponibile per il tuo account e ambiente.

Data dell'annuncio

3 settembre 2026 — annuncio ufficiale

OpenAI — GPT-6 Astra

Distribuzione

Secondo gli annunci ufficiali, Trusted Access/Daybreak sarà uno dei primi canali di distribuzione.

I piani Plus, Pro, Business ed Enterprise, così come l'API e AWS, verranno distribuiti successivamente.

Negli ambienti aziendali, l'amministratore potrebbe dover abilitare esplicitamente l'accesso.

Punti importanti

• Enterprise: l'amministratore deve abilitarlo quando applicabile.
• Livello gratuito: Astra non è previsto come modello gratuito.
• Crediti: gli utenti dei piani a pagamento potrebbero avere opzioni di credito aggiuntive a seconda del prodotto.
• Cybersecurity: alcune funzionalità avanzate potrebbero essere subordinate a percorsi di accesso specifici come Daybreak.
• ID modello API: gpt-6-astra.

Prezzo API Standard

Secondo le tariffe indicate in questo documento:

• Input: $10 / milione di token.
• Output: $50 / milione di token.

Esistono tariffe e condizioni diverse per alcune modalità, contesti lunghi, caching ed elaborazione prioritaria.

Regola fondamentale:

il fatto che Astra non appaia nell'interfaccia non significa necessariamente che il modello non esista per la tua organizzazione. Prima verifica la disponibilità, le autorizzazioni e la distribuzione.

Durante la verifica dell'accesso, la strategia può essere costruita utilizzando Sol come modello base.

1. Dove eccelle Astra e dove è sufficiente Sol?

Astra è progettato come un modello di fascia alta per attività professionali, specialmente quelle relative a:

• uso del computer,
• navigazione,
• ingegneria del software,
• agenti,
• scienza,
• matematica,
• attività end-to-end complesse.

La documentazione ufficiale posiziona i modelli di fascia alta per i lavori end-to-end più difficili.

La strategia corretta, tuttavia, non è usare Astra per assolutamente tutto.

La strategia corretta è:

Usa Astra solo quando la sua maggiore capacità ha un impatto reale sul risultato.

1.1. Dove appare realmente la differenza?

Le differenze più importanti tendono ad apparire in attività in cui diversi fattori si combinano:

• più file o moduli,
• molti passaggi consecutivi,
• uso intensivo di strumenti,
• interazione con interfacce grafiche,
• problemi difficili da riprodurre,
• ragionamento matematico,
• debug prolungato,
• alto costo di un errore,
• perdita di contesto,
• necessità di mantenere una strategia per molto tempo.

Nelle attività quotidiane e semplici, la differenza può essere molto più piccola.

Pertanto, una buona regola è:

Non chiederti quale modello è "migliore". Chiediti quale modello è più economico per completare correttamente questo compito.

1.2. OSWorld, Mind2Web e la questione della velocità

Benchmark come OSWorld e Mind2Web sono utili per comprendere le differenze tra i modelli, ma devono essere interpretati correttamente.

Nelle simulazioni di latenza OSWorld 2.0 menzionate nella documentazione ufficiale, Astra ha raggiunto un utilizzo del processore più elevato rispetto a Sol e ha mostrato circa il 47% in meno di tempo per attività nel confronto indicato.

Ad esempio:

• Astra: circa 40 minuti.
• Sol: circa 75 minuti.

Il punteggio indicato era approssimativamente:

• Astra: 72.6%
• Sol: 65.7%

Allo stesso modo, la documentazione indica che Astra + il nuovo harness Codex può essere circa 1.9× più veloce dell'attuale esperienza Sol in alcuni test Mind2Web.

Ma ricorda due cose

1. È un benchmark.

Un risultato di 1.9× su Mind2Web non significa che ogni attività interna in un'azienda sarà 1.9× più veloce.

2. Fornisce comunque un segnale utile.

Più un'attività dipende da:

• schermate,
• strumenti,
• navigazione,
• azioni multiple,
• decisioni intermedie,

più ha senso valutare una combinazione di modello + sistema agente, piuttosto che confrontare solo i token al secondo.

1.3. Quando è sufficiente Sol?

Usa Sol, Terra o Luna prima quando:

• la risposta può essere completata in un unico scambio;
• devi solo modificare uno o due file;
• i test sono brevi;
• l'attività è principalmente di lettura;
• non è richiesta GUI;
• non sono necessari strumenti complessi;
• il costo per ripetere il lavoro è basso;
• un fallimento non genera conseguenze maggiori.

Astra inizia ad avere senso quando si verifica il contrario

Per esempio:

• molti file;
• moduli multipli;
• lunghe catene di strumenti;
• uso del computer;
• debug complesso;
• verifica matematica;
• attività in cui un fallimento implica molto rielaborazione;
• perdita di contesto durante una sessione lunga.

2. ChatGPT, API e Configurazione Codex

2.1. ChatGPT: seleziona Astra

Quando Astra diventa disponibile:

1. Apri ChatGPT sul Web o Desktop.
2. Controlla il selettore del modello.
3. Seleziona Astra / GPT-6 Astra.
4. Se usi Codex, verifica che lo stesso modello sia disponibile lì.
5. Se Astra non appare: controlla il piano; verifica le autorizzazioni aziendali; verifica la distribuzione; usa Sol come configurazione temporanea.

I piani Pro, Business ed Enterprise possono includere varianti specifiche di Astra. Non dovresti trarre conclusioni solo dal nome visualizzato nell'interfaccia: rivedi sempre la descrizione corrispondente al piano.

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

La configurazione di base consiste nello specificare il modello nell'API Responses.

Considerazioni importanti

• Per le chiamate agli strumenti, usa preferibilmente API Responses.
• Astra non supporta reasoning.effort = "none".
• Se usi un basso livello di ragionamento, inizia con una configurazione piccola e aumenta solo quando necessario.
• Alcuni parametri tradizionali, come temperature o top_p, potrebbero non essere disponibili.
• La residenza dei dati nell'UE potrebbe imporre restrizioni su Fast/Priority.
• La configurazione della cache può essere migrata a prompt_cache_options.ttl.

2.3. Codex: gestione sperimentale del contesto

Per sessioni lunghe, Codex può utilizzare meccanismi di gestione del contesto che vanno oltre la semplice compressione della cronologia.

L'idea è conservare informazioni importanti come:

• ipotesi investigate;
• ipotesi scartate;
• file ispezionati;
• test eseguiti;
• risultati ottenuti;
• decisioni prese.

Una configurazione concettuale può essere:

La configurazione sperimentale di gestione del contesto dovrebbe essere trattata come tale e verificata rispetto alla versione corrente di Codex prima di essere adottata come standard di squadra.

Perché è importante?

In una sessione di debug che dura diverse ore, perdere il contesto può costringere l'agente a re-investigare:

• quali ipotesi erano già state scartate;
• quali file erano già stati rivisti;
• quali comandi avevano già funzionato;
• quali test erano già stati eseguiti.

Prendere appunti riduce quella ripetizione.

Importante:

non memorizzare mai informazioni riservate, segreti, chiavi API o dati sensibili nelle note persistenti dell'agente.

2.4. Approvazioni e sandbox

L'obiettivo dell'automazione non dovrebbe essere:

"Che l'agente possa fare assolutamente tutto."

L'obiettivo dovrebbe essere:

Automatizzare tutto ciò che è reversibile e mantenere l'intervento umano solo nei punti irreversibili o ad alto rischio.

Configurazione interattiva consigliata come punto di partenza:

L'agente può occuparsi di:

• leggere file;
• eseguire test;
• analizzare log;
• apportare modifiche locali;
• creare commit;
• preparare una Pull Request;
• rivedere il proprio lavoro;
• correggere errori.

L'umano deve mantenere il controllo su:

• produzione;
• distribuzioni;
• merge finale;
• pubblicazione;
• invio di informazioni esterne;
• modifica delle autorizzazioni;
• operazioni irreversibili;
• informazioni riservate.

L'approvazione dovrebbe diventare l'ultimo checkpoint, non un'interruzione costante durante tutto il processo.

2.5. AGENTS.md e Skills

Prima di iniziare un lavoro importante con Codex, l'agente deve conoscere le regole del progetto.

Un'architettura utile è:

AGENTS.md

Contiene:

• regole permanenti;
• ambito consentito;
• restrizioni;
• condizioni di completamento;
• test obbligatori;
• punti di approvazione umana.

Skills

Contengono:

• procedure ripetitive;
• flussi di lavoro;
• checklist operative;
• processi specializzati.

MCP

Utilizzato per:

• connessioni esterne;
• servizi;
• strumenti;
• fonti di dati.

Una semplice divisione sarebbe:

AGENTS.md = regole

Skills = procedure

MCP = connessioni

Esempio minimo di AGENTS.md

3. Come scrivere istruzioni che sfruttano Astra

La qualità delle istruzioni ha un enorme impatto sugli agenti a lunga esecuzione.

Astra può essere molto sensibile a:

• ambiguità;
• contraddizioni;
• istruzioni obsolete;
• Skills incoerenti;
• regole duplicate.

Pertanto, una buona configurazione può migliorare le prestazioni tanto quanto cambiare modello.

3.1. Aumentare l'autonomia

Invece di creare istruzioni che facciano chiedere costantemente conferma all'agente, definisci chiaramente lo spazio entro cui può agire autonomamente.

3.2. Approvazione dopo risultati verificabili

Una delle migliori regole per gli agenti autonomi è:

Prima produci un risultato verificabile; poi chiedi l'approvazione per il passo irreversibile.

Questo evita lo schema:

agente → domanda → umano → agente → domanda → umano

e lo sostituisce con:

agente → indaga → implementa → testa → prepara risultato → umano approva → azione finale

3.3. Domande che non bloccano il compito principale

Nelle sessioni lunghe può essere utile consentire domande indipendenti senza fermare il flusso principale.

Una buona regola è:

Il compito principale ha una condizione di completamento fissa di una frase. Se durante l'esecuzione appare una domanda indipendente, rispondi brevemente senza interrompere il compito principale. Ferma il flusso di lavoro principale solo quando la domanda cambia la direzione, l'ambito, le autorizzazioni o l'output richiesto del compito.

L'API può anche utilizzare meccanismi per inviare istruzioni aggiuntive durante un'esecuzione e strumenti asincroni per lavori prolungati.

3.4. Delega a subagenti

Quando un'attività può essere parallelizzata, fallo esplicitamente.

Se è probabile che la parallelizzazione riduca il tempo di esecuzione o migliori la qualità, delega i sotto-compiti indipendenti ad altri agenti. Preferisci il lavoro parallelo per indagini indipendenti, modifiche a livello di modulo, verifica dei test, controlli della documentazione e revisione del codice. Mantieni i messaggi tra agenti concisi, espliciti e leggibili.

Esempi di parallelizzazione:

• Agente A → indaga il modulo di autenticazione.
• Agente B → analizza i test.
• Agente C → rivede i tipi.
• Agente D → rivede la documentazione.

Poi, l'agente principale integra i risultati.

3.5. Controllare il volume dei test

Più test non sempre significano un risultato migliore.

Per piccole modifiche:

L'obiettivo è impedire che una modifica banale inneschi un'enorme batteria di test inutili.

3.6. Modello per debug prolungato

3.7. Modello per attività informatiche e browser

4. Massimizzare il valore, non il conteggio dei token

La domanda giusta non è:

"Come posso spendere tutti i token di Astra?"

La domanda giusta è:

"Come posso ottenere più lavoro completato per ogni dollaro speso?"

Secondo le tariffe indicate:

Astra è chiaramente più costoso per token.

Ma il prezzo per token non rappresenta necessariamente il costo effettivo del completamento di un'attività.

Se Astra raggiunge:

• meno errori;
• meno iterazioni;
• meno rielaborazione;
• meno chiamate agli strumenti;
• tempo totale inferiore;
• tasso di successo più elevato;

allora il costo per attività completata può essere competitivo o addirittura inferiore.

4.1. Tabella di routing pratica

La regola generale:

Luna/Terra per il volume → Sol per il lavoro standard → Astra per i lavori che giustificano veramente il loro costo.

4.2. Abitudini che riducono i costi

1. Scrivi prima la condizione di completamento

Questo riduce l'esplorazione non necessaria.

1. Evita monologhi intermedi

Dai priorità a:

Stato → Azione successiva → Risultato

invece di spiegazioni infinite.

1. Invia verifiche semplici a modelli economici

Non sprecare Astra per:

• controllare il formato;
• riassumere piccoli log;
• classificare file;
• eseguire attività ripetitive.

1. Stabilizza il prefisso delle istruzioni

Mantenere coerenti le istruzioni di sistema/sviluppatore può favorire un uso efficiente della cache.

1. Usa le modalità veloci solo quando aggiungono valore

Se una modalità costa di più, deve essere giustificata da una reale riduzione del tempo di esecuzione.

4.3. Audit settimanale dei costi

Ogni settimana rivedi:

• attività eseguite con Astra;
• motivo per cui è stato utilizzato;
• risultato;
• costo approssimativo;
• se Sol sarebbe stato sufficiente;
• se Terra sarebbe stato sufficiente;
• numero di iterazioni;
• fallimenti;
• rielaborazione.

Regola semplice

Se non puoi spiegare per iscritto:

"Astra era necessario perché..."

considera di spostare quella categoria di attività su un modello inferiore.

5. Flusso di lavoro consigliato

5.1. Debug prolungato

Passo 1 — Classificazione

Se ci sono più file, riproduzione complessa o molti strumenti:

Astra.

Se è semplice:

Sol/Terra.

Passo 2 — Limiti

Definisci in AGENTS.md:

• file consentiti;
• file proibiti;
• comandi consentiti;
• test obbligatori;
• punti di approvazione.

Passo 3 — Configurazione

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

Passo 4 — Inizio

Inizia sempre con una chiara condizione di completamento.

Passo 5 — Registro

Conserva:

• ipotesi;
• test;
• risultati;
• file esaminati;
• decisioni.

Passo 6 — Interruzioni

Le domande indipendenti non devono distruggere il contesto del compito principale.

Passo 7 — Risultato finale

L'agente può arrivare fino a:

Pull Request pronta per la revisione.

Il merge finale rimane sotto controllo umano.

Passo 8 — Apprendimento

Se lo stesso problema si ripresenta:

trasformalo in una

Skill

.

5.2. Refactoring su larga scala

Una strategia in due fasi funziona bene:

Fase 1 — Indagine economica

Usa:

Luna → Terra → Sol

per costruire:

• mappa delle dipendenze;
• impatto;
• moduli interessati;
• rischi;
• piano di esecuzione.

Fase 2 — Implementazione

Usa:

Astra

per i moduli che richiedono veramente una capacità superiore.

Fase 3 — Parallelizzazione

Subagenti per:

• test;
• controllo dei tipi;
• revisione;
• moduli indipendenti.

Fase 4 — Revisione umana

L'umano si concentra su:

• architettura;
• API pubbliche;
• compatibilità;
• decisioni irreversibili.

5.3. Uso del computer

Per attività browser o GUI:

1. Definisci chiaramente la schermata di destinazione.
2. Definisci le operazioni proibite.
3. Usa Astra quando l'attività è lunga o visivamente complessa.
4. Usa l'ultimo harness Codex quando applicabile.
5. Registra stati e procedure.
6. Trasforma il risultato in un prodotto verificabile.

La cifra di 1.9× in Mind2Web dovrebbe essere interpretata solo come un benchmark, non come una garanzia di prestazioni interne.

5.4. Agente basato su API

Configurazione concettuale:

Model: gpt-6-astra API: Responses Reasoning: basso → alto quando richiesto Tools: abilitati Long-running tools: asincroni quando appropriato Human gate: azione finale irreversibile

Per strumenti a lunga esecuzione:

Usa l'esecuzione asincrona degli strumenti quando il tempo di esecuzione dello strumento è sufficientemente lungo che l'esecuzione sincrona bloccante ridurrebbe la produttività.

Se il livello di difficoltà cambia durante l'esecuzione:

Aumenta lo sforzo di ragionamento solo quando il compito diventa genuinamente difficile. Torna a un livello di ragionamento inferiore per l'esecuzione di routine quando appropriato.

L'idea è riservare le risorse più costose per i momenti che ne hanno veramente bisogno.

6. Cosa fare e cosa non fare

Cosa fare

• Riserva Astra per attività in cui fa una reale differenza.
• Rivedi le incongruenze tra AGENTS.md e Skills.
• Mantieni le approvazioni come ultimo checkpoint.
• Genera risultati verificabili prima di richiedere l'autorizzazione.
• Attiva la gestione del contesto per attività lunghe quando applicabile.
• Registra ipotesi, test e risultati.
• Tratta i benchmark come guida, non come KPI interno.
• Misura il tasso di successo e il tempo per attività.
• Verifica dall'inizio se un'attività richiede Daybreak.
• Tieni le informazioni riservate fuori dalle note persistenti.

Cosa non fare

• Usare Astra per ogni piccola domanda.
• Interpretare frasi promozionali come specifiche tecniche.
• Trattare esperienze individuali su X o Reddit come documentazione ufficiale.
• Dichiarare la distribuzione aziendale prima che l'amministratore la abiliti.
• Dare accesso automatico a operazioni irreversibili.
• Memorizzare segreti o informazioni riservate nei file di contesto.
• Eseguire enormi batterie di test per modifiche banali.
• Usare benchmark esterni come sostituti delle metriche interne.

7. Piano di implementazione in 60 minuti

0–5 minuti

Verifica se gpt-6-astra è disponibile:

• selettore del modello;
• API;
• Codex.

Se è Enterprise, verifica le autorizzazioni dell'amministratore.

5–15 minuti

Controlla:

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

E, per esperimenti di contesto:

[features.context_management] experimental_mode = true

Riavvia Codex se necessario.

15–25 minuti

Aggiorna AGENTS.md:

• ambito;
• restrizioni;
• test;
• condizioni di completamento;
• punti di approvazione.

25–35 minuti

Crea una tabella di routing:

Luna → Terra → Sol → Astra

35–55 minuti

Esegui un'attività di debug reale di ambito limitato con Astra.

Usa una condizione di completamento esplicita.

55–60 minuti

Registra:

• Astra era veramente necessario?
• Sol sarebbe stato sufficiente?
• Quanta rielaborazione ha prevenuto?
• Quale configurazione ha funzionato?
• Cosa dovrebbe diventare una Skill?

Questo è sufficiente.

Non è necessario testare ogni funzionalità disponibile.

Distribuzione + limiti + sessioni lunghe = le basi per sfruttare Astra.

8. Schemi pratici ricorrenti

1. Razzo a due stadi

Modello economico → Astra

Prima:

• indagine;
• definizione dell'ambito;
• analisi.

Poi:

• implementazione complessa;
• integrazione;
• verifica.

2. Condizione di completamento dall'inizio

Negli agenti a lunga esecuzione, scrivi nella prima parte dell'istruzione:

"Il compito sarà terminato quando..."

Questo impedisce un'esplorazione senza scopo.

3. Contesto e presa di appunti

Per lavori lunghi, conserva:

• ipotesi;
• risultati;
• decisioni;
• test;
• file importanti.

Non fare affidamento esclusivamente sulla memoria compressa dell'agente.

4. L'approvazione deve essere l'ultimo passo

Non interrompere costantemente.

Meglio:

Indaga → implementa → testa → prepara risultato → rivedi → approva → esegui azione irreversibile

5. Benchmark come guida

Mind2Web e OSWorld possono aiutarti a decidere cosa testare.

Ma i veri KPI devono essere interni:

• tasso di successo;
• tempo di esecuzione;
• costo per attività;
• numero di iterazioni;
• rielaborazione;
• intervento umano.

9. Errori comuni

Prima di concludere:

"Astra è debole."

controlla prima, in questo ordine:

1. Visibilità

Il modello è effettivamente disponibile?

1. Framework

Codex è aggiornato e configurato correttamente?

1. Prompt

Le istruzioni sono chiare?

1. AGENTS.md

Ci sono regole contraddittorie?

1. Skills

Ci sono procedure vecchie o incoerenti?

1. Routing

Stai usando il modello giusto per il lavoro?

Spesso il problema non è la capacità del modello.

È l'ambiente in cui il modello sta lavorando.

10. Checklist di implementazione per i team

• Definisci chi userà Astra.
• Attiva le autorizzazioni amministrative necessarie.
• Stabilisci un proprietario e una scadenza.
• Crea una tabella di routing Luna/Terra/Sol/Astra.
• Crea un AGENTS.md minimo.
• Definisci approval_policy.
• Definisci sandbox_mode.
• Definisci i punti di intervento umano.
• Documenta le operazioni riservate.
• Stabilisci una revisione settimanale dei costi.
• Registra quali attività richiedono effettivamente Astra.
• Converti gli errori ripetitivi in Skills.

La priorità dovrebbe essere ridurre gli errori e la rielaborazione del team, non semplicemente massimizzare la velocità di un singolo agente.

11. Albero decisionale: Sol vs. Astra

Usa questa sequenza all'inizio di un'attività:

1. Può essere completata in un unico scambio?

Sì → Luna / Terra / Sol

No → continua.

1. Necessita di GUI, strumenti o molti passaggi?

Sì → Astra

No → continua.

1. Il costo del fallimento è alto?

Sì → Astra

No → Sol/Terra

1. L'attività può cambiare difficoltà durante l'esecuzione?

Sì → considera Astra + regolazione dinamica del ragionamento.

1. Astra è ancora non disponibile?

Esegui lo stesso flusso di lavoro con Sol.

Quando Astra appare, cambia solo il modello e mantieni la struttura.

12. Migrazione API ad Astra

L'ordine consigliato è:

1. Cambia il modello

model = "gpt-6-astra"

1. Usa API Responses

Specialmente se ci sono chiamate agli strumenti.

1. Rivedi il ragionamento

Astra non usa:

reasoning.effort = "none"

Inizia con un livello basso quando è sufficiente.

1. Rimuovi parametri non necessari

Rivedi parametri come:

temperature top_p

se il modello o l'endpoint non li supportano più.

1. Rivedi la cache

Migra a:

prompt_cache_options.ttl

quando applicabile.

1. Rivedi la residenza dei dati

Se usi requisiti di infrastruttura o residenza nell'UE, verifica le restrizioni corrispondenti.

1. Regola il ragionamento dinamicamente

Durante un compito difficile:

Aumenta lo sforzo di ragionamento quando il compito diventa genuinamente difficile.

Durante le operazioni di routine:

Torna a un livello di ragionamento inferiore quando un ragionamento aggiuntivo non è più utile.

1. Strumenti lunghi

Considera l'esecuzione asincrona quando il tempo dello strumento lo giustifica.

13. Configurazione minima di Codex

Una configurazione iniziale può essere:

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

E il repository dovrebbe contenere un AGENTS.md che definisce:

AGENTS.md

Obiettivo

• Mantenere le modifiche al minimo.
• Il completamento richiede che tutti i test necessari siano superati.

Ambito consentito

• src/
• tests/

Punti di approvazione

• Deploy in produzione
• Trasmissione di dati esterni
• Modifiche alle autorizzazioni
• Merge finale

Comportamento operativo

• Lavorare in autonomia nell'ambito consentito.
• Preferire azioni reversibili.
• Produrre risultati verificabili prima di richiedere approvazione.
• Non fare domande di conferma non necessarie.

Dopo aver modificato la configurazione:

1. riavviare Codex;
2. eseguire un piccolo compito di lettura;
3. verificare che l'ambiente funzioni;
4. avviare il compito principale.

14. Definisci "utilizzo massimo" in una singola frase

In questo documento, utilizzo massimo non significa consumare il numero massimo di token.

Significa:

Concentrare Astra sui compiti in cui può davvero fare la differenza, eseguire tutto il resto in modo economico e costruire una solida base di istruzioni, limiti, approvazioni e gestione del contesto che consenta di completare compiti lunghi senza interruzioni inutili.

Da questa definizione derivano diverse decisioni:

• È meglio aggiornare la tabella di routing settimanalmente piuttosto che cambiare modelli arbitrariamente.
• È meglio eseguire un vero test di debug piuttosto che provare ogni nuova funzionalità.
• È meglio misurare il successo e il tempo per compito piuttosto che inseguire benchmark.
• Non dobbiamo trasformare frasi promozionali in specifiche interne.
• Se Astra non è disponibile, Sol può essere utilizzato come sostituto temporaneo.

15. I Tre Risultati Fondamentali

Alla fine, questo intero sistema dovrebbe produrre tre elementi:

1. Tabella di allocazione dinamica

Definisce quando utilizzare:

Luna / Terra / Sol / Astra

2. AGENTS.md

Definisce:

• regole;
• ambito;
• restrizioni;
• test;
• condizioni di completamento;
• checkpoint umani.

3. Prompt operativo lungo

Deve definire:

• ruolo;
• obiettivo;
• condizioni di completamento;
• procedura;
• limiti;
• strumenti;
• validazione;
• formato di output.

Questi tre elementi sono più importanti che memorizzare l'intero catalogo delle funzionalità.

16. Scheda di Classificazione da Copiare

Usa questa scheda all'inizio di ogni sessione importante:

La scheda non deve essere perfetta.

Il suo obiettivo è creare un'abitudine alla classificazione.

Se consigli Astra ma il compito richiede solo risposte brevi, probabilmente stai sovradimensionando il modello.

Se Sol fallisce ripetutamente a causa della perdita di contesto o dell'incapacità di completare una lunga catena di azioni, probabilmente è il momento di passare ad Astra.

17. Come Pensare Davvero al Prezzo

Le tariffe per milione di token sono solo una parte dell'equazione.

Ad esempio:

Astra

• Input: $10
• Output: $50

Sol

• Input: $4
• Output: $20

Astra costa di più.

Ma immaginiamo:

Sol

$5 di token + 4 tentativi + 2 fallimenti + rilavorazione umana = costo effettivo elevato

Astra

$12 di token + 1 tentativo + risultato corretto = costo totale inferiore per compito

Pertanto, per compiti brevi:

Il prezzo per token conta molto.

Per compiti lunghi:

Il costo per compito completato conta molto di più.

La metrica finale dovrebbe essere:

Costo × tasso di successo × tempo × intervento umano

e non solo:

$/1M token

Conclusione

L'obiettivo di Astra non dovrebbe essere renderlo il modello predefinito per tutto.

L'obiettivo dovrebbe essere costruire un sistema in cui ogni modello svolga il lavoro per cui è più efficiente.

Luna

Volume e compiti semplici.

Terra

Equilibrio tra costo e capacità.

Sol

Lavoro standard e programmazione generale.

Astra

Compiti complessi, lunghi, agentici, GUI, matematici, di debug e lavori in cui il fallimento è costoso.

Il pattern più potente è:

Investigare a basso costo → pianificare → eseguire con Astra quando necessario → verificare → preparare un risultato verificabile → intervento umano solo al checkpoint finale.

La vera ottimizzazione non consiste nell'usare Astra di più.

Consiste nel sapere esattamente quando Astra vale la pena.

E più gli agenti sono complessi, più è importante l'infrastruttura che li circonda: AGENTS.md, Skills, sandbox, approvazioni, gestione del contesto.**