Ecco la traduzione in italiano del testo fornito, seguendo tutte le istruzioni specificate.
Introduzione
Hai i due modelli più capaci mai resi disponibili al pubblico, e li usi ancora uno alla volta, manualmente.
Tre cose sono cambiate nell'ultimo mese.
- Claude Fable 5 pianifica per fasi, delega i propri sotto-agenti e verifica il proprio output. $10 per milione di token in ingresso, $50 in uscita.
- GPT-5.6 è stato rilasciato il 9 luglio in tre livelli permanenti. Sol a $5 e $30, Terra a metà del costo di Sol, Luna a $1 e $6. OpenAI ora vende la decisione di instradamento come prodotto.
- Fable 5 è stato sospeso per 19 giorni a giugno a causa di un ordine di esportazione. La disponibilità è ora una cosa che ti capita.
Usati senza criterio, questi modelli sono un modo costoso per generare cose sbagliate impressionanti.
Usati all'interno di un sistema, sono la cosa più vicina a un dipendente che puoi noleggiare. I dati aziendali di Anthropic posizionano Claude Code a circa $13 per sviluppatore per giorno attivo. OpenAI posiziona Codex a $100-$200 al mese.
Questa guida costruisce quel sistema in dodici build: i file veri e propri, in ordine, ognuno testato prima della pubblicazione, con un checkpoint dopo ognuno, così sai che un pezzo funziona prima di aggiungerci il successivo.
È per chiunque abbia un repository, un terminale e l'accesso a una delle due CLI. Gli esempi sono orientati al codice perché i loop sono cresciuti intorno al codice, ma il router, il consulente e il gate funzionano allo stesso modo con fatture e report.
Leggila in ordine, eseguendo i controlli. Ogni build richiede dai 10 ai 20 minuti, circa due ore in totale. I 30 giorni alla fine sono il programma durante il quale il sistema si guadagna il diritto di funzionare senza di te.
Tre principi prevedono ogni decisione di progettazione qui sotto:
- Instrada ai confini. Lo sforzo prima del modello. Un cambio di modello a metà sessione brucia uno sconto sulla cache pari al 90%. Aumentare lo sforzo di ragionamento sullo stesso modello non costa nulla in termini di complessità dell'infrastruttura.
- Nessuno valuta i propri compiti. Scrittore, router, consulente e revisore sono parti diverse, di diversa estrazione dove possibile, e il voto finale è uno script bash.
- Fatto è un dato di fatto dell'ambiente. Una suite di test superata, un file di attività spuntato, una riga di verdetto. Mai l'opinione del modello su se stesso.
La mappa, e perché quella usuale è sbagliata
L'ingegneria dei loop è un flusso di lavoro agente con una condizione di arresto esplicita e una logica di ripetizione. L'infrastruttura decide quando il lavoro è finito, invece di lasciare al modello la domanda "ho finito?".
L'immagine standard è lo stack Loopcraft di swyx: cinque loop annidati l'uno dentro l'altro, esecuzione dentro compito dentro prodotto dentro sistema dentro supervisione, ognuno con la propria uscita. È la migliore che sia mai stata disegnata.
L'ho usata per settimane. Poi ho provato a costruirci sopra, e si è rotta in quattro punti.
1) Problema uno: i loop non si annidano.
Annidare significa che un giro del loop esterno equivale a un'esecuzione completa del loop interno. Non è così che funziona. Il loop di sistema non aspetta che il loop di prodotto finisca. Viene eseguito la domenica, indipendentemente dal fatto che qualcosa sia stato rilasciato o meno.
Puoi interrompere manualmente un flusso di token senza dover disfare quattro livelli. È un'immagine di contenimento disegnata sopra un sistema che fa passaggi di consegne.
2) Problema due: un loop disegnato come infinito è un conto da pagare.
L'originale disegna il loop di prodotto in questo modo. In pratica, termina per un limite di budget, per un checkpoint o perché qualcuno perde la pazienza.
Chiamarlo "nessuno per progettazione" nasconde il punto esatto in cui il denaro esce da un sistema agente: un loop a cui nessuno ha detto come uscire.
3) Problema tre: non esiste un'interruzione.
Ogni livello ha un lieto fine e nessun finale infelice. I loop reali hanno bisogno di entrambi: come si chiude quando funziona e come si ferma quando non può.
Ogni conto fuori controllo che ho visto era un loop con un'uscita definita e un'interruzione indefinita.
4) Problema quattro: la verifica manca, ed è l'intero gioco.
La verifica è il contratto tra i livelli. Quando un loop inferiore passa un rapporto a un loop superiore invece di un dato di fatto, il loop superiore si chiude su una bugia.
Quella singola lacuna è il motivo per cui un loop può raggiungere la sua condizione di arresto ed essere comunque sbagliato.
Questa è la versione su cui costruisco.
La Scala delle Prove
Sei gradini, due uscite ciascuno, e una regola: il controllo scorre verso il basso come obiettivi, le prove scorrono verso l'alto come fatti, e nessun gradino può chiudersi su un rapporto proveniente dal gradino sottostante.
Dalla forma derivano cinque leggi.
Ogni gradino ha un'interruzione, altrimenti è un conto da pagare. Se non puoi nominare come un loop finisce male, hai costruito un abbonamento. Questo è il motivo per cui ralph.sh porta due limiti e lo sciame porta un limite di cicli.
Le prove scorrono verso l'alto e il controllo scorre verso il basso. Un gradino si chiude su un dato di fatto prodotto al di sotto, mai su un riassunto scritto al di sotto.
Il cancello della fabbrica è questa legge in SQL. Due revisori hanno dato il via libera. Il gate ha comunque rifiutato, perché nessuno aveva prodotto una riga di test superata.
Un verdetto è un'opinione. Una riga è una prova.
Il costo per giro aumenta di circa dieci volte per gradino.
Un bug che sfugge al gradino 2 costa dieci volte di più da individuare al gradino 3, e cento volte di più al gradino 4.
Questo è l'intero argomento per mettere la tua migliore verifica il più in basso possibile sulla scala, motivo per cui il gate è uno script bash e non una riunione.
La scala temporale appartiene al modello, non al gradino.
Il gradino 2 richiedeva minuti nel 2024, richiede ore nel 2026 e presto richiederà giorni. Progetta in base alla condizione di uscita, mai in base all'orologio. È qui che la vecchia immagine invecchia più velocemente.
Solo il gradino 5 non ha una condizione di uscita, ed è questo che significa umano.
Tu vivi lì. La scala esiste per guadagnarsi una frase: un loop può raggiungere la sua condizione di arresto ed essere comunque sbagliato.
I test passano, il gate diventa verde, entrambi i revisori firmano, e l'ultimo commit è ancora un errore. Ogni gradino sotto di te esiste per rendere quel controllo più piccolo. Nessuno di loro può togliertelo.
Prerequisiti
1CLI di Claude (Claude Code) con accesso a Fable 52CLI di codex con accesso a GPT-5.6 # o il plugin ufficiale all'interno di Claude Code3python3, jq, git, gh, make, cron4un repository con un comando di test che funziona oggi56# opzionale, per flotte miste (BUILD 7):7openai/codex-plugin-cc # ufficiale: esegue Codex all'interno di Claude Code8claude-model-switch # proxy locale: qualsiasi fornitore dietro Claude Code9CLIProxyAPI # avvolge gli abbonamenti CLI come endpoint API
Cosa stai costruendo
1tuo-repo/2 CLAUDE.md # BUILD 1: costituzione lato Claude3 AGENTS.md # BUILD 1: costituzione lato Codex4 .claude/5 skills/model-bench/SKILL.md # BUILD 0: prezzi, ID API, fallback. l'unico file con numeri6 skills/model-router/SKILL.md # BUILD 47 skills/stuck-protocol/SKILL.md # BUILD 58 skills/ship-gate/SKILL.md # BUILD 29 agents/fable-expert.md # BUILD 510 agents/fresh-eyes-reviewer.md # BUILD 611 agents/sol-reviewer.md # BUILD 612 agents/scout.md # BUILD 713 loop/14 ralph.sh # BUILD 3: il battito cardiaco15 two_lane.sh # BUILD 6: loop di revisione cross-vendor16 PROMPT.md TASKS.md # BUILD 3: il protocollo di lavoro17 gate/18 verify.sh # BUILD 2: voto finale deterministico19 eval_gate.py eval/cases.jsonl # BUILD 2: gate per le modifiche di instradamento20 router/21 router.py # BUILD 422 advisor_loop.py # BUILD 523 ~/.codex/24 config.toml # BUILD 0: profili luna/terra/sol25 prompts/effort.md # /effort valuta il compito, assegna il posto26 prompts/plan-stop.md # /plan-stop pianifica, preventivalo, poi fermati27 prompts/fable-advice.md # /fable-advice consulenza esperta cross-vendor28 prompts/review-hostile.md # /review-hostile verdetto in contesto pulito29 prompts/compost.md # /compost i fallimenti diventano leggi, settimanalmente30 factory/31 factory_gate.py # BUILD 8: lavagna + gate di completamento32 factory.sh # BUILD 8: brief -> implementa -> revisiona -> gate33 factory.db # BUILD 8: le righe che decidono34 swarm/35 swarm.sh # BUILD 9: pianifica -> invia -> valuta -> ripianifica36 goals.jsonl # BUILD 9: un obiettivo per riga, ognuno con il suo controllo37 system/38 verify_goals.py # BUILD 10: riverifica giornaliera, per sempre39 goals/ # BUILD 10: un file per ogni cosa finita40 ROUTING.md # BUILD 12: la politica di instradamento completa, entrambe le infrastrutture41 progress.log # ogni build aggiunge qui42 # opzionale (BUILD 7): proxy claude-model-switch su localhost:4000,43 # CLIProxyAPI per avvolgere gli abbonamenti CLI come endpoint API
BUILD 0: Configura i Motori
Imposta questi prima di scrivere qualsiasi file tuo. Ogni numero qui sotto è stato verificato rispetto alle pagine dei prezzi ufficiali la settimana della pubblicazione.
La panchina: ogni posto, luglio 2026
La rosa da cui il sistema assume.
I prezzi vivono in un unico file di abilità, .claude/skills/model-bench/SKILL.md, caricato su richiesta prima di qualsiasi domanda di instradamento o costo. Nessun altro file ha un numero hard-coded.
I prezzi si sono spostati tre volte nelle sei settimane precedenti la stesura di questo articolo. Un prezzo in un articolo è sbagliato al momento della pubblicazione. Un prezzo in un file di abilità è distante una modifica.
La suddivisione che decide tutto a valle:
- Fable 5 eccelle nel lavoro software complesso. 80% su SWE-Bench Pro contro il 64,6% di Sol, e supera Sol nell'intelligenza complessiva.
- Sol eccelle nel lavoro da terminale e agente. 88,8% su Terminal-Bench 2.1, ed è in cima all'indice degli agenti di codifica a circa un terzo del costo di Fable per attività.
Questa suddivisione è il motivo per cui questo sistema è multi-fornitore. Fable giudica e pianifica, Sol revisiona e guida i terminali, e nessuno dei due si occupa della digitazione di massa.
Due posti che le persone interpretano male.
Opus 4.8 non è il vecchio modello di punta che prende polvere. È il fallback automatico sotto Fable e il predefinito raccomandato per la codifica agente complessa. Il tuo sistema lo eredita, che tu lo pianifichi o meno.
Sonnet 5 al prezzo di lancio è il miglior rapporto qualità-prezzo della lista. Vicino a Opus 4.8 in capacità a una frazione del prezzo di input di Fable, motivo per cui è l'esecutore predefinito ovunque in questa build. Quella tariffa scade il 31 agosto, e il file di abilità lo sa già.
Quel file di abilità è l'unico file nel sistema che contiene un numero:
1---2name: model-bench3description: Il listino prezzi corrente, gli ID modello API e la catena di fallback4 per ogni modello che questo sistema può assumere. Carica prima di qualsiasi decisione5 di instradamento, stima dei costi, domanda di budget, confronto tra modelli, o quando6 l'utente chiede quanto costa qualcosa.7---89# Panchina dei modelli1011Fonte unica di verità per prezzi e identificatori API. Nient'altro in questo repository12ha un prezzo hard-coded, quindi quando i laboratori modificano le loro tariffe, modifichi13questo file e nient'altro. Verificato il 13-07-2026. I prezzi si muovono. Riverifica prima14di fare un budget.1516## Anthropic (API Messages, /v1/messages)1718Sforzo: output_config {"effort": "low|medium|high|xhigh|max"}. Il pensiero adattivo19è sempre attivo per Fable 5 e non può essere disabilitato. max_tokens limita il pensiero20PIÙ il testo della risposta, quindi impostalo grande (inizia vicino a 64k) su alto e superiore,21altrimenti il modello esaurisce lo spazio a metà pensiero.2223| Modello | In/out per Mtok | Lettura cache | Posto |24|---|---|---|---|25| claude-fable-5 | $10/$50 | $1.00 | conduttore, pianificatore, consulente, giudice. Ricade automaticamente su opus-4-8 |26| claude-opus-4-8 | $5/$25 | $0.50 | conduttore sotto regole di conservazione |27| claude-sonnet-5 | $2/$10 (fino al 31 ago, poi $3/$15) | n/d | esecutore di codifica predefinito |28| claude-haiku-4-5 | $1/$5 | $0.10 | esploratori, sotto-agenti, lavoro meccanico |2930Contesto 1M su Fable, Opus 4.8, Sonnet 5, prezzato IN PIATTO a contesto lungo, motivo per cui31le letture lunghe vengono instradate qui. Output massimo 128K.3233## OpenAI (API Responses, /v1/responses)3435| Modello | In/out per Mtok | In cache | Posto |36|---|---|---|---|37| gpt-5.6-sol | $5/$30 | $0.50 | revisore cross-vendor, lavoro da terminale |38| gpt-5.6-terra | $2.50/$15 | $0.25 | driver quotidiano Codex (testa prima con Luna) |39| gpt-5.6-luna | $1/$6 | $0.10 | lavoro meccanico, tick silenziosi |4041Il contesto lungo sopra la soglia RADDOPPIA circa il prezzo di input, a differenza dei livelli42piatti da 1M di Anthropic. Prima famiglia con punti di interruzione espliciti della cache;43le scritture costano 1.25x.4445## Pesi aperti (lavoratori di massa)4647| Modello | In/out per Mtok | Hit cache |48|---|---|---|49| deepseek-v4-flash | $0.14/$0.28 | $0.0028 (circa 98% di sconto) |50| deepseek-v4-pro | $0.435/$0.87 | n/d |51| kimi-k2.7-code | $0.95/$4.00 | $0.19 |5253## Sconti che si accumulano54 - le letture della cache costano un decimo dell'input fresco in entrambi i laboratori (circa 90% di sconto)55 - le scritture nella cache si ripagano da sole dopo una lettura (5m) o due (1h)56 - le API batch sono scontate del 50% in entrambe le direzioni57 - batch + lettura cache su un prefisso ripetuto si avvicina al 95% di sconto58 - il nuovo tokenizer di Anthropic produce circa il 30% in più di token per lo stesso59 testo, quindi il costo effettivo è superiore al prezzo indicato. Fai il budget sul costo effettivo.6061## Come rispondere a una domanda sui costi62 1. Stima input e output separatamente. Gli agenti leggono circa 100 token per ogni63 1 che scrivono, quindi l'input domina e il tasso di hit della cache decide il conto.64 2. Applica la tariffa di lettura cache al prefisso ripetuto, non alla tariffa base.65 3. Moltiplica le cifre di Anthropic per circa 1,3 per il tokenizer.66 4. Cita un intervallo, nomina le ipotesi, dì quale riga di questo file hai usato.67 5. Se il numero supera il limite giornaliero del repository, dillo PRIMA di eseguire qualsiasi cosa.6869Non presentare mai un prezzo che non hai letto da questo file. Un modello non elencato qui non è70sulla panchina, e aggiungerlo è una modifica di instradamento che passa attraverso il gate.
Sette fatti che cambiano il modo in cui costruisci:
- L'input in cache ha il 90% di sconto in entrambi i laboratori. Un timestamp nel tuo prompt di sistema lo brucia a ogni chiamata. Prefisso stabile, cronologia solo append, sempre. Gli agenti leggono circa 100 token per ogni 1 che scrivono, quindi questo sconto è la maggior parte del tuo conto.
- Le scritture nella cache costano di più ma si ripagano velocemente. La scrittura da 5 minuti di Anthropic fattura 1,25x e raggiunge il pareggio dopo una singola lettura. GPT-5.6 è la prima famiglia di OpenAI con punti di interruzione espliciti della cache e scritture prezzate. Architetta intorno alla cache come un programmatore di sistemi architetta intorno a una gerarchia di memoria.
- Il più recente tokenizer di Anthropic produce circa il 30% in più di token per lo stesso testo. Il prezzo effettivo è superiore al prezzo indicato. Fai il budget sul costo effettivo.
- Un rifiuto di sicurezza da Fable 5 non è un errore. La chiamata ha successo e il lavoro finisce su Opus 4.8, per progettazione, in meno del 5% delle sessioni. Leggi cosa è successo, non solo il codice di uscita, e configura la catena di fallback prima di averne bisogno.
- Non impostare come predefinito il livello intermedio. Test indipendenti hanno scoperto che alcune impostazioni Luna o Sol battono sempre Terra sulla frontiera costo-qualità. Testa Terra contro Luna sul tuo traffico prima di pagarlo.
- Le API batch dimezzano qualsiasi cosa possa aspettare una notte, e lo sconto si accumula con la cache: i prefissi ripetuti nel lavoro batch funzionano quasi al 95% di sconto. Il bruciatore notturno nella BUILD 7 esiste per sfruttarlo.
- La disponibilità è un rischio operativo, non un'ipotesi. Fable 5 ha perso 19 giorni a giugno. Ogni riferimento a modello qui ha un fallback: fable-5 cade su opus, sol cade su terra, e ogni fallback viene registrato.
Il secondo contatore: un posto non è una chiave API
Ogni numero sopra è prezzato in dollari per milione di token. Questa è la valuta giusta se paghi per chiamata.
È quella sbagliata se esegui questo su un posto Codex Pro da $200 o un posto Claude Max.
Su un posto, il contatore è una finestra di cinque ore e una finestra settimanale, valutate insieme, e una richiesta conta per entrambe.
Puoi essere a posto per la settimana ed essere comunque bloccato per quattro ore, perché un singolo messaggio ha consumato quella breve.
Stessa dottrina. Valuta diversa. Tre impostazioni decidono quanto di una finestra un singolo messaggio può consumare:
La modalità veloce è quella costosa, perché moltiplica un numero che è appena diventato più grande.
GPT-5.6 funziona molto più a lungo per messaggio di quanto facesse 5.5. Per lo più un regalo. Rende anche il consumo imprevedibile.
- Theo riporta di aver bruciato oltre $200.000 di token su Sol
- Ha osservato un singolo messaggio 5.6 consumare il 15% di una finestra di cinque ore
- Con il moltiplicatore, questo è il 40% della finestra in un singolo messaggio
La velocità non è gratuita. Ti addebita i token che avresti bruciato comunque. Rileggi il moltiplicatore nei documenti sulla velocità prima di fidartene: è pubblicato per modello e si muove.
Ultra è la trappola più sottile, perché l'interfaccia lo archivia dove vivono i livelli di sforzo e non è uno di loro.
- Max è profondità. Un modello, un problema, più tempo su una singola catena di ragionamento.
- Ultra è ampiezza. Il lavoro si dirama a quattro agenti, poi viene sintetizzato.
- Assi diversi. Ultra non è "più di max."
Puntato su un compito che non si divide veramente, ultra compra quattro agenti che duplicano un'unica indagine.
Vale circa 3,1 punti su Terminal-Bench 2.1, da 88,8 a 91,9, per un consumo pari a un'intera flotta. Disattivo finché i confini tra i sotto-problemi non sono reali.
Perché Sol e Terra sono entrambi valori predefiniti corretti
Un rapporto sul campo esegue Sol per quasi tutto. La panchina qui sopra fa di Terra il driver quotidiano di Codex. Entrambi hanno ragione, e il contatore è il motivo.
- La scheda tariffaria dice che l'output di Sol costa il doppio di quello di Terra
- Il posto dice che hai già pagato
- Quindi l'unica domanda concreta è quanti turni servono per arrivare al verde
- Un modello più forte con uno sforzo inferiore di solito ne ha bisogno di meno
La tariffa non è il costo. Il costo è la tariffa moltiplicata per i turni per arrivare al verde, e il secondo termine è quello che si muove.
Che è la legge della BUILD 4 che arriva dall'altra direzione: aggiorna il posto prima di toccare la manopola. Su un posto che legge come Sol su alto al livello da $200, Sol su basso sotto di esso. Misura prima di credere a entrambi.
Imposta ora i livelli di Codex:
1# ~/.codex/config.toml2model = "gpt-5.6-terra" # driver quotidiano3model_reasoning_effort = "medium"4# service_tier = "fast" # LASCIA COMMENTATO. la modalità veloce fattura 2.5x5 # crediti. esegui /fast status per confermare di non6 # essere già dentro.78[profiles.fast] # lavoro meccanico. NON "modalità veloce": questo9model = "gpt-5.6-luna" # profilo è un modello più economico, non un contatore 2.5x10model_reasoning_effort = "low" # due cose diverse, una parola.1112[profiles.deep] # pianificazione, bug difficili, revisioni13model = "gpt-5.6-sol"14model_reasoning_effort = "high"
CHECK 0: entrambe le CLI si autenticano e il tuo comando di test termina con 0 sul repository corrente.
BUILD 1: Le Costituzioni
Questi modelli seguono leggi e ottimizzano in base ai suggerimenti, quindi ogni riga ha bisogno di un numero, un "mai" o un comando che la verifichi.
Crea CLAUDE.md:
1# CLAUDE.md23## MAI (le eccezioni richiedono di chiedere prima)4- Mai cambiare modello a metà sessione. L'instradamento avviene solo ai confini5 di sessione e sotto-agente. Gli scambi a metà compito bruciano la cache.6- Mai revisionare il proprio diff. La revisione proviene da un contesto fresco o da una7 stirpe diversa. Il revisore di Devin cattura 2 bug per PR agente proprio8 perché non condivide nulla con lo scrittore.9- Mai modificare, indebolire o eliminare un test per farlo passare. FALLIMENTO automatico.10- Mai riportare "fatto" da una autovalutazione. Fatto = gate/verify.sh superato.11- Mai fare una quarta consultazione con un consulente. Tre fallimenti = BLOCCATO, tocca all'umano.12- Mai unire una modifica di instradamento o di prompt che eval_gate.py ha BLOCCATO.13- Mai eseguire alcun loop senza entrambi i limiti impostati: MAX_ITERS e BUDGET_USD.14- Mai presumere che un modello all'avanguardia sia attivo. Fallback: fable-5 -> opus,15 sol -> terra. Registra ogni fallback su progress.log.16- Mai generare un sotto-agente che non ti è stato richiesto. I figli ereditano il17 modello E lo sforzo del genitore, quindi una flotta troppo zelante eredita il posto costoso.1819## DISPACCIO (vince la prima corrispondenza)20| # | Compito | Posto |21|---|---|---|22| 1 | pianificare / architettare / migrare | fable-5 pianifica, sonnet esegue |23| 2 | estrarre / formattare / test / documenti | haiku o luna |24| 3 | contesto oltre 60k token | Livello piatto da 1M di Anthropic |25| 4 | revisione di codice scritto da agente | sol tramite codex, infrastruttura nativa |26| 5 | ambiguo | punteggio di difficoltà: 0-1 economico, 2 sonnet, 3+ all'avanguardia |27| 6 | ancora incerto | esegui economico una volta, verifica, scala una volta in caso di fallimento |2829## FATTO30- Ogni compito porta una condizione done_when verificabile dalla macchina prima che il lavoro inizi.31- Un revisore in contesto fresco giudica la specifica contro il diff, nient'altro.32- gate/verify.sh detiene il voto finale. Due disaccordi creatore/verificatore33 su un elemento -> fermati, metti in coda per un umano.
Crea AGENTS.md nella radice del repository, le stesse leggi nel dialetto di Codex. Mantienilo vicino a 100 righe, un indice, non un'enciclopedia:
1# AGENTS.md23## Comandi4| Scopo | Comando |5|---|---|6| Test | make test (questo comando è la definizione di fatto) |7| Lint | make lint |89## Protocollo di sessione101. Leggi prima progress.log e TASKS.md. 2. UN compito non spuntato.113. Implementa, esegui la SUITE completa, esegui commit solo verde, messaggio descrittivo.124. Spunta il compito, aggiungi una riga a progress.log, fermati.13I test definiscono "fatto". Mai indebolire, saltare o eliminarne uno. Test sbagliato =14segna il compito come BLOCCATO e spiega perché.1516## Politica del modello17Predefinito: terra, sforzo medio. Meccanico: profilo fast (luna, basso).18Pianificazione e bug difficili: profilo deep (sol, alto).19Sforzo prima del modello. Profilo scelto all'inizio della sessione, mai a metà compito.20Modalità veloce SPENTA (2.5x crediti). Ultra SPENTA. Nessuna delle due è un livello di sforzo.21Genera un sotto-agente solo quando te lo chiedo. I figli ereditano il modello DI QUESTA22sessione E il livello di ragionamento, quindi una generazione troppo zelante con sforzo alto23è un'intera flotta con sforzo alto.2425## In stallo26Segnali: stesso errore due volte; due passi senza progresso; un test che sopravvive a due27correzioni distinte. Poi /fable-advice. Massimo 3 consultazioni, poi BLOCCATO.2829## Revisione30/review-hostile in una sessione FRESCA prima di qualsiasi unione, o la corsia cross-vendor31dal lato Claude. Mai unire il proprio lavoro non revisionato.
Una dottrina deve vivere su entrambi i lati, altrimenti l'infrastruttura con le abitudini più lasche vince ogni volta che cambi strumento.
CHECK 1: per ogni riga, chiediti se il modello potrebbe rispettare all'80% e dichiarare successo. Se sì, riscrivila con un numero o un "mai". wc -l CLAUDE.md sotto 60.
BUILD 2: Il Gate
Uno script bash deve detenere il voto finale prima che esista qualsiasi altra cosa, perché ogni build successiva lo presuppone.
Crea gate/verify.sh per il tuo stack:
1#!/usr/bin/env bash2set -e3npm run typecheck --if-present4npm test --if-present5npm run lint --if-present
Crea gate/eval_gate.py, la cintura di sicurezza per ogni futura modifica di instradamento o prompt. Esegue da 50 a 500 casi esclusi attraverso la configurazione corrente e quella proposta, con solo controlli deterministici:
1for case in cases: # {prompt, must_include, must_not_include, max_words}2 hits += passes(case, run_config(case.prompt))3verdict = "SHIP" if new_score >= old_score - 0.02 else "BLOCKED"
Poi rendi il gate non saltabile come abilità, .claude/skills/ship-gate/SKILL.md:
1---2name: ship-gate3description: Esegui il gate di valutazione prima di qualsiasi modifica al routing, al modello o al prompt. Da usare quando l'utente chiede di cambiare le regole di routing, sostituire un tier di modello, modificare un system prompt, regolare i livelli di effort o unire qualsiasi cosa che tocchi il router, i prompt o la configurazione del modello.4---56# Ship gate78Qualsiasi modifica al routing o ai prompt è una scommessa sulla qualità finché il gate non dice il contrario. Questa skill esiste perché la scommessa non venga mai spedita in silenzio.9101. Individua eval/cases.jsonl. Se non esiste, FERMATI e comunica all'utente di creare prima da 50 a 500 casi rappresentativi, basati sul traffico reale. Non inventare casi da solo.112. Esegui: python3 eval_gate.py eval/cases.jsonl, config corrente vs proposta.123. BLOCCATO: riporta entrambi i punteggi, elenca quali casi hanno subito regressioni, non applicare la modifica, suggerisci il rollback più piccolo che sblocca il gate.134. SPEDITO: applica la modifica e aggiungi una riga a progress.log con entrambi i punteggi.1415Regole ferree:16 - Non ignorare mai un verdetto BLOCCATO, anche se richiesto gentilmente. Segnala all'umano con i casi falliti allegati.17 - Non modificare mai il file dei casi nella stessa sessione di una modifica al routing. Il gate e la modifica non devono condividere un autore.18 - I numeri di costo non sono una difesa contro un calo di qualità. Il gate vince.
Il gate utilizza solo controlli deterministici, perché non deve mai ereditare il problema di "chi verifica il verificatore". Una modifica al routing senza un gate di valutazione è un esperimento sui costi che stai facendo pagare ai tuoi clienti.
CHECK 2: ./gate/verify.sh esce con 0 oggi, e eval_gate.py stampa SPEDITO nella sua demo. Se verify.sh fallisce ora, risolvilo prima di tutto il resto. Il sistema si regge su questo script.
BUILD 3: The Heartbeat
Il modello porta l'intelligenza. Il ciclo porta la disciplina.
- Un contesto fresco a ogni iterazione previene il degrado del contesto
- Il repository porta tutta la memoria
- Due limiti trasformano un agente fuori controllo in una lezione da dieci dollari
Questa è la forma esatta dietro il run a 16 cicli di Anthropic che ha costruito un compilatore C da 100.000 righe per circa $20.000, senza alcun modello orchestratore.
Crea loop/PROMPT.md:
1Leggi progress.log e TASKS.md. Scegli ESATTAMENTE UN'attività non spuntata.2Implementala. Esegui i test. Se è tutto verde: fai un commit con un messaggio3descrittivo, spunta l'attività, aggiungi una riga a progress.log, fermati.4Se la stessa attività fallisce due volte, segnala come BLOCCATA con l'errore e fermati.5Crea un file chiamato DONE solo quando ogni attività è spuntata E l'intera6suite di test passa. Non modificare mai un test per farlo passare.
Crea loop/ralph.sh:
1#!/usr/bin/env bash2set -u3MAX_ITERS="${MAX_ITERS:-25}" # limite uno: iterazioni4BUDGET_USD="${BUDGET_USD:-10}" # limite due: dollari5MAX_FAILS=3; fails=0; spent=0; i=067while [ ! -f DONE ] && [ "$i" -lt "$MAX_ITERS" ]; do8 i=$((i + 1))9 # sessione fresca a ogni iterazione: nessuna memoria tranne il repo stesso10 claude -p "$(cat PROMPT.md)" --max-turns 30 \11 --output-format json > out.json 2> err.log \12 && fails=0 || fails=$((fails + 1))13 [ "$fails" -ge "$MAX_FAILS" ] && exit 2 # interruttore14 cost=$(jq -r '.total_cost_usd // 0' out.json)15 spent=$(awk -v a="$spent" -v b="$cost" 'BEGIN{printf "%.4f", a+b}')16 awk -v s="$spent" -v c="$BUDGET_USD" 'BEGIN{exit !(s>c)}' && exit 3 # limite17 sleep 218done19[ -f DONE ] && echo "fatto in $i tick, \$$spent" || echo "limite raggiunto, \$$spent"
Sostituisci la riga di claude con codex exec e il ciclo identico guida GPT-5.6.
La mappa di uscita è intenzionale: 0 fatto o silenzio, 2 interruttore, 3 budget. Ogni allarme in BUILD 12 si basa su questi.
La riga del costo legge il report dei costi JSON della sessione stessa, quindi il limite è imposto dall'harness in base alla spesa reale, non a una stima.
Conta le fermate in quel prompt. Ogni ramo termina con una, e questo è il design, non un tic.
Questa generazione gira molto più a lungo per messaggio rispetto alla precedente. Per lo più un dono. Ogni tanto un conto, perché un modello che non ha più bisogno di essere incoraggiato a continuare porterà un'attività quattro passi oltre il punto in cui avresti voluto esaminarla.
Il ciclo risolve strutturalmente: un'attività per tick, stop brusco alla fine.
In modo interattivo devi dirlo ad alta voce. Due prompt fanno il lavoro:
- "scrivi il piano, poi fermati e mostramelo prima di costruire qualsiasi cosa"
- una volta che il piano è buono: "costruiscilo, testalo, apri la PR, gestisci il primo giro di commenti della review, poi fermati"
Un modello che gira a lungo è pericoloso solo quando nessuno gli ha detto dov'è il limite.
I compiti lunghi falliscono come fallisce il contesto, quindi le iterazioni rimangono brevi e l'ambiente fa da memoria. La Fable 5 e i modelli Codex ora compattano il proprio contesto a metà esecuzione, quindi resisti all'idea di aggiungere plumberie di memoria elaborate; la quantità giusta si riduce ogni trimestre.
CHECK 3: due minuscole attività reali in TASKS.md, un tick eseguito a mano con BUDGET_USD=2. Conferma un commit, un'attività spuntata, una riga di log, e che il ciclo esce invece di iniziare una seconda attività.
BUILD 4: The Router That Earns Its Job (model, then effort)
Il benchmark di routing più rigoroso del 2026, LLMRouterBench, ha scoperto che molti router, inclusi quelli commerciali, non riescono a battere in modo affidabile la scelta del miglior modello singolo. Quindi il router è colpevole fino a prova contraria sul tuo traffico.
La regola decisionale, prima di qualsiasi codice. Aggiungi un router solo quando entrambe queste condizioni sono vere:
- Il tier economico e quello frontier mostrano approssimativamente un gap di cinque volte in capacità-per-dollaro sul tuo traffico
- Il set di valutazione di BUILD 2 esiste per controllarlo
Se un modello ben scelto batte il tuo router su quelle valutazioni, elimina il router e goditi la semplicità.
Una volta superata la soglia, router/router.py esegue tre livelli, decisione più economica per prima. Nota che i tier nominano i posti, mai i prezzi: le tariffe provengono dalla skill bench in fase di esecuzione, quindi una variazione di prezzo non tocca mai il tuo router.
1TIERS = { # posti, non numeri2 "cheap": "gpt-5.6-luna", # o claude-haiku-4-53 "mid": "claude-sonnet-5",4 "frontier": "claude-fable-5", # o gpt-5.6-sol5}6PRICES = load_bench(".claude/skills/model-bench/SKILL.md") # unica fonte di verità78RULES = [9 (kind in {"extract", "format", "summarize"}, "cheap"),10 (kind in {"plan", "architect", "migrate"}, "frontier"),11 (context_length > 60_000, "mid"),12]13tier = layer1_rules(task) or layer2_classifier(task)14if tier: return call(TIERS[tier], task)15return cascade(task) # cheap prima, verifica, scala UNA SOLA VOLTA in caso di fallimento
Il livello intermedio assegna un punteggio di difficoltà basato su marcatori che puoi leggere: why, debug, race, deadlock, refactor, security, più codice nel prompt, un tentativo fallito precedente e più di un sottosistema coinvolto.
Zero o un punto va al cheap. Due punti al mid. Tre o più al frontier. Il verificatore della cascata è deterministico e scala esattamente una volta.
Collega le stesse decisioni nell'harness in modo che si attivino senza essere invocate, .claude/skills/model-router/SKILL.md. Nota che la skill non riformula le regole, le legge, lo stesso trucco della fonte unica di verità che il bench usa per i prezzi:
1---2name: model-router3description: Instrada ogni attività al posto e all'effort giusti prima di iniziare il lavoro. Da usare all'inizio della sessione, prima di generare subagenti, quando l'utente chiede quale modello usare, o quando un'attività mescola pianificazione ed esecuzione.4---56# Model router78Leggi ROUTING.md e applicalo. Non improvvisare una policy, e non riformularne una qui: questo file marcirebbe, e il file della policy è quello sotto il gate di valutazione.910Tre cose che questa skill impone in aggiunta a quel file:1112 1. Instrada solo ai confini. Inizio sessione e generazione di subagenti. Uno scambio a metà attività invalida la cache e rifattura il contesto a dieci volte la tariffa della cache.13 2. Alla fine della sessione, aggiungi la quota del tier economico a progress.log. I risparmi si accumulano solo quando la maggior parte del traffico va sul cheap, quindi quel numero è quello da tenere d'occhio.14 3. Qualsiasi modifica a ROUTING.md viene spedita tramite la skill ship-gate. Nessuna eccezione.
L'ordine delle decisioni rispecchia il costo: prima un controllo gratuito, poi un'ipotesi con punteggio, infine un esperimento a pagamento.
Il denaro è la ripartizione del traffico, non l'ingegnosità.
- Invia il 70 percento del lavoro a un tier che costa un decimo del prezzo e la bolletta scende di circa due terzi
- I report di produzione si attestano tra il 40 e l'85 percento di risparmio, e la differenza è quasi interamente la ripartizione
- I risparmi si accumulano solo dopo che la maggior parte del traffico va sul cheap
Ecco perché la quota cheap in progress.log è l'unico numero che questo sistema ti obbliga a monitorare.
L'effort è la seconda leva
L'effort è il routing a un livello inferiore: la stessa skill, applicata a quanto a lungo il modello pensa invece di quale modello esegue.
Ogni strumento seppellisce la leva su un'impostazione predefinita diversa. Alta in Claude Code. Media in Codex. Nascosta nella maggior parte delle app. Quindi le persone lasciano un'impostazione per tutto, e o pagano troppo o pensano troppo poco.
Imposta su alto come predefinito e tratta il massimo come ultima risorsa, non come vanto.
- La stessa documentazione di Anthropic sull'effort colloca il punto ottimale su alto, e avverte che il massimo porta a un eccesso di riflessione
- Un benchmark pubblico su 26 attività di codifica ha scoperto che alto triplica approssimativamente la qualità rispetto a basso
- Lo stesso benchmark ha scoperto che xhigh costa più del doppio per un guadagno che raramente si ripaga da solo
Il modello conta almeno quanto la leva. Fable 5 con effort più basso spesso batte modelli più vecchi che girano a xhigh, quindi cerca il modello migliore prima dell'impostazione più alta.
Due impostazioni vengono scambiate per gradini più alti di questa scala. Nessuna delle due lo è.
- Massimo è profondità. Un modello, un problema, più tempo.
- Ultra è ampiezza. Un'attività suddivisa in quattro agenti paralleli, poi sintetizzata.
Assi diversi. Ultra non è "più del massimo", e puntarlo su un'attività che non si divide veramente significa comprare quattro agenti che duplicano un'unica indagine.
La scala non si trasporta tra versioni. La stessa parola compra una diversa quantità di riflessione su un modello nuovo rispetto a quello vecchio.
Spostando un'attività familiare su un nuovo posto, inizia un gradino sotto l'impostazione di cui ti fidi. Sali solo se l'output lo richiede.
Una trappola appartiene specificamente agli sciami.
I subagenti ereditano il modello e l'effort del genitore. Una flotta generata da un conduttore a effort massimo è una flotta a effort massimo, e drena una finestra in un singolo messaggio.
Bloccali nel loro frontmatter, e sappi in quale harness ti trovi quando lo fai, perché il blocco vale solo quanto il generatore che lo legge.
- Lato Claude. Il frontmatter qui sotto è il controllo.
- Lato Codex. 5.6 genera figli al modello e al livello di ragionamento del genitore, e lo fa con impazienza. La leva del genitore è la leva della flotta.
Sul lato Codex gli unici veri controlli sono l'impostazione con cui hai aperto la sessione, e una riga in AGENTS.md che dice di non generare a meno che non venga richiesto. Verifica quale hai prima di fidarti dell'una o dell'altra:
1name: scout2model: haiku3effort: low # i subagenti ereditano dal genitore. uno sciame a effort4 # massimo svuota una finestra in un messaggio. bloccali.
Impostalo per strumento: /effort in Claude Code e nella TUI di Codex, un flag come codex -e high, una riga in config, o il campo effort sull'API.
Il routing del modello decide chi pensa. Il routing dell'effort decide per quanto tempo, e la seconda leva è più economica da girare perché nient'altro nella configurazione cambia e la cache rimane calda. Spendi effort dove il ciclo si dirama. Ovunque altro è una tassa.
Tieni traccia dell'unico numero settimanalmente:
1grep '^route' progress.log | awk -F'\t' \2 '{r++; if($3!="frontier")c++} END{printf "cheap share: %.0f%%\n", c/r*100}'
ROUTING.md, la policy che entrambi gli harness leggono
Tutto quanto sopra si condensa in un file nella radice del repository.
1# ROUTING.md23Il routing è quattro decisioni, e l'ordine è il punto:4 1. DOVE: quale harness esegue il lavoro5 2. QUANDO: a quale confine viene presa la decisione6 3. CHI: quale modello occupa il posto7 4. QUANTO SFORZO: a quale livello di effort opera quel modello8La maggior parte dei team discute solo del 3. I soldi sono nel 2 e nel 4.910## 1. DOVE: harness prima del modello11Un modello post-addestrato all'interno di un harness opera fuori distribuzione ovunque altro.12Differenza misurata: 20,2 percento nativo vs 7,7 percento esterno, stessi pesi.1314| Lavoro | Harness | Perché |15|---|---|---|16| scrivere codice | harness nativo del modello | gli scrittori degradano fuori distribuzione |17| revisionare codice | harness nativo del revisore | una revisione debole è peggio di nessuna |18| leggere, esplorare | ovunque | le letture sono economiche e verificabili |19| trasformazioni meccaniche | ovunque | se il controllo è deterministico, l'harness conta poco |2021LEGGE: rimappa liberamente i canali del lettore e del revisore. Il canale dello scrittore rimane nell'harness nativo finché il tuo set di valutazione non dice diversamente. Quella sostituzione deve essere una misurazione, non una preferenza.2223## 2. QUANDO: instrada ai confini, mai al loro interno24Uno scambio a metà sessione butta via la cache del prompt. L'input in cache costa un decimo dell'input fresco, quindi uno scambio inutile rifattura l'intero contesto a dieci volte il prezzo e non compra nulla.2526Confini legali, gli UNICI posti in cui può avvenire una decisione di routing:27 - inizio sessione28 - generazione di un subagente29 - un nuovo obiettivo nello sciame30 - un passaggio di revisione all'altra linea31 - un fallback attivato da un'interruzione o da una salvaguardia3233Illegale ovunque altro. Nessun routing per turno. Nessuno scambio adattivo a metà attività. La cascata ottiene ESATTAMENTE UNA escalation, e apre un nuovo confine.3435LEGGE: scegli il posto quando il confine si apre, poi rimani lì fino al successivo.3637## 3. CHI: la procedura decisionale (prima corrispondenza vince, registra il risultato)3839Livello 1, regole. Gratuito. Controlla sempre prima.4041| Segnale | Posto |42|---|---|43| extract / format / summarize / classify / tests | Haiku o Luna, effort basso |44| plan / architect / migrate / root-cause | Fable pianifica, Sonnet esegue |45| contesto oltre 60k token | Tier Anthropic 1M (prezzo fisso) |46| revisione di codice scritto da un agente | l'altra linea, harness nativo |47| obiettivo si suddivide in parti indipendenti | sciame: Fable scrive e assegna punteggio |4849Livello 2, il punteggio. Un punto ciascuno:50 - contiene why / debug / race / deadlock / refactor / security / optimize51 - tocca più di un sottosistema52 - un tentativo precedente è già fallito53 - la modifica è irreversibile o rivolta all'utente54 0-1 -> tier economico, effort basso. 2 -> Sonnet, medio. 3+ -> frontier, alto.5556Livello 3, la cascata. Esegui cheap, verifica deterministicamente, scala ESATTAMENTE UNA VOLTA. Mai due. Un secondo fallimento è un problema di specifica, e un modello più grande non risolverà la tua specifica.5758Posti e fallback vivono in .claude/skills/model-bench/SKILL.md. Nessun prezzo qui.5960## 4. QUANTO SFORZO: routing dell'effort61L'effort è il routing a un livello inferiore. La leva più economica in questo file: nient'altro cambia e la cache rimane calda.6263| Effort | Usalo per |64|---|---|65| basso | refusi, ridenominazioni, ordinamento, estrazione, OGNI subagente per impostazione predefinita |66| medio | codice di routine da una specifica chiara, riassunti, scrittura standard |67| alto | smontaggi, migrazioni, bug difficili, tutto il lavoro del conduttore (PREDEFINITO) |68| massimo | solo il problema che alto ha già fallito a risolvere |69| ultra | NON SU QUESTA SCALA. ampiezza, non profondità: 4 agenti in parallelo. disattivato per impostazione predefinita |7071 1. Predefinito su alto. Il punto ottimale è lì; il massimo tende a riflettere troppo.72 2. Un modello migliore batte una leva più alta. Aggiorna il posto prima dell'impostazione.73 3. I subagenti EREDITANO il modello E l'effort del genitore. Una flotta generata da un conduttore a effort massimo opera al massimo e svuota una finestra in un messaggio. Blocca ogni subagente nel suo frontmatter: effort: low. Dove il generatore ignora il blocco, la leva del genitore È la leva della flotta. Controlla quale hai.74 4. Massimo è profondità. Ultra è ampiezza. Ultra solo quando i sottoproblemi sono genuinamente indipendenti, mai come predefinito, e per niente mentre l'harness genera in eccesso.75 5. La scala non si trasporta tra versioni. Su un modello nuovo, inizia un gradino sotto l'impostazione di cui ti fidavi su quello vecchio.76 6. La modalità veloce non è nemmeno un livello di effort. Compra latenza a 2,5x crediti su token che stavi comunque bruciando. Disattivata.7778La leva vive in quattro posti: /effort in Claude Code e nella TUI di Codex, codex -e high, model_reasoning_effort in config, il campo effort sull'API. Claude Code predefinito alto, Codex predefinito medio, la maggior parte delle app lo nasconde completamente, motivo per cui i team eseguono accidentalmente un livello per tutto.7980## 5. Fallback: presupponi che il frontier sia giù81La disponibilità del frontier non è garantita, e una salvaguardia può reindirizzare una chiamata a Opus 4.8 a metà esecuzione, in meno del 5 percento delle sessioni, senza errori.82 - Ogni posto ha un fallback designato. Nessuna eccezione.83 - Ogni fallback viene registrato. Un reindirizzamento silenzioso è un bug, perché potresti leggere output da un modello che non hai scelto.84 - NON iterare MAI sull'output di un modello che non hai scelto tu.8586## 6. Il numero che decide se tutto questo ha funzionato87Il costo ponderato è la tua ripartizione del traffico, nient'altro. Il 70 percento cheap taglia la bolletta di circa due terzi. Il 10 percento risparmia spiccioli. L'accuratezza del router vale molto più dell'ingegnosità del router.8889Tienine traccia con il comando in BUILD 4. Sotto il 50 percento, i risparmi non hanno iniziato a crescere. Sistema la ripartizione prima di toccare qualsiasi altra cosa qui.9091## 7. Il gate su questo file92LEGGE: nessuna modifica a questo file viene spedita senza che eval_gate.py superi 50-500 casi trattenuti. Un verdetto BLOCCATO è definitivo e non può essere sovrascritto in sessione. Il gate e la modifica non devono condividere un autore.9394## 8. Quando eliminare questo file95Se un singolo modello ben scelto batte l'intero stack sulle tue valutazioni, elimina il router e mantieni la semplicità. Il benchmark di routing più rigoroso del 2026 ha scoperto che molti router, inclusi quelli commerciali, non riescono a battere in modo affidabile la scelta del miglior modello singolo.96Misura prima. Instrada dopo. Elimina volentieri.
CHECK 4: router.py gira offline e stampa una decisione, un motivo e la ripartizione. I tuoi appunti contengono la misurazione del gap di 5x, o una nota datata che dice che il router non è ancora giustificato.
BUILD 5: The Advisor Inversion
Lo schema classico mette il modello intelligente al comando e brucia token frontier sull'esecuzione di massa. Invertilo.
I risultati di Anthropic con l'advisor: Haiku con un advisor di classe Opus ha più che raddoppiato il suo punteggio su un benchmark di navigazione difficile, 41,2 contro 19,7 da solo, con un costo per attività inferiore dell'85% rispetto al tier medio.
L'esecuzione è massa. Il consiglio è grammi.
L'harness decide quando il driver è bloccato, mai il driver, .claude/skills/stuck-protocol/SKILL.md:
1---2name: stuck-protocol3description: Scalare all'advisor esperto fable quando i progressi si bloccano. Da usare quando lo stesso errore appare due volte, quando due passaggi consecutivi non modificano file mentre gli errori persistono, quando un test fallisce dopo due distinti tentativi di correzione, o quando l'utente dice che l'agente sta girando in tondo.4---56# Stuck protocol (l'inversione dell'advisor)78Sei il driver economico e questa è una caratteristica: l'esecuzione è massa, il consiglio è grammi. Ma i modelli piccoli sono troppo sicuri di sé, quindi non puoi decidere tu che va tutto bene. Controlla invece i segnali deterministici.910Segnali di blocco (uno qualsiasi attiva il protocollo):11 1. La stessa stringa di errore in due passaggi consecutivi.12 2. Due passaggi consecutivi con zero file modificati mentre gli errori persistono.13 3. Lo stesso test che fallisce dopo due tentativi di correzione genuinamente diversi.1415Procedura:16 1. Conta le consulenze in questa sessione. A 3, FERMATI: segna l'attività come BLOCCATA con l'errore allegato, riassumi per l'umano, passa oltre. Mai una quarta consulenza.17 2. Prepara il brief, nient'altro ci va dentro:18 OBIETTIVO: una riga19 TENTATIVO x2: gli ultimi due tentativi, 200 caratteri ciascuno20 ERRORE: l'errore esatto, 300 caratteri21 3. Genera fable-expert con il brief. Restituisce indicazioni, non codice.22 4. Applica le indicazioni nel passaggio immediatamente successivo, prima di qualsiasi cosa di tua iniziativa.23 5. Aggiungi una riga a progress.log: consulenza #N, cosa ha detto, se ha funzionato.2425Regole ferree:26 - Non chiedere mai all'esperto di fare il lavoro. Se la risposta contiene un'implementazione completa, prendi l'idea e scarta il codice.27 - Non appesantire mai il brief con la tua cronologia di ragionamento. Il valore dell'esperto è il contesto pulito; un brief lungo lo avvelena.28 - Se l'indicazione fallisce, conta come uno dei tuoi due tentativi verso la consulenza successiva. Tre consulenze fallite significano che l'attività è al di sopra del livello di questa sessione, e dirlo è l'output corretto.
Il posto dell'esperto, .claude/agents/fable-expert.md:
1---2name: fable-expert3description: Advisor frontier per momenti di blocco. Riceve un brief compatto da stuck-protocol, restituisce indicazioni sotto i 600 token, non fa mai il lavoro stesso.4model: claude-fable-5 # passa a opus se le regole di retention mordono5effort: high6tools: Read, Grep, Glob # può leggere, non può mai modificare7---89Sei il consulente esperto, non l'appaltatore. Un modello più economico sta guidando e ha colpito un muro. Il tuo valore è il giudizio in grammi, e il contesto pulito: non sai nulla di come il driver sia arrivato qui, motivo per cui la tua lettura è più acuta.1011Ricevi un brief: OBIETTIVO, gli ultimi due TENTATIVI e l'ERRORE. Se il brief nomina file specifici, puoi leggerli. Non puoi modificare nulla.1213 1. Se al brief manca qualcosa di cui hai bisogno, rispondi con UNA riga che nomina cosa manca. Non indovinare intorno a un buco.14 2. Diagnostica prima di prescrivere: una o due frasi su cosa c'è effettivamente che non va.15 3. Poi rispondi in questo formato e nient'altro dopo:16 INDICAZIONE:17 1. (correzione più probabile: cosa provare, e perché dovrebbe funzionare)18 2. (fallback se 1 fallisce)19 3. (solo se esiste un terzo percorso genuinamente distinto)20 CONFIDENZA: alta | media | bassa21 4. Sotto i 600 token. Nessun blocco di codice oltre le 10 righe. Dai l'idea, non l'implementazione. Se la tua risposta contiene una soluzione completa, hai fallito il ruolo.22 5. Se l'attività stessa è mal concepita, dillo nel punto 1 e raccomanda cosa dire all'umano.2324Nota per l'operatore: se la tua organizzazione non può accettare la retention di classe Mythos, cambia la riga del modello in opus. Il ruolo funziona allo stesso modo; il risultato dell'advisor è stato dimostrato per la prima volta con advisor di classe Opus.
E lo stesso canale al contrario per le sessioni Codex, ~/.codex/prompts/fable-advice.md:
1claude --model claude-fable-5 -p "Sei un consulente esperto.2 Un modello più economico sta guidando ed è bloccato. BRIEF: <obiettivo, due3 tentativi, errore>. Rispondi INDICAZIONE: fino a 3 elementi numerati,4 sotto i 600 token. Non fare il lavoro."
I modelli piccoli sono troppo sicuri di sé, quindi l'harness osserva il comportamento invece di chiedere.
Il brief rimane minuscolo, perché il valore dell'esperto è il contesto pulito e un brief lungo lo avvelena.
Ogni consultazione consuma poche centinaia di token di indicazioni. Ecco perché l'economia crolla: milioni di esecuzione viaggiano sul tier da $1, e il giudizio arriva a grammi a $50 per milione.
Cognition ha pubblicato il fallimento per primo. Il limite è posto dal driver, non dall'advisor, e lo schema ha ripagato solo dopo che il loro driver è migliorato di una generazione.
Il problema aperto è un driver che si accorge di essere bloccato. Ecco perché i segnali sopra sono comportamentali, e perché vivono nell'harness.
CHECK 5: advisor_loop.py supera le sue asserzioni: il driver fallisce due volte allo stesso modo, una consulenza si attiva, l'attività viene completata, le consulenze rimangono sotto il limite.
BUILD 6: The Two-Lane Bench
Niente valuta i propri compiti è una legge, e questa build la impone tra fornitori diversi.
Stessi pesi in un harness esterno calano duramente. Una misurazione del 2026 ha mostrato 20,2 percento nativo contro 7,7 percento di terze parti.
Quindi ogni revisore gira nella propria casa. Claude revisiona in Claude Code. Sol revisiona tramite la CLI di Codex.
Il giudice interno, .claude/agents/fresh-eyes-reviewer.md:
1---2name: fresh-eyes-reviewer3description: Revisore con contesto pulito. Invocarlo dopo qualsiasi modifica scritta da un agente.4 Non condivide alcuna cronologia con l'autore, legge il diff da solo, non può modificare.5model: haiku # passa a opus quando il diff è critico6effort: medium7tools: Read, Grep, Glob, Bash8---910Non hai memoria di come sia stata scritta questa modifica, ed è proprio questo il punto. Non chiedere11il ragionamento dell'autore. Non fidarti di alcun riassunto. Solo evidenze.1213 1. git diff HEAD~1 (o l'intervallo indicato) e leggi ogni hunk.14 2. Leggi il CONTENUTO COMPLETO di ogni file toccato, non solo gli hunk. I bug si nascondono15 nelle righe non modificate intorno a una modifica.16 3. Esegui la suite di test indicata nel README o in CLAUDE.md.17 4. Caccia i tre classici fallimenti degli agenti:18 pigrizia: implementazioni parziali, TODO, gestito per un solo caso19 auto-valutazione: test indeboliti, asserzioni cancellate, suite saltate20 deriva: modifiche al di fuori dell'ambito del compito dichiarato21 5. Verdetto, esattamente in questo formato:22 VERDETTO: APPROVATO o RESPINTO23 BUG: numerati, ciascuno con file:riga e un motivo in una frase24 RISCHIO: una frase sulla cosa più rischiosa che questa modifica tocca2526Regole ferree: non puoi modificare file, non puoi rieseguire il compito dell'autore, e una27lista BUG vuota con VERDETTO: RESPINTO non è valida. Se i test non possono essere eseguiti, è un28RESPINTO automatico con il motivo.
Il giudice cross-vendor, .claude/agents/sol-reviewer.md, è un canale che esegue un comando e trasmette il verdetto letteralmente. Sol è il revisore; questo file lo inserisce nel suo proprio ambiente:
1---2name: sol-reviewer3description: Revisore cross-vendor. Invia l'ultimo commit a GPT-5.6 Sol tramite4 Codex CLI, nell'ambiente nativo di Sol, e trasmette il verdetto intatto.5model: haiku # solo canale. Sol è il revisore.6effort: low7tools: Bash, Read8---910Sei un canale, non il revisore. I modelli di una stessa famiglia condividono punti ciechi; questo11canale esiste perché Sol non condivide quelli di Claude.1213 1. Controlla la CLI: codex --version. Se manca, emetti VERDETTO: RESPINTO con motivo14 "codex CLI non installato" più il percorso di installazione (o il plugin ufficiale:15 /plugin marketplace add openai/codex-plugin-cc, /plugin install, /codex:review).16 2. Esegui la revisione a massimo impegno, nell'ambiente nativo di Sol:1718 codex --profile deep exec "Revisiona l'ultimo commit (git show HEAD) come un19 ingegnere senior ostile che non ha mai incontrato l'autore. Leggi ogni file20 toccato PER INTERO, non solo gli hunk. Caccia: implementazioni parziali, test21 indeboliti o cancellati, modifiche al di fuori dell'ambito del compito dichiarato. Termina con22 esattamente 'VERDETTO: APPROVATO' o 'VERDETTO: RESPINTO' seguito da risultati numerati,23 ciascuno con file:riga e un motivo in una frase."2425 3. Salva l'output completo in .review_sol_<hash-breve>.md.26 4. Trasmetti verso l'alto: prima la riga VERDETTO, poi i risultati LETTERALMENTE. Non27 riassumere i risultati, non aggiungere rassicurazioni, non discutere con Sol.28 Se il verdetto è RESPINTO, il genitore decide cosa sistemare. Tu non decidi nulla.2930Regole ferree: mai modificare file, mai rieseguire il compito dell'autore, mai sostituire31la tua propria revisione. Se codex va in errore a metà, segnalalo come RESPINTO con stderr allegato,32piuttosto che riprovare silenziosamente più di una volta.
Per CI, loop/two_lane.sh gestisce l'intero scambio, massimo tre round:
1claude -p "Implementa: $TASK. Esegui i test. Fai commit quando è verde."2review=$(codex exec "Revisiona HEAD ... VERDETTO: APPROVATO o RESPINTO più risultati.")3grep -q "VERDETTO: APPROVATO" <<< "$review" && exit 04claude -p "Un revisore di un'altra famiglia di modelli ha trovato questi problemi.5 Sistemali tutti, riesegui i test, fai commit: $review"
All'interno di Claude Code puoi saltare completamente lo script.
OpenAI ha rilasciato un plugin Codex ufficiale per Claude Code, disponibile da marzo 2026 e con circa ventimila stelle GitHub in nove settimane. Il mercato ti dice che la revisione cross-vendor è diventata mainstream. Installa una volta:
1/plugin marketplace add openai/codex-plugin-cc2/plugin install codex@openai-codex3/codex:setup
Tre comandi in qualsiasi sessione di Claude:
- /codex:review per un passaggio standard
- modalità adversarial, che attacca intenzionalmente le tue scelte progettuali
- handoff in background a Codex
Usa la modalità adversarial su tutto ciò che è critico. Usa handoff quando il lavoro è pesante sul terminale, dove Sol è più forte.
Un numero crescente di sviluppatori ora esegue GPT-5.6 Sol all'interno di Claude Code, tramite il proxy di BUILD 7, e lo preferisce a Codex per il lavoro quotidiano.
Dimostra la tesi: noleggia i pesi, possiedi l'ambiente.
Il problema è la legge dell'ambiente nativo, poiché Sol in Claude Code viene eseguito al di fuori del suo ambiente domestico. Verificalo sul tuo set di valutazione. Se le tue valutazioni dicono che l'ambiente estraneo vince, le tue valutazioni superano il benchmark.
Tre proprietà rendono il revisore degno di essere utilizzato:
- Contesto pulito. Arriva senza alcuna cronologia dello scrittore.
- Lignaggio diverso. Non condivide i punti ciechi dello scrittore.
- Ambiente nativo. Giudica a piena potenza.
Un verdetto addolcito è un verificatore rotto, quindi la trasmissione è letterale. Un terzo RESPINTO fa intervenire un umano invece di tentare una quarta volta.
CHECK 6: esegui two_lane.sh, oppure /codex:review sul tuo ultimo commit. Un VERDETTO finisce in un file .review, e un RESPINTO torna al canale dello scrittore.
BUILD 7: Fan-out opzionali (installa quando si presenta la condizione)
Sciame di esploratori. Installa quando la ricerca o l'archeologia del codice consuma più di 30 minuti della tua giornata. Avvia tre in parallelo su sezioni separate:
1---2name: scout3description: Lettore parallelo economico per fan-out di ricerca. Avviane diversi contemporaneamente4 per sondaggi del codebase, audit delle dipendenze, archeologia dei log, ricerca documentale.5 Solo lettura per dottrina; le letture si espandono, le scritture rimangono single-threaded.6model: haiku7effort: low # guardia di ereditarietà (BUILD 4): uno sciame che eredita8 # lo sforzo massimo svuota una finestra in un messaggio9tools: Read, Grep, Glob, Bash10---1112Sei uno di molti lettori che potrebbero essere in esecuzione in parallelo. Sonda la tua sezione e13riferisci in modo piccolo e mirato. Solo il tuo messaggio finale torna al genitore, quindi14mantienilo sotto le 400 parole e fai sì che ogni parola si guadagni il suo posto.1516 1. Restringi il tuo compito a una sezione da solo (una directory, un sottosistema,17 una domanda) e di' a cosa ti sei limitato.18 2. Solo letture: Read, Grep, Glob e shell in sola lettura (ls, git log, git show, rg).19 Mai modificare, installare o cancellare. Se il compito richiede una scrittura, segnalalo, non20 farlo.21 3. Ampiezza prima, poi profondità sui due o tre punti più caldi.2223Formato del rapporto, nient'altro:24 RISULTATI: fino a 10 punti elenco, ciascuno un fatto con la sua evidenza (file:riga, hash25 del commit o URL)26 LACUNE: cosa non hai potuto determinare e perché, così il genitore sa cosa è ancora oscuro27 PUNTO CALDO: il singolo file o funzione che merita maggiormente un'analisi approfondita, una riga28 sul perché2930Non fare commenti, non proporre implementazioni, non aggiungere riempitivi. Un esploratore che31restituisce 300 parole utili batte uno che ne restituisce 3.000 miste, perché32tutto ciò che emetti finisce nella finestra di contesto del genitore e il genitore lo paga.
Le letture si espandono perché i lettori paralleli si moltiplicano. Il limite di parole esiste perché ogni rapporto finisce in una finestra di contesto che il genitore paga.
Le scritture non si espandono mai. Uno studio del 2026 a parità di budget ha scoperto che gli agenti singoli eguagliano le configurazioni multi-agente sul ragionamento quando i token sono mantenuti costanti. Questo canale è solo per la lettura.
Burner notturno. Installa quando TASKS.md contiene dieci o più elementi piccoli e verificabili. La skill del burner notturno imposta i file, conferma entrambi i limiti, verifica che il comando di test funzioni, quindi avvia ralph.sh. Interfaccia mattutina: git log, progress.log, segni di spunta.
Divisione del piano. Installa quando i token di pianificazione dominano il conto di una sessione. Un'impostazione in Claude Code esegue un modello di classe Opus per il piano e Sonnet per l'esecuzione. Pianifica sulla frontiera a grammi, esegui in blocco.
Banco di prova trio. Installa quando una modifica complessa merita tre prospettive. Due ruoli leggono e uno scrive, e il quarto pannello è una trappola. Il canale di comunicazione sta sotto.
Il canale di comunicazione per flotte miste
Due pezzi open source trasformano una configurazione a due vendor in una a vendor qualsiasi. Installali solo quando una condizione richiede un terzo fornitore.
claude-model-switch (open source, Rust, funziona su localhost:4000). Un proxy locale tra Claude Code e qualsiasi endpoint compatibile con Anthropic o OpenAI.
- Rimappa i tre livelli interni di Claude Code (haiku, sonnet, opus) su qualsiasi modello offerto dal tuo fornitore
- Cambia fornitore senza riavviare, tramite ricarica della configurazione
- Viene fornito come plugin di Claude Code con comandi slash
1claude-model-switch init # punta Claude Code al proxy2claude-model-switch add openrouter sk-or-xxx3claude-model-switch add glm \4 --haiku glm-4.5-air --sonnet glm-4.7 --opus glm-55claude-model-switch use glm # per sessione, mai a metà compito6claude-model-switch orchestrate start --preset trio # planner/coder/reviewer
Il preset trio è il banco di prova di BUILD 7 reso fisico: tre pannelli tmux, ciascun ruolo su un fornitore diverso, ciascuno indirizzabile (orchestrate send coder "implement milestone 1"), con riassegnazione del ruolo a metà sessione se un fornitore degrada.
CLIProxyAPI (open source). Lo stesso trucco, puntato nella direzione opposta.
Avvolge i login OAuth di ChatGPT Codex, Claude Code, Gemini e Grok come endpoint API compatibili con OpenAI, Claude e Gemini.
Traduzione: i posti in abbonamento che già paghi diventano target API instradabili per script come ralph.sh e two_lane.sh, senza chiavi API separate. Fork della community lo estendono a Factory e Amp, e wrapper come ccs aggiungono il cambio multi-account.
La legge che governa entrambi, dai dati di BUILD 6: un modello rimappato viene eseguito in un ambiente estraneo.
Rimappa liberamente i canali di lettura e revisione. Sono economici e verificabili.
Mantieni il canale che scrive codice su un modello nativo del suo ambiente, finché il tuo set di valutazione non dimostra il contrario.
CHECK 7: ogni fan-out installato ha la sua condizione di attivazione scritta accanto. Installare qualcosa di speculativo è così che i stack si gonfiano.
BUILD 8: La Factory (il completamento diventa un fatto di database)
Tutto ciò che è stato fatto finora dimostra il lavoro nel momento. Il gate, il verdetto e il set di valutazione scattano tutti durante l'esecuzione.
Non appena più di un agente tocca un progetto in più sessioni, hai bisogno di una prova che sopravviva all'esecuzione: chi ha lavorato a cosa, in quale ordine e se l'ultimo ciclo di revisione è stato superato.
Il modello viene dalla demo pi-factory (github.com/xpriment626/pi-factory). L'idea portante è una frase:
Un thread è una traccia. Una riga è un'evidenza. Il gate legge le righe.
progress.log è un diario. La lavagna è un registro. SQLite è il registro perché è interrogabile dopo che tutti hanno smesso di parlare.
Crea factory/factory_gate.py. Contiene quattro tabelle (tickets, briefs, evidence, verdicts), un comando di registrazione che ogni agente chiama mentre lavora e il gate di completamento. Le condizioni di fallimento del gate corrispondono al lavoro stesso:
1checks = [2 (tickets == 0, "Nessun ticket registrato."),3 (done != tickets, "Non tutti i ticket sono completati."),4 (first_brief is None, "Nessun brief architetturale registrato."),5 (first_brief > first_code, "L'evidenza di implementazione precede il brief."),6 (code_ev == 0, "Nessuna evidenza di codice implementatore registrata."),7 (build_ok == 0, "Nessuna evidenza di comando di build superato."),8 (test_ok == 0, "Nessuna evidenza di comando di test superato."),9 (latest("architect") != "green", "L'ultimo verdetto dell'architetto non è verde."),10 (latest("reviewer") != "green", "L'ultimo verdetto del revisore non è verde."),11]
Quell'elenco codifica l'intera dottrina.
- L'ordine è imposto. Un brief che è successivo alla prima evidenza di codice è una violazione, il che rende "pianifica prima di costruire" un fatto verificabile anziché un'abitudine.
- Entrambi i posti di giudice devono essere verdi sullo stesso ciclo più recente. Un'approvazione obsoleta non può sostenere un diff più nuovo.
- Il completamento con zero righe di test superati è impossibile, non importa quanto sicuro sembri il trascritto.
Crea factory/factory.sh, che collega i posti che hai già costruito nell'ordine di esecuzione e registra righe tra ogni passaggio:
1G ticket "kanban board" "colonne renderizzate, drag persiste" # righe planner2G brief "$BRIEF" # PRIMA di qualsiasi codice3../loop/ralph.sh && G evidence code pass "loop completato" # BUILD 3 funziona4npm test && G evidence test pass "npm test verde"5G verdict 1 architect green "layout corrisponde al brief" # Posto Claude6G verdict 1 reviewer green "test passano, ambito pulito" # Posto Sol, tramite codex7python3 factory_gate.py gate factory.db # le righe decidono
Non viene assunto nulla di nuovo.
Fable taglia i ticket e scrive il brief, in sola lettura. Il loop BUILD 3 implementa. Claude e Sol restituiscono ciascuno un verdetto dal proprio ambiente. Il ciclo si ripete fino a tre volte finché entrambi non diventano verdi.
La factory è l'organigramma per dipendenti che già hai.
Un'esecuzione reale, non un mockup. La seconda chiamata al gate è l'intero argomento per questa build:
1$ factory_gate.py record demo.db ticket "kanban-board" "colonne renderizzate, drag persiste"23$ factory_gate.py gate demo.db4GATE: RIFIUTATO5 - Non tutti i ticket sono completati.6 - Nessun brief architetturale registrato.7 - Nessuna evidenza di codice implementatore registrata.8 - Nessuna evidenza di comando di build superato.9 - Nessuna evidenza di comando di test superato.10 - Nessun ciclo di revisione registrato.11 exit: 11213... gli agenti lavorano. ogni passo scrive una riga ...1415$ factory_gate.py record demo.db brief "Stack: node+sqlite. /tasks CRUD."16$ factory_gate.py record demo.db evidence code pass "src/board.js scritto"17$ factory_gate.py record demo.db evidence build pass "npm run build exit 0"18$ factory_gate.py record demo.db done "kanban-board"19$ factory_gate.py record demo.db verdict 1 architect green "layout corrisponde al brief"20$ factory_gate.py record demo.db verdict 1 reviewer green "ambito pulito"2122$ factory_gate.py gate demo.db23GATE: RIFIUTATO24 - Nessuna evidenza di comando di test superato.25 exit: 12627$ factory_gate.py record demo.db evidence test pass "npm test 33/33"2829$ factory_gate.py gate demo.db30GATE: COMPLETO (1/1 ticket, ciclo 1 verde x2)31 exit: 0
Entrambi i revisori hanno detto verde. L'architetto ha confermato che il layout corrispondeva al brief. Il revisore ha confermato che l'ambito era pulito.
E il gate ha comunque rifiutato, con una riga: nessuna evidenza di comando di test superato. Nessuno aveva eseguito i test.
Un verdetto è un'opinione. Due opinioni non sono ancora un fatto. Una riga di evidenza di test superato dopo, lo stesso gate restituisce COMPLETO ed esce 0.
I modelli argomentano in modo convincente per il loro lavoro, e un trascritto cattura l'argomentazione piuttosto che la verità. Con le righe non si può discutere.
Quando il gate rifiuta, nomina l'esatto artefatto mancante. Questo trasforma "l'esecuzione è fallita" in "produce una riga di test superato." Un compito, non un mistero.
Condizione di installazione: più di una sessione di scrittura al giorno, cicli di revisione che si estendono su più giorni o la necessità di provare dopo il fatto cosa è successo. Per un repository singolo con un loop notturno, BUILD 3 è sufficiente e questo è gonfiore.
CHECK 8: riproduci lo screenshot. Registra tutto tranne una riga di test, e il gate deve rifiutare con esattamente un motivo. Aggiungi la riga e restituisce COMPLETO. Un gate che supera senza di essa è un lettore di trascritti.
BUILD 9: Lo Sciame (Fable pianifica, la flotta esegue, Fable valuta)
Un driver con un consulente copre un compito. Un obiettivo che si divide in quattro parti indipendenti vuole quattro lavoratori.
Ma una flotta mantiene la sua direzione solo se un modello pianifica ogni obiettivo e valuta ogni risultato. Questo è l'unico motivo per cui questa build esiste, e il motivo per cui gli sciami di solito falliscono senza di esso.
Il Gradino 3 reso letterale. Fable scrive gli obiettivi, la flotta li esegue, Fable valuta ogni risultato rispetto alla propria verifica, e il ciclo successivo ri-pianifica solo i mancati.
Il suo aborto è il limite di ciclo. Quando il limite scatta con mancati in sospeso, è un problema di specifica che va a un umano, non un motivo per eseguire un quarto ciclo.
Crea swarm/swarm.sh. Tre impostazioni portano la dottrina:
1FLEET=4 # le scritture non collidono mai: un worktree ciascuno2WORKER_MODEL=claude-sonnet-5 # o haiku / luna / kimi per pura esecuzione3WORKER_EFFORT=low # MAI ereditare lo sforzo del conduttore4CONDUCTOR=claude-fable-5 # o opus-4-8 se le regole di ritenzione mordono
Queste tre righe sono esplicite perché il valore predefinito non lo è.
Una flotta che eredita prende il modello del conduttore e lo sforzo del conduttore entrambi. Un Fable-alto che genera quattro Fable-alti per fare lavoro meccanico è il modo più costoso possibile per fare la cosa più economica possibile.
Impostali. Non lasciarli mai al default.
Il fan-out cross-harness è legale e non è l'eccezione alla prima legge di ROUTING.md che sembra.
- Un conduttore Fable che chiama codex exec esegue Sol all'interno di Codex, nativamente. Questa è la legge rispettata, non piegata.
- Ciò che infrange la legge è un subagente lato Claude che indossa una stringa di modello GPT, o viceversa.
L'ambiente viaggia con il lavoratore, non con il conduttore.
Il conduttore scrive obiettivi, mai codice, e ogni obiettivo porta il proprio comando di verifica, quindi "fatto" rimane un fatto:
1{"id":"strip-legacy-auth","spec":"rimuovi il percorso auth v1 da routes/","check":"npm test -- tests/auth"}2{"id":"migrate-sessions","spec":"sposta il session store nel nuovo adattatore","check":"npm test -- tests/session"}
Poi dispatch, valutazione e ri-pianificazione:
1# dispatch: un git worktree per obiettivo, limitato a FLEET in parallelo2claude --model "$WORKER_MODEL" --effort "$WORKER_EFFORT" -p "Esegui questa specifica3 esattamente. Non espandere l'ambito. Esegui i test. Fai commit solo quando è verde."45# valutazione: il conduttore valuta ogni obiettivo rispetto al proprio comando di verifica.6# la fiducia del lavoratore non è evidenza. il codice di uscita lo è.7bash -c "$chk" && echo "$id" >> passed.txt || misses=$((misses+1))89# ri-pianificazione: il ciclo successivo vede passed.txt e ri-pianifica solo ciò che ha mancato
Posto per posto:
- Sonnet 5 per l'esecuzione di codifica
- Haiku o Luna per puro lavoro meccanico
- Un lavoratore open-weight come Kimi quando il lavoro è ripetitivo e i pesi sono gratuiti
- Sol quando il lavoro è pesante sul terminale
- Opus 4.8 nel posto lavoratore, solo quando un subagente ha bisogno di ragionare
Riserva Fable per i due lavori che nessun modello economico può fare: scrivere gli obiettivi e valutarli.
Una flotta è una strategia di costo, mai una strategia di intelligenza.
Le esecuzioni multi-agente bruciano da 3 a 10 volte i token per lavoro equivalente, e uno studio del 2026 a parità di budget ha scoperto che gli agenti singoli li eguagliano sul ragionamento quando i token sono mantenuti costanti.
Uno sciame si ripaga solo quando gli obiettivi sono indipendenti e per lo più meccanici. Le scritture rimangono single-threaded per worktree, i merge avvengono in serie, e un umano prende l'ultimo commit.
CHECK 9: esegui lo sciame su un obiettivo che si divide in tre modi. Un obiettivo rotto deve tornare RESPINTO in results.tsv e venire ri-pianificato nel ciclo 2, mai dichiarato completato.
BUILD 10: Gradino 4 (nulla che è passato una volta rimane inosservato)
Tutto finora verifica il lavoro mentre viene creato. Nulla finora nota quando un lavoro finito smette di essere vero sei settimane dopo. Un obiettivo che verifichi una volta è un'ipotesi con un timestamp.
Il Gradino 4 ha due metà, e il suo aborto è importante quanto la sua uscita: se nessuna proposta supera il gate questa settimana, il sistema non cambia, e questo è un successo.
Prima metà, obiettivi permanenti. Ogni cosa finita si diploma in un invariante con un predicato, riverificato quotidianamente, per sempre. Crea un file per ogni cosa finita in goals/:
1predicate: npm test -- tests/auth 2>&1 | tail -1 | grep -q passing2born: 2026-07-133status: soddisfatto4last-pass: 2026-07-135on-violation: svegliami. non correggere automaticamente.
Poi system/verify_goals.py esegue tutto ed esce 1 se un qualsiasi invariante si è rotto, nominando l'obiettivo, la data in cui era valido l'ultima volta e la politica che hai impostato:
1held = subprocess.run(["bash","-c",predicate], timeout=60).returncode == 02g["status"] = "soddisfatto" if held else "VIOLATO"3# un timeout è una violazione, non un passaggio: un predicato costoso è rotto
Le regole del predicato sono severe di proposito: un comando shell, uscita 0 significa che l'invariante è valido, economico e in sola lettura.
Gli aggettivi sono vietati. Se una shell non può verificarlo, nemmeno un modello può.
Gli obiettivi non di codice funzionano allo stesso modo. test -s reports/$(date +%Y-%m)-review.md è un perfetto obiettivo permanente per un report mensile.
Seconda metà, compostaggio. Una volta a settimana, leggi lo scarico che il sistema ha già prodotto: attività BLOCCATE, esecuzioni del gate fallite, factory gates rifiutati, PR annullate, obiettivi violati.
Poi proponi al massimo tre cambiamenti. Una nuova legge per la costituzione. Una correzione a una skill che continua a fallire allo stesso modo. O un obiettivo permanente che ti mancava.
Proponi solo. Decidi tu.
1claude --model claude-fable-5 --effort high --allowedTools "Read,Grep,Glob" \2 -p "Leggi lo scarico di questa settimana: righe BLOCCATE in progress.log, voci GATE3 RIFIUTATO, obiettivi VIOLATI, PR chiuse non unite. Estrai AL MASSIMO 3 proposte:4 una nuova legge (cita gli incidenti), una correzione di skill (stesso fallimento che si ripete),5 o un obiettivo permanente che ci mancava. Proponi solo, non modificare nulla. Settimana pulita è6 una risposta valida, dillo e fermati."
Questo gradino si chiude solo quando le valutazioni e i giudici dicono che il sistema è migliorato. Il che significa che il sistema ha bisogno di una memoria dei propri fallimenti per migliorare.
L'esecuzione del compostaggio è ciò che trasforma uno script in un'istituzione.
Gli obiettivi permanenti sono ciò che rende sicuro il completamento. La sentinella rileva, la pipeline normale corregge, e nulla marcisce in silenzio.
CHECK 10: verify_goals.py demo nomina l'invariante rotto con la sua data di ultimo passaggio e lascia stare quello sano. Poi scrivi un obiettivo permanente reale per l'ultima cosa che hai completato.
BUILD 11: Gradino 5 (il tuo posto, e perché non è mai vuoto)
Il Gradino 5 porta il tuo nome per un motivo meccanico, non sentimentale.
Un ciclo può raggiungere la sua condizione di arresto ed essere comunque sbagliato. I test passano, il gate diventa verde, entrambi i revisori firmano, e l'ultimo commit è ancora un errore.
Ogni build al di sotto di questa esiste per ridurre quel rischio. Nessuna di esse lo elimina.
I tuoi compiti permanenti, tutti economici:
- Leggi la coda con il caffè: attività BLOCCATE, righe GATE RIFIUTATO, obiettivi VIOLATI, la quota del livello economico. Dieci minuti.
- Controlla l'ultimo commit prima che venga unito. Non ogni diff, l'ultimo, quello di cui il sistema era più sicuro.
- Firma o rifiuta le tre proposte di compostaggio. Questo è l'unico modo in cui le leggi entrano nella costituzione.
Tre mosse vengono eseguite su una cadenza piuttosto che su richiesta, perché costano soldi veri e pagano in direzione piuttosto che in diff:
Mossa uno, il ciclo di feedback del progetto, mensile.
Punta Fable su ciò che hai già spedito, in sola lettura, e fallo scrivere un piano di miglioramento dettagliato. Poi affida l'esecuzione di quel piano a Opus 4.8 o Sol.
Il modello costoso fa la parte che si accumula, il giudizio su cosa cambiare, e mai la parte che non lo fa, scrivere codice.
1claude --model claude-fable-5 --effort high --allowedTools "Read,Grep,Glob" \2 -p "Revisiona questo progetto dall'inizio alla fine. Scrivi un piano di miglioramento3 classificato per leva: cosa è fragile, cosa è sovra-costruito, cosa manca, cosa4 dovrebbe essere cancellato. Non scrivere codice. Emetti attività con criteri di5 accettazione." \6 > plans/$(date +%F)-improvement.md
Gioco due, l'analisi comportamentale, mensile.
Alimentalo con la cronologia delle tue sessioni e dei tuoi progetti su entrambi i finimenti e chiedigli di mappare come costruisci e dove ti blocchi.
Questo è l'unico report del sistema il cui soggetto sei tu. Di solito è quello che cambia di più.
Gioco tre, il controllo del secondo cervello, trimestrale. Puntalo verso le tue note, i tuoi documenti e il backlog, e chiedi cosa il tuo stesso pensiero suggerisce sia utile costruire dopo e cosa sia da eliminare. Tratta l'output come una proposta, esattamente come il compost.
I gradini sottostanti ottimizzano l'esecuzione, e l'esecuzione ora è la parte economica. La direzione è l'input scarso, e la direzione è ciò per cui vale la pena pagare un modello all'avanguardia. Compra giudizio al grammo, esecuzione alla tonnellata, e tieni l'ultima firma.
CHECK 11: esegui il gioco uno sul tuo repository. Se il piano non nomina nulla che già sapevi essere fragile, i tuoi file di contesto sono troppo sottili, il che è un problema COSTRUZIONE 1.
COSTRUZIONE 12: Operazioni
Gli agenti consumano da 10 a 100 volte i token di una chiamata in chat, e l'input domina con un rapporto di circa 100 a 1.
Impila le quattro leve di COSTRUZIONE 0 (suddivisione, cache, batch, compattazione) e i team riferiscono di raggiungere un risparmio dal 70 al 90 percento rispetto alla loro baseline non ottimizzata.
Per chiarezza: 13 dollari per sviluppatore per giorno attivo è la media enterprise di Claude Code, e il 90 percento degli utenti rimane sotto i 30 dollari.
Una riga di disciplina invece di un nuovo sottosistema: una classe di attività può eseguire il merge automatico solo dopo 20 esecuzioni registrate con un tasso di superamento del 95 percento, e un singolo calo sotto il 90 percento la revoca rumorosamente.
1awk -F'\t' '$2=="fix-lint"{r++; if($3=="pass")p++}2 END{printf "%d runs, %.0f%%\n", r, (r?p/r*100:0)}' progress.log
Spesa settimanale, dai costi per tick che ralph.sh già registra:
1grep '^cost' progress.log | awk -F'\t' \2 -v d="$(date -d '7 days ago' +%F)" \3 '$2>=d{s+=$3} END{printf "week: $%.2f\n", s}'
Calcola il metabolismo prima di programmare il cron. Il costo giornaliero è tick moltiplicato per il costo medio del tick.
Il posto che gestisce il silenzioso tick di non-lavoro decide la fattura. Centesimi sul livello economico, dollari su un modello all'avanguardia con alto impegno, per la identica risposta "niente da fare".
Lavorare entro i propri limiti
Questi modelli bruciano token velocemente, e il modo in cui li esegui decide quanto lavoro di una giornata riesci a completare prima di colpire un muro.
Prima di tutto, conosci quale muro.
- Su una chiave API, il muro è la fattura. progress.log la tiene già d'occhio.
- Su un posto in abbonamento, il muro è una finestra di cinque ore e una finestra settimanale giudicate insieme. Nessuna delle due appare da nessuna parte nel log qui sopra.
Tieni d'occhio il contatore su cui sei effettivamente: il pannello di utilizzo nelle impostazioni di Codex, /usage sul lato Claude, o un monitor come ccusage o codexbar parcheggiato nell'angolo dello schermo.
Un limite che non leggi mai è un limite che scopri colpendolo, con quattro ore rimaste sul cronometro e niente da eseguire.
Sei leve, dalla più economica. La maggior parte agisce ai gradini da 0 a 2, dove i token bruciano:
- Riduci CLAUDE.md e AGENTS.md all'essenziale. Ogni singolo prompt li legge, insieme a ogni abilità e strumento che hai attivato. Disattiva ciò che non usi; un server MCP inutilizzato è una tassa su ogni messaggio.
- Abbassa l'impegno quando non ti serve il massimo della scala. Predefinito medio o alto. Riserva il massimo per i problemi che ne hanno bisogno. E conferma che la modalità veloce sia spenta mentre ci sei, perché moltiplica qualunque livello tu scelga.
- Dai al modello punti di arresto chiari. Questi modelli sono progettati per funzionare a lungo. Chiedi loro di completare il piano e fare il check-in prima di eseguire, che è il vero lavoro della modalità piano.
- Mantieni i subagenti su un impegno più basso. Ereditano il modello del genitore e la sua manopola, e uno sciame al massimo svuota una finestra in un messaggio. La soluzione economica è una legge in entrambe le costituzioni: non generare a meno che non sia richiesto.
- Tieni il modello costoso lontano dal lavoro di massa. Che Fable stia in cima come conduttore a basso consumo di token o su chiamata come consulente, guadagna il suo prezzo nei punti decisionali, mai mentre scrive la millesima riga.
- Leggi quanto costa un messaggio, poi regola le cinque precedenti in base a quel numero. Questa è l'unica leva che ti dice quale delle altre cinque è il tuo problema.
Insieme, queste leve determinano per quanto tempo puoi eseguire i migliori modelli prima che il limite ti fermi.
Cron, quando inizia la Settimana 2:
1# task loop: the daily tick, both caps set20 7 * * 1-5 cd /path/to/repo/loop && BUDGET_USD=5 ./ralph.sh >> ../progress.log 2>&134# system loop: nothing that passed once goes unwatched530 7 * * * cd /path/to/repo && python3 system/verify_goals.py goals/ >> progress.log 2>&167# system loop: failures become laws, once a week, proposals only80 9 * * 1 cd /path/to/repo && codex --profile deep exec \9 "$(cat ~/.codex/prompts/compost.md)" >> proposals/$(date +\%F).md 2>&1
Il runbook. Ogni allarme e cosa fare al riguardo:
Il programma di 30 giorni. Non saltare le lauree; ognuna sblocca la successiva.
Il Ponte di Comando
Ogni ciclo qui è raggiungibile con una combinazione di tasti. I comandi slash vivono in ~/.codex/prompts/ sul lato Codex, dove il nome del file diventa il comando, e in .claude/skills/ sul lato Claude. Gli snippet CLI sono le versioni headless che cron e CI eseguono.
Comandi slash di Codex
/plan-stop e /effort si ripagano più velocemente. Entrambi spendono poche centinaia di token per impedirti di spenderne poche centinaia di migliaia.
Questi modelli funzionano a lungo, quindi il checkpoint che desideri arriva prima della spesa. /plan-stop restituisce il piano, i comandi di completamento, il raggio di esplosione, il costo e l'unica domanda che farebbe a un umano. Poi si ferma.
Metti entrambi i file in ~/.codex/prompts/, dove il nome del file diventa il comando.
effort.md diventa /effort, il selettore di instradamento reso esplicito:
1# /effort - choose the effort level before you spend it23Do not answer the task yet. Route it first.45Score it. One point each:6 - contains a why, a debug, a race, a deadlock, a refactor, a security concern,7 or an optimize8 - touches more than one subsystem9 - a previous attempt already failed10 - the change is irreversible or lands in front of users1112Then map:1314| Score | Effort | Seat |15|---|---|---|16| 0-1 | low | codex -e low, or profile fast (Luna). Never put a frontier seat on it. |17| 2 | medium | Terra at medium is the seat. |18| 3+ | high | the default for real work, and where the sweet spot sits. |1920Only if high has ALREADY been tried and failed: recommend max, and say plainly21what the extra thinking is expected to buy. The base rate you are arguing22against is roughly double the cost for a gain that usually does not repay.2324Two reminders before recommending an upgrade:25 1. A better model at lower effort usually beats a weaker model at max. Change26 the seat before the dial.27 2. If this task spawns subagents, state their effort explicitly (low unless28 proven otherwise). Subagents inherit the parent, and a fleet at max empties a29 context window in one message.3031Output exactly:32 EFFORT: low | medium | high | max33 SEAT: <model>34 WHY: <one line, naming the points that scored>35 SUBAGENTS: <effort to pin, or none>36Then stop. The human runs the task at the level you named.
Una risposta dal vivo assomiglia a questa, e costa poche centinaia di token per evitarne poche centinaia di migliaia:
1EFFORT: high2SEAT: gpt-5.6-sol3WHY: contains "why", touches auth and sessions, prior attempt failed4SUBAGENTS: low
plan-stop.md diventa /plan-stop, il checkpoint prima della spesa:
1# /plan-stop - plan the work, then stop23These models run long. That is a feature when the plan is right and an expensive4way to be wrong when it is not. This command buys the checkpoint before the spend.56Plan the task. Do not edit a single file. Do not run a build. Do not start.78Produce:9 GOAL: <one line>10 ASSUMPTIONS: <what you take for granted; if these are wrong, so is the plan>11 STEPS: <numbered, each one commit's worth of work>12 DONE_WHEN: <the exact shell command that proves each step landed>13 BLAST RADIUS: <files and systems touched; name auth, payments, migrations, prod14 config explicitly>15 COST: <rough tokens or dollars, and which seat runs each step>16 UNKNOWNS: <what you would ask a human if you could ask exactly one question>1718Then stop and wait.1920Rules while planning:21 - Ambiguity goes in UNKNOWNS. Do not resolve it by guessing and proceeding. A22 guess that survives into execution costs a hundred times more than a question.23 - If the plan needs a credential, endpoint, or convention that is not written24 down in this repo, stop and say so. Never invent one.25 - If any DONE_WHEN is not a shell command, rewrite that step until it is. If a26 shell cannot check it, neither can a reviewer.27 - If the blast radius touches the never-list in AGENTS.md, say so at the top and28 recommend queueing for a human.2930You are paid for the plan here, not the diff. A short honest plan with real31unknowns beats a confident plan that quietly assumed the wrong thing.
fable-advice.md e review-hostile.md diventano /fable-advice e /review-hostile. Entrambi sono gli specchi lato Codex di file che hai già scritto: il brief del consulente di COSTRUZIONE 5 e il contratto del revisore ostile di COSTRUZIONE 6. Stesse regole, stessi limiti, puntati dall'altra parte della linea del fornitore.
compost.md diventa /compost, il costruttore settimanale di istituzioni del gradino 4:
1# /compost - turn this week's failures into next week's laws23Read this week's exhaust, all of it, and nothing else:4 - BLOCKED lines in progress.log (tasks that beat three advisor consults)5 - GATE: REFUSED entries (a run that could not prove it was done)6 - VIOLATED standing goals (something finished stopped being true)7 - circuit-breaker and budget exits (codes 2 and 3)8 - PRs opened by the loop and closed unmerged (the human silently disagreed)9 - any task class whose pass rate dropped below 90 percent1011Extract AT MOST three proposals. Three is a hard cap, not a target. A clean week is12a valid finding, and saying so is more useful than manufacturing work.1314Each proposal is exactly one of:15 1. A NEW LAW for CLAUDE.md or AGENTS.md. Quote the incidents it would have16 prevented. A law with one incident behind it is a coincidence; wait for the17 second.18 2. A SKILL FIX, when the same failure repeats in the same place. Name the skill,19 the pattern, and the smallest edit that breaks it.20 3. A STANDING GOAL you were missing, when something rotted silently. Write the21 predicate as a shell command, or do not propose it.2223Output:24 WEEK: <dates>25 EXHAUST: <counts: blocked, refused, violated, reverted>26 PROPOSAL n: <law | skill fix | standing goal>27 EVIDENCE: <the incidents, quoted>28 CHANGE: <the exact text or predicate to add>29 COST OF NOT DOING IT: <one line>30 VERDICT: <what you would do first if you could only do one>3132Hard rules:33 - Propose ONLY. Do not edit CLAUDE.md, AGENTS.md, any skill, or any goal file.34 The human signs, or it does not happen.35 - Do not propose a law that softens a gate, raises a budget, or relaxes a never.36 Those are the system asking to be allowed to fail more comfortably.37 - Empty exhaust: say "clean week" and stop. Do not go looking for work to justify38 the run.
Snippet CLI
Tienili in un file di appunti. Sono l'intero sistema raggiungibile da un terminale:
1# the daily tick, capped in both dimensions2BUDGET_USD=5 MAX_ITERS=20 ./loop/ralph.sh34# plan first, spend later (the single highest-leverage habit here)5codex -e high exec "$(cat ~/.codex/prompts/plan-stop.md)67TASK: migrate the session store off the legacy adapter"89# cross-vendor review of the last commit, in Sol's native harness10codex --profile deep exec "$(cat ~/.codex/prompts/review-hostile.md)"1112# the mirrored lane: Codex stuck, Claude advises13claude --model claude-fable-5 --effort high -p "$(cat ~/.codex/prompts/fable-advice.md)"1415# the goal loop: Fable plans, the fleet runs, Fable scores16CYCLES=3 FLEET=4 WORKER_EFFORT=low ./swarm/swarm.sh "split the auth migration"1718# the system loop: nothing that passed once goes unwatched19python3 system/verify_goals.py goals/ # exit 1 names what rotted20python3 gate/eval_gate.py eval/cases.jsonl # exit 1 blocks the routing change2122# rung 3, the factory: rows decide, not transcripts23./factory/factory.sh "build the kanban and notes app per PRD.md"24python3 factory/factory_gate.py gate factory.db2526# the weekly institution-building run27codex --profile deep exec "$(cat ~/.codex/prompts/compost.md)"2829# the one number that says whether any of this worked30grep '^route' progress.log | awk -F'\t' \31 '{n++; if($3!="frontier") c++} END{printf "cheap share: %.0f%%\n", c/n*100}'
La politica completa vive in ROUTING.md di COSTRUZIONE 4, che entrambi i finimenti leggono.
Le Regole (stampa questo)
- Leggi, non suggerimenti: un numero, un mai, o un comando che lo verifica.
- Il modello è a noleggio. Il ciclo è tuo. Tu vivi al gradino 5.
- Un ciclo senza interruzione è una fattura. Due limiti su ognuno: iterazioni e dollari.
- Le prove fluiscono verso l'alto, il controllo fluisce verso il basso. Nessun gradino si chiude su un rapporto proveniente da sotto di esso.
- Un ciclo può fermarsi ed essere comunque sbagliato. Controlla l'ultimo commit prima che esegua il merge.
- Instrada ai confini. Impegno prima del modello. La cache vota contro il cambio.
- Predefinito ad alto. Massimo è profondità, ultra è larghezza, la modalità veloce è una tassa di 2,5x, e i subagenti ereditano sia il posto che la manopola del genitore.
- Il router è colpevole finché non batte il miglior modello singolo nelle tue valutazioni.
- I risparmi sono la ripartizione del traffico. Controlla la quota economica, non il listino prezzi.
- L'esecuzione è all'ingrosso, i consigli sono al dettaglio. Limita le consulenze a tre.
- Niente valuta il proprio compito. Contesto fresco, altra discendenza, finimento nativo.
- Un thread è una traccia. Una riga è una prova. Il cancello legge le righe.
- Non modificare mai un test per superarlo. Non fare mai il merge oltre un cancello BLOCCATO.
- Un obiettivo che verifichi una volta è un'ipotesi con una marca temporale.
- Una laurea alla volta. Ogni mese, elimina qualcosa.
Conclusione
Tra trenta giorni, se hai fatto i controlli:
- Un ciclo spedisce lavoro noioso in autonomia, dietro un cancello deterministico
- Un driver economico chiama un esperto all'avanguardia solo quando si blocca
- Ogni differenza significativa viene giudicata da un modello che non l'ha scritta
- Un numero in progress.log ti dice se l'economia sta dando i suoi frutti
I modelli non sono mai stati la parte difficile. Un sistema che rimane onesto quando smetti di guardare è la parte difficile, ed è per questo che il gradino 5 ha ancora il tuo nome sopra.
Inizia stasera con i venti minuti che lo dimostrano. Il verify.sh di COSTRUZIONE 2. Un tick eseguito a mano di COSTRUZIONE 3. Una revisione dall'altra discendenza sul tuo ultimo commit.
La prima volta che un revisore che non condivide alcun contesto con lo scrittore trova un vero bug in un lavoro che eri sicuro fosse finito, non avrai bisogno di essere convinto del resto.
Costruisci il cancello stasera. Rispondi con cosa ha intercettato al primo tentativo.
Disclaimer
Scritto a partire dagli appunti di ricerca dell'autore e da fonti verificate, con assistenza per la stesura e la verifica dei fatti da Claude. Tutti i prezzi e i comportamenti dei modelli sono stati verificati rispetto alle pagine di prezzi e documentazione ufficiali nella settimana di pubblicazione; cambiano, quindi verifica prima di fare budget.
Questo articolo è stato scritto a partire dagli appunti dell'autore come menzionato nel paragrafo precedente e modificato con Claude Opus 4.7.
Se desideri aggiungere altre correzioni, aggiungile nei commenti.
![Le geniali tecniche di utilizzo dell'IA di Yusuke Narita [Edizione da conservare]](/cdn-cgi/image/width=1920,quality=90,format=auto,metadata=none/https%3A%2F%2Fcms-assets.youmind.com%2Fmedia%2F1784137658627_u4bwry_HNMS89bbsAAUPJI.jpg)
