Hai spiegato a Codex tre volte come si lanciano i test del tuo progetto, e alla quarta ha di nuovo provato il comando sbagliato. Il problema non è la memoria dell'agente ma dove hai scritto la regola: Codex ha due posti per le regole stabili, e hanno poteri diversi. AGENTS.md contiene istruzioni in linguaggio naturale (come si costruisce il progetto, quali convenzioni seguire, cosa non toccare) che il modello legge e può seguire male; config.toml contiene impostazioni (modello, sandbox, approvazioni, ricerca web) che il programma applica. Secondo la documentazione letta il 13 novembre 2026, Codex costruisce la catena di AGENTS.md dalla radice del progetto fino alla cartella corrente, e i file più vicini a dove lavori vengono dopo e quindi prevalgono; per config.toml vince, in ordine, la riga di comando, poi il file di progetto (solo se il progetto è fidato), poi il profilo, poi il tuo file utente. Il costo da tenere presente: ogni riga di AGENTS.md entra nel contesto a ogni sessione, e c'è un tetto di byte.
Metodo e limiti. Non sono affiliato a OpenAI. Non ho eseguito Codex: ho letto le pagine ufficiali il 2026-11-13 e ho scritto due piccoli programmi miei che modellano le regole che descrivono, per vederle all'opera su file di prova. Entrambi sono stati eseguiti due volte con la stessa uscita (Python 3.14, Linux); non sono il motore di Codex e dove la documentazione si contraddice lo dico.
La differenza che evita metà degli errori
Un'istruzione in AGENTS.md è un consiglio; un valore in config.toml è un vincolo. Se vuoi che l'agente non scriva fuori dal workspace, non scriverlo in AGENTS.md: imposta sandbox_mode = "workspace-write" (la parte 3 spiega perché). Se vuoi che usi pnpm e non npm, quello è un consiglio e va in AGENTS.md. La regola pratica è: ciò che deve valere sempre sta nel programma, ciò che aiuta a lavorare bene sta nel testo. Un esempio che lo mostra: «non toccare la cartella db/migrations/» in AGENTS.md è una preghiera, mentre una regola di sola lettura su quella cartella in un profilo di permessi (la pagina Permissions, in beta, mostra regole read e deny per percorso) sarebbe un vincolo; la prima si può ignorare per distrazione, la seconda no.
Come Codex trova AGENTS.md
La pagina dedicata descrive una catena costruita una sola volta per esecuzione (nella TUI, di norma una volta per sessione avviata), in due ambiti più una fusione.
- Ambito globale. Nella cartella home di Codex (
~/.codex, oppure quella indicata daCODEX_HOME) leggeAGENTS.override.mdse esiste, altrimentiAGENTS.md, e usa solo il primo file non vuoto di questo livello. - Ambito di progetto. Parte dalla radice (di norma la radice Git) e scende fino alla cartella corrente; in ogni cartella controlla
AGENTS.override.md, poiAGENTS.md, poi i nomi inproject_doc_fallback_filenames, includendo al massimo un file per cartella. Senza una radice di progetto controlla solo la cartella corrente. - Fusione. I file sono concatenati dalla radice verso il basso, separati da righe vuote; quelli più vicini alla cartella corrente compaiono dopo e quindi prevalgono.
L'ordine qui conta: il file globale viene prima di tutti, quello della cartella più profonda per ultimo, e la prevalenza è una conseguenza della posizione nel testo, non di un meccanismo di sostituzione. Gli esempi della pagina: ~/.codex/AGENTS.md per le tue preferenze personali, AGENTS.md alla radice per le norme del repository, services/pagamenti/AGENTS.override.md per un'area con regole proprie. L'override ha la precedenza sul file base nella stessa cartella ed è il modo per sostituire una guida senza cancellarla: nell'albero d'esempio della documentazione, l'AGENTS.md dei pagamenti è ignorato perché esiste il suo override. Dopo aver cambiato questi file, riavvia Codex: la catena si ricostruisce all'avvio.
Il tetto di byte e il file che resta fuori
La pagina dice che Codex salta i file vuoti e smette di aggiungere file quando la dimensione combinata raggiunge il limite project_doc_max_bytes, che vale 32 KiB per impostazione predefinita. Il rischio è silenzioso: l'ordine di lettura va dal generale allo specifico, quindi a restare fuori sono i file più in profondità, cioè i più specifici. Per vederlo senza lanciare Codex ho scritto un modello di quella regola. La funzione catena parte dalla radice (la cartella che contiene .git), scende fino alla cartella corrente, sceglie in ciascuna il primo file non vuoto fra override, AGENTS.md e i nomi di riserva, e smette di aggiungere file quando il totale ha raggiunto il limite. L'albero è costruito in una cartella temporanea: un file globale, uno alla radice, uno per ogni servizio, e un TEAM_GUIDE.md sotto docs/.
"""Quali file di istruzioni leggerebbe l'agente, e in che ordine? Un modello della regola documentata.
Regole prese dalla pagina AGENTS.md della documentazione di Codex (consultata il
2026-11-13): ambito globale (override, altrimenti AGENTS.md, il primo non vuoto);
ambito di progetto dalla radice alla cartella corrente, un solo file per cartella
(override, AGENTS.md, poi i nomi di riserva); file concatenati dalla radice in giu';
si smette di aggiungere file quando la dimensione combinata raggiunge il limite.
Non e' Codex: e' il modo per vedere il tetto all'opera.
"""
import tempfile
from pathlib import Path
def trova_radice(cwd, marcatori=(".git",)):
for cartella in (cwd, *cwd.parents):
if any((cartella / m).exists() for m in marcatori):
return cartella
return None
def primo_non_vuoto(cartella, nomi):
for nome in nomi:
f = cartella / nome
if f.is_file() and f.stat().st_size > 0:
return f
return None
def catena(codex_home, cwd, riserva=(), limite=32 * 1024):
candidati = []
globale = primo_non_vuoto(codex_home, ("AGENTS.override.md", "AGENTS.md"))
if globale:
candidati.append(globale)
radice = trova_radice(cwd)
percorso = [cwd]
if radice is not None:
scendi = [cwd, *[p for p in cwd.parents if p.is_relative_to(radice)]]
percorso = list(reversed(scendi))
for cartella in percorso:
f = primo_non_vuoto(cartella, ("AGENTS.override.md", "AGENTS.md", *riserva))
if f:
candidati.append(f)
inclusi, totale = [], 0
for f in candidati:
if totale >= limite:
break
inclusi.append(f)
totale += f.stat().st_size
return inclusi, candidati[len(inclusi):], totale
def prepara(base):
home, repo = base / "codex_home", base / "repo"
file = {
home / "AGENTS.md": "Preferisco pnpm.\n",
repo / "AGENTS.md": "Esegui pnpm lint prima di ogni PR.\n",
repo / "docs/TEAM_GUIDE.md": "Guida della documentazione (nome di riserva).\n",
repo / "services/pagamenti/AGENTS.md": "Test: pnpm test.\n",
repo / "services/pagamenti/AGENTS.override.md": "Test: make test-pagamenti.\n",
repo / "services/ricerca/AGENTS.md": "Test: pnpm --filter ricerca test.\n",
}
(repo / ".git").mkdir(parents=True)
for percorso, testo in file.items():
percorso.parent.mkdir(parents=True, exist_ok=True)
percorso.write_text(testo)
return home, repo
def mostra(titolo, base, risultato):
inclusi, esclusi, totale = risultato
rel = lambda f: str(f.relative_to(base))
print(titolo)
print(" letti :", " > ".join(rel(f) for f in inclusi))
print(" esclusi :", ", ".join(rel(f) for f in esclusi) or "nessuno", f"({totale} byte letti)")
if __name__ == "__main__":
with tempfile.TemporaryDirectory() as t:
base = Path(t)
home, repo = prepara(base)
mostra("da services/pagamenti", base, catena(home, repo / "services/pagamenti"))
mostra("da services/ricerca", base, catena(home, repo / "services/ricerca"))
mostra("da docs, senza nomi di riserva", base, catena(home, repo / "docs"))
mostra("da docs, con TEAM_GUIDE.md fra i nomi di riserva", base,
catena(home, repo / "docs", riserva=("TEAM_GUIDE.md",)))
mostra("da services/pagamenti, limite 40 byte", base,
catena(home, repo / "services/pagamenti", limite=40))
# Comando: python3 -I catena_agents.py
# Output:
# da services/pagamenti
# letti : codex_home/AGENTS.md > repo/AGENTS.md > repo/services/pagamenti/AGENTS.override.md
# esclusi : nessuno (79 byte letti)
# da services/ricerca
# letti : codex_home/AGENTS.md > repo/AGENTS.md > repo/services/ricerca/AGENTS.md
# esclusi : nessuno (86 byte letti)
# da docs, senza nomi di riserva
# letti : codex_home/AGENTS.md > repo/AGENTS.md
# esclusi : nessuno (52 byte letti)
# da docs, con TEAM_GUIDE.md fra i nomi di riserva
# letti : codex_home/AGENTS.md > repo/AGENTS.md > repo/docs/TEAM_GUIDE.md
# esclusi : nessuno (98 byte letti)
# da services/pagamenti, limite 40 byte
# letti : codex_home/AGENTS.md > repo/AGENTS.md
# esclusi : repo/services/pagamenti/AGENTS.override.md (52 byte letti)
Tre cose da leggere nell'uscita. Dalla cartella dei pagamenti la catena è globale, radice, override dei pagamenti: l'AGENTS.md accanto all'override non viene letto, come nell'esempio della documentazione. Da docs, il nome TEAM_GUIDE.md entra nella catena solo se è elencato nei nomi di riserva; senza, la cartella contribuisce con niente. Con un limite di 40 byte (volutamente minuscolo) i primi due file superano il tetto, e il file dei pagamenti, il più specifico, non viene letto. Una precisazione onesta sulla fonte: la pagina su AGENTS.md parla di dimensione combinata, mentre la pagina di riferimento descrive project_doc_max_bytes come i byte letti da AGENTS.md e la pagina di configurazione avanzata come quanto leggere da ciascun file. Il modello segue la prima lettura; per sapere come si comporta la tua versione, controlla quali file risultano caricati con il metodo di verifica della pagina (si veda più sotto).
Le due strade, se raggiungi il tetto, sono alzare il limite oppure, meglio, spezzare le regole in file annidati, ciascuno breve e legato alla sua area. Anche senza arrivare al tetto, un file enorme ha un costo: ogni parola è contesto che l'agente rilegge a ogni sessione e che compete con il codice del compito. Per verificare che cosa Codex abbia caricato, la documentazione propone di avviare da una cartella annidata con codex --cd services/pagamenti --ask-for-approval never "List the instruction sources you loaded.", oppure di attivare il registro testuale con codex -c log_dir=./.codex-log e leggere ./.codex-log/codex-tui.log. Entrambe le prove coinvolgono il modello e non le ho eseguite.
Che cosa scrivere in un buon AGENTS.md
/init ne genera una bozza, ma la pagina Best practices avverte che va rivista per rispecchiare il modo in cui il tuo team costruisce e verifica il progetto. Un file utile risponde, secondo quella pagina, a domande di questo tipo:
- Com'è fatto il repository e quali cartelle contano.
- Come si esegue il progetto e quali sono i comandi di build, test e lint, scritti per intero.
- Quali convenzioni e quali aspettative sulle PR non si leggono dal codice.
- Quali vincoli e quali «non fare» valgono.
- Che cosa significa «finito» e come si verifica.
Nessuna voce prevale sulle altre, ma a queste io aggiungerei una sezione che la pagina non elenca: le trappole che sono già costate tempo a qualcuno del team, perché sono l'unica informazione che il codice non contiene. Scrivere «esegui i test» non serve; scrivere il comando esatto e il modo in cui fallisce quando manca una dipendenza, sì. Lo schema seguente è un esempio mio da adattare, non l'ho dato a Codex e non è stato eseguito.
# AGENTS.md (schema da adattare)
## Build e test
- Installa: `pnpm install`
- Test dell'API: `pnpm --filter api test`
- Il lint fa parte del «finito»: `pnpm lint` deve passare.
## Convenzioni
- TypeScript strict; niente `any` senza un commento che spieghi perché.
- Un commit per cambiamento logico, formato `tipo(ambito): oggetto`.
## Non toccare
- `src/generated/`: si rigenera con `pnpm codegen`.
- Le migrazioni già presenti in `db/migrations/`: se ne aggiunge una nuova.
## Trappole note
- I test di integrazione richiedono Postgres su localhost:5432; senza, falliscono per timeout e non con un errore chiaro.
Che cosa non scrivere: descrizioni generiche come «scrivi codice pulito», ciò che il modello sa già, e soprattutto qualunque regola di sicurezza che il programma non applica. Se una frase comincia con «non devi mai», chiediti se non appartiene a config.toml o a uno script di controllo. Per la revisione del codice su GitHub la documentazione prevede una sezione ## Code Review Rules nell'AGENTS.md più vicino al codice interessato: regole del repository alla radice, regole di servizio in un file annidato.
config.toml: dove vive e chi vince
La documentazione indica tre posizioni:
- Utente:
~/.codex/config.toml. - Progetto:
.codex/config.tomlnel repository o in una sottocartella, caricato solo se il progetto è fidato. - Sistema (Unix):
/etc/codex/config.toml, se presente.
Da queste tre posizioni, più la riga di comando e i profili, nasce una precedenza esatta; il punto che sorprende è che il file di progetto batte il tuo file utente. È utile in un team, perché il repository impone le sue regole, e spiega perché lo stesso comando si comporta in modo diverso in due cartelle. Dalla più alta alla più bassa, secondo la pagina «Config basics»:
- Opzioni da riga di comando e override
--config(-c chiave=valore). - I file di progetto
.codex/config.toml, dalla radice alla cartella corrente: vince il più vicino, solo per progetti fidati. - Il file di profilo scelto con
--profile nome, cioè~/.codex/nome.config.toml. - La configurazione utente,
~/.codex/config.toml. - I valori gestiti dal cloud, quando consegnati al tuo workspace.
- La configurazione di sistema.
- I valori predefiniti incorporati.
Qui l'ordine è tutto, e l'elenco è già un algoritmo: per ogni chiave, Codex prende il valore del primo livello che la definisce, dall'alto. Se non capisci perché un'impostazione non ha l'effetto che ti aspettavi, il comando /debug-config della CLI stampa i livelli di configurazione nell'ordine, con lo stato attivo e le fonti dei criteri; è la prima cosa da guardare e non l'ho eseguito io. Due vincoli sul livello di progetto: Codex ignora in un .codex/config.toml di progetto le chiavi che reindirizzano credenziali o provider (la pagina elenca openai_base_url, chatgpt_base_url, apps_mcp_product_sku, model_provider, model_providers, notify, profile, profiles, experimental_realtime_ws_base_url e otel) e stampa un avviso all'avvio; e un progetto non fidato perde del tutto i suoi livelli .codex/, comprese le regole e gli hook locali.
Un validatore di forma e un risolutore di precedenza
Prima di mettere un config.toml in un repository, conviene sapere se contiene valori che il programma rifiuta. Lo script seguente controlla soltanto le chiavi che elenco io, con i valori ammessi dalla pagina «Configuration Reference»: approval_policy (on-request, never o tabella granular; untrusted è ritirato e on-failure deprecato), sandbox_mode, web_search (cached, indexed, live, disabled), il conflitto fra default_permissions e sandbox_mode, e le chiavi che un file di progetto non può impostare. Tutte le altre chiavi sono dichiarate «non controllate». La funzione risolvi applica la precedenza fra due livelli (progetto sopra utente) con una semplificazione mia: le tabelle si sostituiscono, mentre la pagina dice che i filtri dell'ambiente si fondono fra livelli.
"""Un controllo di forma per config.toml, e chi vince fra due livelli.
I valori ammessi sono quelli della pagina "Configuration Reference" e delle pagine
"Config basics" e "Agent approvals & security" (consultate il 2026-11-13). Controlla
SOLO le chiavi elencate qui sotto: tutte le altre le dichiara non controllate.
Non e' Codex e non sostituisce il suo messaggio d'errore all'avvio.
"""
import sys, tomllib
SANDBOX = {"read-only", "workspace-write", "danger-full-access"}
WEB = {"cached", "indexed", "live", "disabled"}
GRANULARI = {"sandbox_approval", "rules", "mcp_elicitations", "request_permissions", "skill_approval"}
# Chiavi che un .codex/config.toml di progetto NON puo' impostare (Codex le ignora e avvisa).
IGNORATE_DAL_PROGETTO = {"openai_base_url", "chatgpt_base_url", "apps_mcp_product_sku",
"model_provider", "model_providers", "notify", "profile",
"profiles", "experimental_realtime_ws_base_url", "otel"}
CONTROLLATE = {"approval_policy", "sandbox_mode", "web_search", "default_permissions",
"project_doc_max_bytes", "model", "model_reasoning_effort", "profile", "profiles"}
def controlla(cfg, progetto=False):
guai = []
ap = cfg.get("approval_policy")
if ap == "untrusted":
guai.append("ERRORE approval_policy = 'untrusted' e' ritirato: puo' impedire l'avvio")
elif ap == "on-failure":
guai.append("AVVISO approval_policy = 'on-failure' e' deprecato: usa on-request o never")
elif isinstance(ap, dict):
extra = set(ap.get("granular", {})) - GRANULARI
if "granular" not in ap or extra:
guai.append(f"ERRORE approval_policy tabella non valida, chiavi: {sorted(extra) or 'manca granular'}")
elif ap not in (None, "on-request", "never"):
guai.append(f"ERRORE approval_policy = {ap!r} non e' un valore documentato")
if cfg.get("sandbox_mode", "read-only") not in SANDBOX:
guai.append(f"ERRORE sandbox_mode = {cfg['sandbox_mode']!r} non e' documentato")
if cfg.get("web_search", "cached") not in WEB:
guai.append(f"ERRORE web_search = {cfg['web_search']!r}: ammessi {sorted(WEB)}")
if "default_permissions" in cfg and "sandbox_mode" in cfg:
guai.append("ERRORE default_permissions e sandbox_mode insieme: la pagina Permissions dice 'non entrambi'")
sep = cfg.get("shell_environment_policy", {})
if ({"exclude", "include_only"} & set(sep)) and "filters" in sep:
guai.append("ERRORE shell_environment_policy: exclude/include_only e filters nello stesso livello")
if {"profile", "profiles"} & set(cfg):
guai.append("AVVISO profile/profiles: non letti dalla 0.134.0; usa ~/.codex/<nome>.config.toml")
if progetto:
for chiave in sorted(IGNORATE_DAL_PROGETTO & set(cfg)):
guai.append(f"AVVISO {chiave}: ignorata in un config.toml di progetto")
return guai
def risolvi(livelli):
"""livelli: [(nome, dict)] dal piu' forte al piu' debole; ritorna chiave -> (valore, nome)."""
out = {}
for nome, cfg in reversed(livelli):
for k, v in cfg.items():
if nome.startswith("progetto") and k in IGNORATE_DAL_PROGETTO:
continue # Codex la ignora: non entra nel valore effettivo
out[k] = (v, nome) # semplificazione mia: le tabelle si sostituiscono (la pagina dice che i filtri si fondono fra livelli)
return out
if __name__ == "__main__":
carico = {}
for percorso in sys.argv[1:]:
with open(percorso, "rb") as f:
carico[percorso] = tomllib.load(f)
progetto = percorso.startswith("progetto")
guai = controlla(carico[percorso], progetto)
non_controllate = sorted(set(carico[percorso]) - CONTROLLATE - {"shell_environment_policy"})
print(f"{percorso}: {len(guai)} segnalazioni; chiavi non controllate: {non_controllate or 'nessuna'}")
for g in guai:
print(" -", g)
nomi = [n for n in carico if n.startswith("progetto")] + [n for n in carico if n.startswith("utente")]
if len(nomi) == 2:
print("valore effettivo (progetto batte utente):")
for k, (v, da) in sorted(risolvi([(n, carico[n]) for n in nomi]).items()):
print(f" {k} = {v!r} <- {da}")
# Comando: python3 -I valida_config.py utente.toml progetto.toml errori.toml
# Output:
# utente.toml: 0 segnalazioni; chiavi non controllate: nessuna
# progetto.toml: 1 segnalazioni; chiavi non controllate: ['model_provider']
# - AVVISO model_provider: ignorata in un config.toml di progetto
# errori.toml: 5 segnalazioni; chiavi non controllate: nessuna
# - ERRORE approval_policy = 'untrusted' e' ritirato: puo' impedire l'avvio
# - ERRORE sandbox_mode = 'workspace_write' non e' documentato
# - ERRORE web_search = 'yes': ammessi ['cached', 'disabled', 'indexed', 'live']
# - ERRORE default_permissions e sandbox_mode insieme: la pagina Permissions dice 'non entrambi'
# - AVVISO profile/profiles: non letti dalla 0.134.0; usa ~/.codex/<nome>.config.toml
# valore effettivo (progetto batte utente):
# approval_policy = {'granular': {'sandbox_approval': True, 'rules': True, 'request_permissions': False}} <- progetto.toml
# model = 'gpt-6.1-sol' <- utente.toml
# model_reasoning_effort = 'medium' <- utente.toml
# sandbox_mode = 'read-only' <- progetto.toml
# shell_environment_policy = {'inherit': 'core', 'ignore_default_excludes': False, 'filters': {'AWS_*': 'exclude'}} <- utente.toml
# web_search = 'cached' <- utente.toml
I tre file di prova che lo script legge sono quelli seguenti; utente.toml e progetto.toml sono configurazioni plausibili, errori.toml raccoglie errori tipici, e tutti e tre sono schemi da adattare, non dati a Codex. Nel valore effettivo il progetto impone sandbox_mode = "read-only" e una politica di approvazione granulare, mentre il modello e il livello di ragionamento restano quelli dell'utente; model_provider del progetto è scartata, come dice la documentazione. Il nome del modello in utente.toml è quello dell'esempio ufficiale: verifica la pagina Models prima di copiarlo.
# ===== utente.toml =====
model = "gpt-6.1-sol"
approval_policy = "on-request"
sandbox_mode = "workspace-write"
model_reasoning_effort = "medium"
web_search = "cached"
[shell_environment_policy]
inherit = "core"
ignore_default_excludes = false
[shell_environment_policy.filters]
"AWS_*" = "exclude"
# ===== progetto.toml =====
sandbox_mode = "read-only"
approval_policy = { granular = { sandbox_approval = true, rules = true, request_permissions = false } }
model_provider = "interno"
# ===== errori.toml =====
approval_policy = "untrusted"
sandbox_mode = "workspace_write"
web_search = "yes"
default_permissions = ":workspace"
profile = "revisione"
Nell'uscita, errori.toml produce quattro errori e un avviso: untrusted (ritirato), workspace_write con il trattino basso al posto dei trattini (un refuso che nessuno nota a occhio), yes come valore di web_search, la coppia default_permissions con sandbox_mode che la pagina sui permessi vieta, e profile, che dalla 0.134.0 non è più letto (i profili stanno in file ~/.codex/nome.config.toml). Il limite del validatore è netto: controlla la forma di poche chiavi e non sa se il modello esiste, se la tua versione le accetta o se un livello amministrativo le vieta. Serve per il refuso, non per la certezza.
Un'impostazione di squadra ragionevole
Un repository può contenere un AGENTS.md alla radice e un .codex/config.toml che fissa sandbox e approvazione prudenti, così ogni collega parte dallo stesso comportamento. Un dettaglio di sicurezza che conviene sapere: nella sandbox workspace-write predefinita, la cartella .codex dentro un workspace scrivibile è protetta in sola lettura, quindi l'agente non può riscrivere da solo la configurazione di progetto. Il costo è doppio: il file di progetto si applica solo ai progetti fidati (va spiegato ai nuovi arrivati) e va rivisto come ogni altro file. Trattalo come tratteresti una modifica alla pipeline di CI: cambia ciò che un processo può fare con i tuoi permessi. Ogni modifica a .codex/config.toml merita lo stesso sguardo di una modifica a un workflow.
Per le prove una tantum non serve toccare il file: codex -c log_dir=./.codex-log sovrascrive la chiave per quella sola esecuzione, e le funzioni sperimentali si accendono con codex --enable nome_funzione o con nome_funzione = true sotto [features]. I nomi di modello cambiano di continuità: l'esempio ufficiale usa gpt-6.1-sol, ma la pagina Models precisa che va scelto fra quelli disponibili al tuo account o workspace.
Domande frequenti
Dove metto una regola che deve valere sempre?
In config.toml, non in AGENTS.md. Un'istruzione in linguaggio naturale può essere seguita male; un valore di configurazione come sandbox_mode o approval_policy è applicato dal programma. Se la regola riguarda un comando, la parte 3 mostra le regole sui comandi.
Perché Codex sembra ignorare il mio AGENTS.md?
Le cause elencate dalla documentazione sono: file vuoto (Codex salta i file vuoti), un AGENTS.override.md più in alto o nella cartella home di Codex che prende il posto di quello che hai modificato, un nome di riserva scritto male, il tetto di byte raggiunto, e una variabile CODEX_HOME che punta a un'altra cartella. Riavvia Codex dopo ogni modifica: non c'è cache da svuotare, perché la catena si ricostruisce a ogni avvio.
Il config.toml del repository batte il mio?
Sì, se il progetto è fidato: nella precedenza il file di progetto sta sopra il profilo e il tuo file utente, e quello più vicino alla cartella di lavoro vince fra più file di progetto. Se il progetto non è fidato, Codex ignora i suoi livelli .codex/.
Che cosa sai fare adesso
Sai distinguere un consiglio da un vincolo e metterli nel posto giusto, prevedere quali file di istruzioni entrano nella catena e quale resta fuori quando si raggiunge il tetto, scrivere un AGENTS.md che risponde a poche domande invece di descrivere tutto, e leggere la precedenza di config.toml come un algoritmo che puoi simulare. Il passo successivo riguarda i costi di ciò che hai configurato: la parte 5 su modelli, ragionamento e costi spiega come scegliere il modello e il livello di ragionamento. Per i permessi che hai appena messo in configurazione, la parte 3 è il riferimento, e la parte 2 mostra il primo lavoro.
Che cosa non ho verificato
Non ho eseguito Codex, quindi non ho verificato né che le istruzioni vengano lette nell'ordine descritto né che il tetto di byte si applichi alla somma o a ciascun file: la documentazione lo descrive in due modi e il modello segue una lettura sola. Non ho provato /debug-config, --cd né log_dir. I due programmi controllano solo ciò che dichiarano e non sostituiscono né la lettura della pagina né l'avviso che Codex stampa all'avvio.
Nella stessa serie trovi anche la mappa del prodotto (parte 1), cloud, subagenti, skill e MCP (parte 7) e il confronto con Claude Code, Copilot e Cursor (parte 8).
Fonti
- Custom instructions with AGENTS.md - catena di ricerca, override, nomi di riserva, tetto di 32 KiB, risoluzione dei problemi di scoperta; consultata il 2026-11-13
- Config basics - posizioni dei file, ordine di precedenza, chiavi principali,
shell_environment_policy,log_dir, funzioni sperimentali; consultata il 2026-11-13 - Advanced Configuration - file di progetto, chiavi ignorate in un file di progetto, profili e cambiamento dalla 0.134.0; consultata il 2026-11-13
- Configuration Reference - valori ammessi di
sandbox_mode,approval_policy,web_search,project_doc_max_bytes; consultata il 2026-11-13 - Best practices - che cosa contiene un buon
AGENTS.md,/initcome punto di partenza; consultata il 2026-11-13 - Agent approvals & security - percorsi protetti nel workspace,
untrustedritirato; consultata il 2026-11-13
I due programmi (catena_agents.py e valida_config.py) sono modelli miei delle regole documentate: eseguiti due volte con Python 3.14 su Linux, stessa uscita. AGENTS.md e i file TOML mostrati sono schemi da adattare, non dati a Codex.
← Parte 3: sandbox e approvazioni Parte 5: modelli, ragionamento e costi →
Commenti
Caricamento commenti...
Accedi per commentare