Un agente di programmazione esegue comandi sul tuo computer, e prima di lasciargli la tastiera devi sapere due cose: che cosa può toccare da solo, e quando si ferma a chiederti il permesso. In Codex sono due controlli distinti, ed è la distinzione che evita la maggior parte degli equivoci. La sandbox (sandbox_mode) è il confine tecnico: dice dove l'agente può scrivere e se i comandi possono usare la rete. L'approvazione (approval_policy) decide quando l'agente deve fermarsi e chiedere prima di oltrepassare quel confine. Secondo la documentazione letta il 13 novembre 2026, in locale la combinazione a basso attrito è workspace-write più on-request: scrive nella cartella di lavoro, tiene la rete spenta, e ti chiede quando deve uscire dal confine. Il criterio per allargare i permessi è una domanda sola: che cosa perdo se l'agente sbaglia, e posso recuperarlo?
Metodo e limiti. Non sono affiliato a OpenAI. Non ho eseguito Codex né tentato di aggirare la sandbox, e non posso garantire che non esistano falle: una sandbox riduce il danno, non lo azzera. Le tabelle e i valutatori di questa pagina sono modelli miei delle regole che la documentazione descrive, scritti per vedere le due manopole separate; li ho eseguiti due volte con la stessa uscita (Python 3.14, Linux), e non sono il motore di Codex.
Le due manopole, con i nomi esatti
La pagina sulla sandbox elenca i valori di sandbox_mode che puoi mettere in config.toml:
read-only: l'agente ispeziona i file ma non li modifica né esegue comandi senza approvazione.workspace-write: legge, modifica nel workspace ed esegue comandi locali di routine dentro quel confine; la pagina lo indica come modalità a basso attrito per il lavoro locale.danger-full-access: nessuna restrizione di sandbox, quindi cadono i confini sul filesystem e sulla rete. Il nome dice quello che fa.
Il confine che conta è il workspace, e va letto bene: comprende la cartella corrente e le cartelle temporanee come /tmp, e dentro i workspace scrivibili restano comunque in sola lettura, ricorsivamente, le cartelle .git, .agents, .codex e .aws quando esistono. Il comando /status mostra quali cartelle fanno parte del workspace della tua sessione, ed è il modo di non indovinare.
Per le approvazioni la stessa documentazione descrive on-request (lavora nella sandbox e chiede quando deve andare oltre) e never (non si ferma mai per chiedere). Esiste anche una forma a tabella, approval_policy = { granular = { ... } }, con cinque chiavi booleane (sandbox_approval, rules, mcp_elicitations, request_permissions, skill_approval) per tenere interattive alcune categorie di richieste e rifiutare automaticamente le altre. Due valori sono usciti di scena: untrusted non è più selezionabile e un file di configurazione che lo contiene può impedire l'avvio del client, mentre on-failure è deprecato. Se erediti un vecchio config.toml, controlla come prima cosa che non contenga approval_policy = "untrusted".
Le combinazioni più comuni sono elencate dalla pagina «Agent approvals & security»; le riporto con ciò che producono.
| Scopo | Opzioni da riga di comando o configurazione | Effetto secondo la pagina |
|---|---|---|
| Auto (predefinito) | --sandbox workspace-write --ask-for-approval on-request | Legge, modifica ed esegue nel workspace; chiede per scrivere fuori dal workspace o per usare la rete |
| Esplorazione sicura | --sandbox read-only --ask-for-approval on-request | Legge e può eseguire comandi dentro la sandbox di sola lettura; fuori può chiedere |
| Sola lettura in CI | --sandbox read-only --ask-for-approval never | Come sopra, ma non chiede mai |
| Revisione automatica | -c approvals_reviewer=auto_review con l'Auto | Stesso confine, ma le richieste idonee le valuta un altro agente |
| Accesso totale | --dangerously-bypass-approvals-and-sandbox (alias --yolo) | Nessuna sandbox, nessuna richiesta: la pagina lo segnala come sconsigliato |
Nell'app desktop e nell'estensione per l'IDE gli stessi profili hanno etichette leggibili: «Ask for approval», «Approve for me» (revisione automatica) e «Full access». Noterai che in un'organizzazione un amministratore può vietare i valori più larghi con un file requirements.toml: se lavori in un'azienda, controlla prima di scrivere una guida interna che consigli accesso totale.
Che cosa succede sotto: il sistema operativo
La sandbox non è una promessa del modello, è un meccanismo del sistema operativo applicato a ogni comando che l'agente lancia, compresi git, i gestori di pacchetti e i test runner, che ereditano gli stessi limiti. La pagina «Agent approvals & security» distingue le piattaforme: su macOS Seatbelt, su Linux bwrap più seccomp, su Windows la sandbox nativa, e in WSL2 quella di Linux. Ti riguarda in due modi. Se bwrap manca o i namespace utente non sono abilitati, la sandbox non parte; la scelta giusta è sistemare l'ambiente, non passare a danger-full-access per far tacere l'errore. In un container la stessa pagina avverte che la sandbox può non funzionare, e suggerisce in quel caso di far fornire l'isolamento al container e di avviare Codex con --sandbox danger-full-access al suo interno, aggiungendo che un dev container non impedisce ogni attacco: un progetto malevolo può portare fuori ciò che è disponibile nel container, comprese le credenziali di Codex.
La rete: spenta, salvo che tu la accenda
La documentazione dichiara il valore predefinito della rete: nell'app desktop, nella CLI e nell'estensione per l'IDE, la modalità workspace-write tiene l'accesso alla rete spento finché non lo abiliti. Si abilita con una chiave sola, e l'effetto è ampio.
- Rete spenta e
network_proxyacceso: la rete resta spenta, la funzione non fa nulla. - Rete accesa e
network_proxyspento: la rete resta accesa, con accesso diretto in uscita senza restrizioni. - Rete accesa e
network_proxyacceso: il traffico in uscita è limitato dalla politica di dominio che configuri, con regoleallowedeny(denyprevale sempre).
Le tre righe dicono che accendere la rete e dichiarare i domini permessi sono due gesti diversi, e il secondo da solo non protegge nulla: se scrivi un elenco di domini senza attivare network_proxy, il tuo elenco non limita le destinazioni. Va tenuto presente anche ciò che il proxy non filtra: la pagina precisa che non copre la ricerca web, le chiamate a strumenti di app e connettori, le connessioni a server MCP, l'attività del browser, i compiti cloud né le richieste del client al modello. La ricerca web ha un controllo a parte: web_search vale cached per impostazione predefinita, cioè risultati da un indice mantenuto da OpenAI invece di pagine scaricate dal vivo, il che riduce l'esposizione all'iniezione di istruzioni; con un profilo di accesso totale passa a live.
Perché la rete conta più del filesystem? Perché è il canale di uscita. Un agente che legge una pagina o un file con istruzioni nascoste e ha la rete aperta può, in teoria, mandare all'esterno ciò che trova nell'ambiente. La difesa è a strati: rete spenta di default, nessun segreto nell'ambiente della sessione, e la tua attenzione quando l'agente legge contenuto esterno.
Le due manopole in una tabella eseguibile
Per vedere che sandbox e approvazione sono indipendenti ho scritto un modello delle regole della documentazione. La funzione dentro_confine risponde solo alla domanda tecnica: l'azione resta dentro il confine della sandbox? La funzione esito aggiunge la seconda manopola: se l'azione è fuori dal confine, con on-request il risultato è «CHIEDE», con never non c'è nessuna richiesta possibile e l'azione non viene eseguita. Quest'ultima è una mia lettura: la pagina dice che never non si ferma mai per chiedere e che Codex fa del suo meglio entro i vincoli impostati, non dice testualmente che l'azione fallisca. Le azioni sono sei: una lettura, una scrittura nel workspace, una scrittura in .git, una in /tmp, una in /etc, e un accesso alla rete.
"""Sandbox e approvazione come due manopole indipendenti: una tabella, non un'opinione.
Modello MIO delle regole scritte nella documentazione di Codex (pagine Sandbox e
"Agent approvals & security", consultate il 2026-11-13; il workspace include la cartella
corrente e le cartelle temporanee come /tmp). Non e' Codex: e' il
modo per vedere le due manopole separate. Nessun assistente coinvolto.
"""
PROTETTI = (".git", ".agents", ".codex", ".aws") # sola lettura anche nel workspace
def dentro_confine(sandbox, azione, rete_attiva=False):
"""True se l'azione resta dentro il confine imposto dalla sandbox."""
tipo, _, percorso = azione.partition(":")
if sandbox == "danger-full-access":
return True
if tipo == "leggi":
return True
if tipo == "rete":
return sandbox == "workspace-write" and rete_attiva
if tipo == "scrivi":
if sandbox == "read-only":
return False
if percorso.startswith("/tmp/"): # il workspace include /tmp
return True
if percorso.startswith("/"): # altro percorso assoluto: fuori
return False
return percorso.split("/")[0] not in PROTETTI
raise ValueError(azione)
def esito(sandbox, approvazione, azione, rete_attiva=False):
if dentro_confine(sandbox, azione, rete_attiva):
return "eseguita"
return "CHIEDE" if approvazione == "on-request" else "non eseguita"
AZIONI = ("leggi:src/app.js", "scrivi:src/app.js", "scrivi:.git/config",
"scrivi:/tmp/build", "scrivi:/etc/hosts", "rete:registry")
COMBINAZIONI = (("read-only", "on-request"), ("read-only", "never"),
("workspace-write", "on-request"), ("workspace-write", "never"),
("danger-full-access", "never"))
if __name__ == "__main__":
larghezza = max(len(a) for a in AZIONI)
for sandbox, appr in COMBINAZIONI:
print(f"{sandbox} + {appr}")
for azione in AZIONI:
print(f" {azione:<{larghezza}} {esito(sandbox, appr, azione)}")
print("workspace-write + on-request, con network_access = true")
print(f" {'rete:registry':<{larghezza}} "
f"{esito('workspace-write', 'on-request', 'rete:registry', rete_attiva=True)}")
# Comando: python3 -I politica.py
# Output:
# read-only + on-request
# leggi:src/app.js eseguita
# scrivi:src/app.js CHIEDE
# scrivi:.git/config CHIEDE
# scrivi:/tmp/build CHIEDE
# scrivi:/etc/hosts CHIEDE
# rete:registry CHIEDE
# read-only + never
# leggi:src/app.js eseguita
# scrivi:src/app.js non eseguita
# scrivi:.git/config non eseguita
# scrivi:/tmp/build non eseguita
# scrivi:/etc/hosts non eseguita
# rete:registry non eseguita
# workspace-write + on-request
# leggi:src/app.js eseguita
# scrivi:src/app.js eseguita
# scrivi:.git/config CHIEDE
# scrivi:/tmp/build eseguita
# scrivi:/etc/hosts CHIEDE
# rete:registry CHIEDE
# workspace-write + never
# leggi:src/app.js eseguita
# scrivi:src/app.js eseguita
# scrivi:.git/config non eseguita
# scrivi:/tmp/build eseguita
# scrivi:/etc/hosts non eseguita
# rete:registry non eseguita
# danger-full-access + never
# leggi:src/app.js eseguita
# scrivi:src/app.js eseguita
# scrivi:.git/config eseguita
# scrivi:/tmp/build eseguita
# scrivi:/etc/hosts eseguita
# rete:registry eseguita
# workspace-write + on-request, con network_access = true
# rete:registry eseguita
Guarda le righe di workspace-write + on-request: la scrittura in src/app.js e in /tmp/build passa senza chiedere, mentre .git/config e /etc/hosts chiedono, perché il primo è un percorso protetto e il secondo è fuori dal workspace. Nelle righe con never le stesse azioni non vengono eseguite, ed è il comportamento che ti serve in CI: nessuno è lì a rispondere. Con danger-full-access tutto passa, e never in quella riga è ciò che la pagina chiama accesso totale. Nell'ultima riga, con network_access = true, la rete non chiede più. Limiti dichiarati: il modello non conosce le regole sui comandi, la revisione automatica, i profili di permessi né i singoli percorsi aggiunti con writable_roots; non usarlo per prevedere il comportamento di una configurazione reale, ma per spiegare a un collega che cosa fa ciascuna manopola.
Le eccezioni mirate: le regole sui comandi
La documentazione dice che, quando un flusso di lavoro ha bisogno di un'eccezione precisa, le regole sui comandi sono spesso meglio che allargare l'accesso in blocco. Le regole sono dichiarate sperimentali e potrebbero cambiare. Si scrivono in un file .rules sotto una cartella rules/ accanto a uno strato di configurazione (per esempio ~/.codex/rules/default.rules), nel linguaggio Starlark, che ha una sintassi vicina a quella di Python. Ogni prefix_rule ha un pattern (il prefisso esatto del comando; un elemento può essere un elenco di alternative), una decision (allow, che è il valore predefinito, prompt o forbidden), una justification opzionale e due elenchi di esempi, match e not_match, che Codex verifica al caricamento, come piccoli test. Se più regole corrispondono, vince la decisione più restrittiva: forbidden, poi prompt, poi allow. Il file seguente è uno schema da adattare, scritto da me sul formato documentato; non l'ho dato a Codex.
# Regole di prova per un repository di esempio (schema da adattare).
prefix_rule(
pattern = ["git", ["status", "diff", "log"]],
decision = "allow",
justification = "Sola lettura.",
match = ["git status", "git diff --stat"],
not_match = ["git commit -m x"],
)
prefix_rule(
pattern = ["gh", "pr", "view"],
decision = "prompt",
justification = "Leggere una PR esce dalla sandbox: decido io.",
match = ["gh pr view 7888", "gh pr view --repo owner/repo"],
not_match = ["gh pr --repo owner/repo view 7888"],
)
prefix_rule(
pattern = ["git", "push"],
decision = "forbidden",
justification = "Il push lo faccio io, a mano.",
match = ["git push origin main"],
not_match = ["git pull"],
)
Una regola vale solo per i comandi che coincidono per prefisso: gh pr --repo owner/repo view 7888 non corrisponde a ["gh", "pr", "view"], ed è il motivo del suo not_match. Dove la documentazione lo prevede, Codex spezza gli script di shell prima di applicare le regole, ma solo quando sono una catena lineare di parole semplici unite da &&, ||, ; o |; con redirezioni, sostituzioni, variabili o caratteri jolly tratta l'intero script come un comando unico. Il valutatore seguente implementa quelle regole su un file .rules: esegue il file come Python con la sola funzione prefix_rule (non è Starlark e non è il motore di Codex), controlla gli esempi inline e valuta alcuni comandi. Per il controllo vero la documentazione indica codex execpolicy check --pretty --rules <file> -- <comando>, che io non ho eseguito.
"""Un valutatore di prefix_rule per provare le regole prima di fidarti di loro.
Segue le regole scritte nella pagina Rules della documentazione di Codex
(consultata il 2026-11-13): prefisso esatto, decisione piu' restrittiva
(forbidden > prompt > allow), script di shell spezzato solo se fatto di parole
semplici unite da && || ; |. NON e' il motore di Codex: il file .rules e' Starlark,
qui lo eseguo come Python con la sola funzione prefix_rule (la sintassi usata e' comune).
Per il motore vero esiste `codex execpolicy check`, che qui non ho eseguito.
"""
import re, shlex, sys
GRAVITA = {"allow": 0, "prompt": 1, "forbidden": 2}
REGOLE = []
def prefix_rule(pattern, decision="allow", justification=None, match=(), not_match=()):
assert pattern and decision in GRAVITA, "pattern non vuoto, decision valida"
REGOLE.append(dict(pattern=pattern, decision=decision, justification=justification,
match=list(match), not_match=list(not_match)))
def corrisponde(pattern, argv):
if len(argv) < len(pattern):
return False
return all((arg in elem) if isinstance(elem, list) else arg == elem
for elem, arg in zip(pattern, argv))
def valuta_argv(argv):
trovate = [r for r in REGOLE if corrisponde(r["pattern"], argv)]
if not trovate:
return None, None
peggiore = max(trovate, key=lambda r: GRAVITA[r["decision"]])
return peggiore["decision"], peggiore["justification"]
NON_SPEZZABILE = re.compile(r"[<>`$*?(){}]|(^|[\s;&|])\w+=|\b(if|for|while|case)\b")
def comandi(riga):
argv = shlex.split(riga)
if len(argv) >= 3 and argv[0] in ("bash", "zsh", "sh") and argv[1] in ("-c", "-lc"):
script = argv[2]
if NON_SPEZZABILE.search(script):
return [argv] # un solo comando opaco
return [shlex.split(p) for p in re.split(r"&&|\|\||;|\|", script) if p.strip()]
return [argv]
def valuta(riga):
verdetti = [valuta_argv(a) + (a,) for a in comandi(riga)]
noti = [v for v in verdetti if v[0]]
if not noti:
return "nessuna regola", None
d, why, _ = max(noti, key=lambda v: GRAVITA[v[0]])
return d, why
def controlla_esempi():
errori = 0
for r in REGOLE:
for riga in r["match"]:
if not corrisponde(r["pattern"], shlex.split(riga)):
print("ERRORE match non corrisponde:", riga); errori += 1
for riga in r["not_match"]:
if corrisponde(r["pattern"], shlex.split(riga)):
print("ERRORE not_match corrisponde:", riga); errori += 1
return errori
if __name__ == "__main__":
exec(open(sys.argv[1]).read(), {"prefix_rule": prefix_rule})
print("regole caricate:", len(REGOLE), "- esempi inline in errore:", controlla_esempi())
for riga in ("git status", "git push origin main", "gh pr view 7888",
"bash -lc 'git add . && git push'", "bash -lc 'git status && git push'",
"bash -lc 'git status > out.txt; git push'", "npm test"):
decisione, perche = valuta(riga)
print(f"{riga:<44} -> {decisione}" + (f" ({perche})" if perche else ""))
# Comando: python3 -I regole.py esempio.rules
# Output:
# regole caricate: 3 - esempi inline in errore: 0
# git status -> allow (Sola lettura.)
# git push origin main -> forbidden (Il push lo faccio io, a mano.)
# gh pr view 7888 -> prompt (Leggere una PR esce dalla sandbox: decido io.)
# bash -lc 'git add . && git push' -> forbidden (Il push lo faccio io, a mano.)
# bash -lc 'git status && git push' -> forbidden (Il push lo faccio io, a mano.)
# bash -lc 'git status > out.txt; git push' -> nessuna regola
# npm test -> nessuna regola
La riga che conta è la penultima. bash -lc 'git status && git push' è una catena lineare: viene spezzata e il git push trova la regola forbidden. Ma bash -lc 'git status > out.txt; git push' contiene una redirezione, quindi l'intero script resta un comando solo, nessuna regola corrisponde, e il verdetto è «nessuna regola»: la tua regola forbidden non scatta. Non vuol dire che il push sia permesso, perché restano la sandbox (rete spenta) e le approvazioni; vuol dire che una regola sui comandi non è una barriera da sola. È una ragione in più per tenere la rete spenta e per non fidarsi di un elenco di divieti come unica difesa.
Ambiente e segreti
La configurazione ha una tabella [shell_environment_policy] che decide quali variabili d'ambiente arrivano ai comandi lanciati dall'agente. Un dettaglio che sorprende: ignore_default_excludes vale true per impostazione predefinita, quindi Codex non rimuove automaticamente le variabili il cui nome contiene KEY, SECRET o TOKEN. Per attivare quell'esclusione automatica devi impostarlo a false. Il resto si regola con inherit (none parte da un ambiente vuoto, core da uno ridotto) e con filtri per nome, che accettano * e ?. L'ordine di applicazione è: esclusioni automatiche, esclusioni personalizzate, valori di set, e infine l'elenco delle inclusioni; poiché set viene dopo le esclusioni, può ripristinare una variabile esclusa. Lo schema seguente riprende l'esempio della documentazione; ho verificato soltanto che sia TOML valido, non che Codex lo accetti.
# schema da adattare: quali variabili d'ambiente arrivano ai comandi dell'agente
[shell_environment_policy]
inherit = "core"
ignore_default_excludes = false
[shell_environment_policy.filters]
"AWS_*" = "exclude"
"AZURE_*" = "exclude"
Il costo di questa disciplina è qualche errore del tipo «variabile non trovata», da risolvere una volta; il vantaggio è che un comando sbagliato non può leggere un segreto che non c'è. Il principio di passare il minimo necessario è mio, non della documentazione. Un esempio concreto: una sessione che sistema test unitari non ha motivo di vedere le variabili AWS_* del tuo shell.
Una matrice di decisione
La mia raccomandazione, derivata dalla domanda «che cosa perdo e posso recuperarlo?», è nella tabella seguente. Le righe sono mie; le opzioni citate esistono nella documentazione.
| Situazione | Sandbox + approvazione | Perché |
|---|---|---|
| Leggere un repository sconosciuto | read-only + on-request | Zero scritture; l'esplorazione non richiede di più |
| Lavoro quotidiano su un repository tuo, albero Git pulito | workspace-write + on-request | Le modifiche sono nel diff e annullabili; le uscite chiedono |
| Molti compiti ripetitivi, rete spenta | come sopra con approvals_reviewer = "auto_review" | Meno interruzioni; la revisione automatica fa altre chiamate al modello e può incidere sull'uso |
| Esecuzione non interattiva in CI | codex exec, per impostazione predefinita sandbox di sola lettura; --sandbox workspace-write per consentire modifiche | La documentazione della modalità non interattiva lo indica; --full-auto non è più supportato |
| Macchina usa e getta o container senza segreti | danger-full-access può essere accettabile | Il confine lo metti tu, fuori da Codex |
| Il tuo portatile con chiavi SSH e credenziali | Mai danger-full-access + never | Un comando sbagliato ha accesso a tutto |
Il compromesso della riga con revisione automatica è reale: la pagina dice che il revisore valuta solo le azioni che già richiedono approvazione, che i guasti nella costruzione del prompt o nell'analisi si chiudono in modo sicuro (l'azione non parte) e che le azioni a rischio critico vengono negate. Resta un altro modello che giudica una richiesta, e per i comandi che toccano la produzione conviene leggerli tu. Un'ultima nota di configurazione: i profili di permessi con nome (:read-only, :workspace, :danger-full-access) sono in beta e, secondo la loro pagina, non si combinano con sandbox_mode: si configura l'uno o l'altro.
Una prassi minima, nell'ordine in cui serve
- Albero Git pulito e commit fatto prima di ogni sessione.
/statusall'inizio: controlla profilo, approvazione e cartelle scrivibili.- Parti da
workspace-writeconon-requeste rete spenta; allarga una cosa per volta, solo per il compito. - Leggi ogni richiesta di approvazione: comando, percorso, destinazione di rete, e scegli l'ambito più stretto che permette di proseguire.
- Rivedi il diff e rilancia i test tu prima di fidarti.
L'ordine ha un senso: i primi due passi sono gratuiti e proteggono tutti i seguenti; il terzo fissa il perimetro prima che esista una richiesta; il quarto è l'unico che richiede attenzione ogni volta; l'ultimo chiude il giro e non si salta. Se una richiesta di approvazione ti sembra ripetitiva, il rimedio è una regola mirata, non un permesso più ampio.
Domande frequenti
Qual è la differenza fra sandbox_mode e approval_policy?
La prima è il confine tecnico: dove l'agente può scrivere e se può usare la rete. La seconda è il momento in cui l'agente deve fermarsi a chiederti il permesso prima di oltrepassarlo. Sono indipendenti: never con read-only è un agente che non chiede e non può scrivere; never con danger-full-access è un agente che non chiede e può tutto.
Perché Codex mi chiede il permesso anche dentro il mio repository?
Le cause più probabili sono tre: l'azione tocca un percorso protetto come .git o .codex, richiede la rete (spenta di default in workspace-write), oppure esce dal workspace. Apri /status per vedere le cartelle scrivibili e leggi il comando richiesto prima di approvare.
È sicuro usare approval_policy = never?
Dipende dalla sandbox che lo accompagna. Con una sandbox di sola lettura o workspace-write l'agente non può uscire dal confine, quindi in CI è una scelta ragionevole; con danger-full-access non c'è più alcun confine. La stessa pagina avverte di usare la combinazione con cautela.
Che cosa sai fare adesso
Sai leggere la configurazione di sicurezza di Codex come due decisioni separate, sai che la rete è spenta di default in workspace-write e che i percorsi .git, .agents, .codex e .aws restano in sola lettura, e sai scrivere una regola sui comandi sapendo che non copre gli script con redirezioni. Nella parte 4 metti queste scelte in un config.toml e nelle istruzioni di progetto; se arrivi da qui senza aver letto l'installazione, la parte 2 mostra come si lancia il primo lavoro, e la parte 1 la mappa del prodotto.
Che cosa non ho verificato
Non ho eseguito Codex, quindi non ho provato né l'avvio della sandbox né il comportamento delle approvazioni: ciò che descrivo è quello che la documentazione dice il 2026-11-13. Non ho verificato che cosa accada a un comando fuori dalla sandbox con never (la mia lettura è dichiarata come tale), né il funzionamento di codex execpolicy check, né il testo esatto dei messaggi. La pagina sui permessi è in beta e può cambiare.
Nella stessa serie trovi anche la scelta del modello e del ragionamento (parte 5), codex exec e l'SDK in CI (parte 6), cloud, subagenti, skill e MCP (parte 7) e il confronto con Claude Code, Copilot e Cursor (parte 8).
Fonti
- Sandbox - i tre valori di
sandbox_mode,on-requestenever,untrustednon più selezionabile,approvals_reviewer; consultata il 2026-11-13 - Agent approvals & security - rete spenta di default,
network_proxy, percorsi protetti, tabella delle combinazioni, sandbox per sistema operativo, container; consultata il 2026-11-13 - Rules -
prefix_rule, decisione più restrittiva, spezzettamento degli script di shell,codex execpolicy check; consultata il 2026-11-13 - Advanced Configuration -
shell_environment_policy, ordine di applicazione dei filtri,ignore_default_excludes; consultata il 2026-11-13 - Non-interactive mode - sandbox di sola lettura predefinita di
codex exec,--full-autonon più supportato; consultata il 2026-11-13 - Permissions - profili di permessi (beta) e loro incompatibilità con
sandbox_mode; consultata il 2026-11-13
La tabella e il valutatore di regole sono modelli miei delle regole documentate, eseguiti due volte con Python 3.14 su Linux con la stessa uscita; il file .rules e lo schema TOML sono schemi da adattare, validati solo nella forma e mai dati a Codex.
← Parte 2: Codex CLI, il primo lavoro Parte 4: AGENTS.md e config.toml →
Commenti
Caricamento commenti...
Accedi per commentare