Salta al contenuto principale

06 - Codex exec e SDK: l'agente in CI senza rischi

Come usare codex exec, l'output JSON Lines, lo schema di risposta e l'SDK in CI, con la chiave API lontana dal codice del repository e due job separati.

Cosa ne pensi di questo articolo?

06 - Codex exec e SDK: l'agente in CI senza rischi
OpenAI Codexfedericocalo.dev

In Breve

Come usare codex exec, l'output JSON Lines, lo schema di risposta e l'SDK in CI, con la chiave API lontana dal codice del repository e due job separati.

Vuoi che Codex lavori in un passo di CI, senza nessuno davanti allo schermo, e non vuoi regalare a quel passo né la tua chiave API né i permessi di scrittura sul repository. La documentazione, aperta il 13 novembre 2026, dà gli ingredienti. codex exec esegue Codex senza interfaccia: stampa l'avanzamento su stderr e solo il messaggio finale su stdout, quindi lo metti in una pipe o in un file. Per impostazione predefinita gira in sandbox read-only, e per fargli modificare file serve --sandbox workspace-write esplicito. In CI la chiave API va passata al singolo comando con CODEX_API_KEY, mai come variabile dell'intero job quando il job esegue codice del repository. Per pilotare l'agente da un programma esistono un SDK TypeScript (@openai/codex-sdk) e uno Python (openai-codex).

La regola che regge tutto è una sola: il passo che lancia l'agente non deve avere i permessi di scrittura sul repository, e quello che li ha non deve vedere la chiave. Sesta parte della serie su OpenAI Codex; conviene aver letto la parte 3 su sandbox e approvazioni. Non ho eseguito Codex, la sua GitHub Action né l'SDK: gli script girano senza agente, su file di prova, e i blocchi che richiedono lo strumento lo dichiarano. Non sono affiliato a OpenAI.

Che cosa fa codex exec

I comandi qui sotto sono quelli della pagina «Non-interactive mode», raccolti in un blocco, e non sono stati eseguiti: servono Codex installato e un accesso. Il primo è il caso base; il secondo usa --output-schema e -o; il terzo prende lo standard input come contesto, il quarto come prompt intero con il trattino -; l'ultimo riprende con resume la sessione più recente della cartella corrente (--last).

# schema da adattare, non eseguito: richiede Codex installato e autenticato
codex exec "riassumi la struttura del repository ed elenca le 5 aree più rischiose"

# con schema di risposta: il prompt è obbligatorio e l'ultimo messaggio finisce in un file
codex exec "Estrai i metadati del progetto" \
  --output-schema ./schema.json \
  -o ./project-metadata.json

# il prompt è l'istruzione, lo standard input è il contesto
npm test 2>&1 | codex exec "riassumi i test che falliscono" | tee riassunto-test.md

# il prompt intero arriva dallo standard input
cat prompt.txt | codex exec -

# riprendere un lavoro precedente
codex exec "controlla se ci sono race condition"
codex exec resume --last "correggi le race condition che hai trovato"

Un dettaglio che la documentazione dei comandi mette nero su bianco: con --output-schema, --output-last-message, --ephemeral o con immagini, il prompt è obbligatorio. Se passi un prompt come argomento e qualcosa su stdin, l'argomento è l'istruzione e lo stdin è contesto; se ometti l'argomento, Codex legge il prompt da stdin. Le opzioni che contano per una pipeline sono queste:

  • --json: lo stdout diventa un flusso JSON Lines di eventi (thread.started, turn.started, item.*, turn.completed, turn.failed, error).
  • -o <percorso> o --output-last-message <percorso>: scrive solo il messaggio finale in un file e lo stampa comunque.
  • --output-schema <file>: obbliga la risposta finale a uno schema JSON, e trasforma l'agente da «scrive prosa» a «produce dati su cui uno script può contare».
  • --ephemeral: non salva su disco i file di sessione.
  • --skip-git-repo-check: supera l'obbligo di eseguire dentro un repository Git, che Codex impone per evitare modifiche distruttive.
  • --ignore-user-config e --ignore-rules: ignorano il tuo $CODEX_HOME/config.toml e i file di regole .rules.
  • -m (o --model): sceglie il modello per questa esecuzione, come si vede nella parte 5.

Le due opzioni della penultima voce meritano un commento, perché sono quelle che cambiano il comportamento senza che il comando lo dica. In CI vuoi un comportamento riproducibile, e --ignore-user-config toglie la variabile di un config.toml ereditato dal runner. --ignore-rules invece salta le regole di esecuzione di utente e progetto: la documentazione lo cita per un ambiente di automazione controllato, e secondo me (è un giudizio mio, non della fonte) in un workflow che tocca codice altrui è raramente ciò che vuoi, perché toglie un controllo. Se un server MCP è configurato con required = true e non si inizializza, codex exec esce con errore invece di proseguire: è il comportamento giusto per un passo che non deve produrre un risultato incompleto in silenzio.

Leggere il flusso JSON e decidere l'esito

Con --json ogni riga dello stdout è un evento. Lo script qui sotto è il lettore minimo che metteresti dopo codex exec --json: prende l'ultimo messaggio dell'agente, i token dell'ultimo turno, i file toccati dagli elementi file_change e il numero di comandi finiti con codice diverso da 0, e restituisce exit 1 se compare turn.failed o error. Usa solo i campi che il codice dell'SDK TypeScript, nel repository pubblico di Codex, dichiara per quegli eventi.

Il primo file di prova, ok.jsonl, è l'esempio di flusso della documentazione, copiato com'è. Il secondo, fallito.jsonl, l'ho costruito io seguendo i tipi del codice dell'SDK: un test che fallisce, due file toccati, un messaggio finale ottimista e un turn.failed per limite di utilizzo. Non sono uscite di Codex.

# Legge il flusso JSON Lines di `codex exec --json` e decide l'esito del passo CI.
# Usa solo il campo "type" e i campi che il codice dell'SDK TypeScript dichiara.
import json
import sys

def leggi(percorso):
    finale, usage, file_toccati, comandi_falliti, errore = None, None, [], 0, None
    with open(percorso, encoding="utf-8") as f:
        for riga in f:
            if not riga.strip():
                continue
            ev = json.loads(riga)
            tipo = ev["type"]
            if tipo == "item.completed":
                item = ev["item"]
                if item["type"] == "agent_message":
                    finale = item["text"]          # vale l'ultimo messaggio
                elif item["type"] == "file_change":
                    file_toccati += [c["path"] for c in item["changes"]]
                elif item["type"] == "command_execution" and item.get("exit_code", 0) != 0:
                    comandi_falliti += 1
            elif tipo == "turn.completed":
                usage = ev["usage"]
            elif tipo == "turn.failed":
                errore = ev["error"]["message"]
            elif tipo == "error":
                errore = ev["message"]
    return finale, usage, file_toccati, comandi_falliti, errore

esito = 0
for percorso in sys.argv[1:]:
    finale, usage, toccati, falliti, errore = leggi(percorso)
    print(f"== {percorso}")
    print("messaggio finale:", finale)
    print("token (ingresso, cache, uscita):",
          None if usage is None else (usage["input_tokens"], usage["cached_input_tokens"], usage["output_tokens"]))
    print("file toccati:", toccati)
    print("comandi con exit diverso da 0:", falliti)
    if errore:
        print("ERRORE:", errore)
        esito = 1
print("codice di uscita:", esito)
sys.exit(esito)

# Output:
# == ok.jsonl
# messaggio finale: Repo contains docs, sdk, and examples directories.
# token (ingresso, cache, uscita): (24763, 24448, 122)
# file toccati: []
# comandi con exit diverso da 0: 0
# == fallito.jsonl
# messaggio finale: Ho corretto l'arrotondamento, ma un test resta rosso.
# token (ingresso, cache, uscita): None
# file toccati: ['src/sconto.js', 'test/sconto.test.js']
# comandi con exit diverso da 0: 1
# ERRORE: limite di utilizzo raggiunto
# codice di uscita: 1

Nel secondo flusso il messaggio finale dice «un test resta rosso» ma i token sono assenti, perché il turno non è mai arrivato a turn.completed: un chiaro segnale che la risposta non va trattata come completa. La riga finale = item["text"] sovrascrive a ogni messaggio, quindi vale l'ultimo, come fa il metodo run() dell'SDK TypeScript, che inoltre solleva un errore quando vede turn.failed.

Lo schema di risposta, controllato due volte

Quando usi --output-schema, il file schema.json è quello dell'esempio della documentazione: un oggetto con project_name (stringa) e programming_languages (elenco di stringhe), entrambi obbligatori, e additionalProperties: false che vieta campi in più. La fonte dice che lo schema serve a ottenere una risposta finale conforme; io propongo di verificarla comunque prima di consumarla, perché il passo successivo si fida di quei campi. Lo script usa la libreria jsonschema (dipendenza di prova, versione 4.26.0, installata in un ambiente virtuale) e prova quattro messaggi: uno conforme e tre sbagliati in modi diversi.

# Verifica che il messaggio finale di un passo CI rispetti lo schema passato a
# --output-schema, PRIMA di darlo in pasto al passo successivo.
# Dipendenza di prova: jsonschema (pip install jsonschema).
import json
from jsonschema import Draft202012Validator

with open("schema.json", encoding="utf-8") as f:
    validatore = Draft202012Validator(json.load(f))

candidati = {
    "conforme": '{"project_name": "demo", "programming_languages": ["Python", "Shell"]}',
    "campo extra": '{"project_name": "demo", "programming_languages": [], "licenza": "MIT"}',
    "campo mancante": '{"project_name": "demo"}',
    "testo libero": "Il progetto si chiama demo.",
}

for nome, testo in candidati.items():
    try:
        dato = json.loads(testo)
    except json.JSONDecodeError as e:
        print(f"{nome}: NON è JSON ({e.msg})")
        continue
    errori = sorted(e.message for e in validatore.iter_errors(dato))
    print(f"{nome}: {'ok' if not errori else '; '.join(errori)}")

# Output:
# conforme: ok
# campo extra: Additional properties are not allowed ('licenza' was unexpected)
# campo mancante: 'programming_languages' is a required property
# testo libero: NON è JSON (Expecting value)

Le tre righe d'errore corrispondono a tre guasti diversi con cui un passo CI deve saper fare i conti: un campo che lo schema non prevede, un campo obbligatorio che manca, un testo che non è nemmeno JSON. In tutti e tre i casi il passo deve fallire con un messaggio comprensibile e non passare il valore a valle. Il controllo non sostituisce lo schema passato a Codex: ne è la cintura di sicurezza.

Permessi: il predefinito è prudente, e deve restarlo

Come visto nella parte 3, codex exec parte in sandbox read-only. Per scrivere: codex exec --sandbox workspace-write "<compito>". Per accessi più ampi: --sandbox danger-full-access, ma solo in un ambiente controllato, come un runner CI isolato o un container. L'opzione --full-auto non è più supportata: la fonte indica --sandbox workspace-write oppure --approve-for-me, che instrada le richieste di approvazione verso la revisione automatica con la sandbox di scrittura nel workspace. Scegli il livello per compito, non per repository: un job che commenta una pull request e un job che corregge il codice hanno bisogno di permessi diversi, e il primo funziona in sola lettura.

Le credenziali in CI: dove si sbaglia davvero

La pagina è esplicita su tre cose, e la guida di sicurezza dell'azione aggiunge i dettagli:

  • Di default codex exec riutilizza l'autenticazione salvata della CLI. Per una singola esecuzione imposti la chiave in linea: CODEX_API_KEY=<chiave> codex exec --json "smista le segnalazioni aperte".
  • Non impostare OPENAI_API_KEY o CODEX_API_KEY come variabile di ambiente a livello di job nei workflow che eseguono codice controllato dal repository: script di build, test, hook delle dipendenze o un'azione compromessa nello stesso job possono leggerla.
  • L'autenticazione gestita da ChatGPT in CI è un'opzione avanzata: tratta ~/.codex/auth.json come una password e non usare questa via per repository pubblici o open source. Le chiavi API sono il predefinito raccomandato.

Il filo comune è che una credenziale in un ambiente condiviso è un bersaglio: tutto ciò che gira nel job può leggerla. Per GitHub Actions la documentazione consiglia di usare la GitHub Action di Codex (openai/codex-action@v1, licenza Apache-2.0) invece di installare la CLI e passare la chiave a un passo di shell. L'azione installa la CLI, avvia un proxy verso la Responses API a cui affida la chiave (la passi con l'input openai-api-key, dai segreti del repository) e lancia Codex con una strategia di sicurezza configurabile. Per impostazione predefinita solo chi ha accesso in scrittura al repository può avviarla, e safety-strategy vale drop-sudo: revoca il sudo dell'utente del runner prima di lanciare Codex. Il motivo, scritto nella guida di sicurezza, è controintuitivo: un filesystem in sola lettura con sudo senza password (il predefinito sui runner ospitati da GitHub) può esporre la chiave, perché Linux rende leggibili molte informazioni dei processi attraverso procfs.

Che cosa può leggere l'agente, e chi lo può avviare

La stessa guida elenca le fonti attraverso cui un testo ostile arriva al modello (prompt injection): il corpo di una pull request, dove un commento HTML è visibile al modello e quasi invisibile a chi legge; i messaggi dei commit; i file di istruzioni del repository come AGENTS.md quando provengono dalla pull request; gli screenshot. Se il workflow gira sul contenuto di pull request esterne, quel contenuto è input non fidato. La guida avverte anche che con allow-users: "*" chiunque può consumare la quota della tua chiave.

Il pattern a due job, controllato da uno script

L'esempio della pagina separa le responsabilità in due job, ed è la parte da imitare. Il job generate_fix ha solo contents: read, esegue Codex tramite l'azione e salva l'output di git diff come artefatto, una patch; il job open_pr ha i permessi di scrittura, scarica la patch, la applica, spinge un ramo e apre una pull request, e non riceve la chiave. Qui sotto una versione ridotta dell'esempio della documentazione (prompt accorciato, apertura della pull request tagliata): non è stata eseguita su GitHub, è uno schema da adattare, e la sua forma la controlla uno script mio.

name: Codex auto-fix on CI failure
on:
  workflow_run:
    workflows: ["CI"]
    types: [completed]
jobs:
  generate_fix:
    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@v5
        with:
          ref: ${{ github.event.workflow_run.head_sha }}
          persist-credentials: false
      - name: Run Codex
        uses: openai/codex-action@v1
        with:
          openai-api-key: ${{ secrets.OPENAI_API_KEY }}
          permission-profile: ":workspace"
          prompt: |
            Riproduci il fallimento della CI e proponi la modifica minima.
      - name: Create patch artifact
        run: git diff --binary HEAD > codex.patch
      - uses: actions/upload-artifact@v4
        with:
          name: codex-fix-patch
          path: codex.patch
  open_pr:
    needs: generate_fix
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write
    steps:
      - uses: actions/checkout@v5
      - uses: actions/download-artifact@v4
        with:
          name: codex-fix-patch
      - run: git apply --index codex.patch

Le righe che portano il peso sono quattro: permissions: contents: read nel job dell'agente, openai-api-key passata nella sezione with del solo passo dell'azione, persist-credentials: false nel checkout, che impedisce a actions/checkout di configurare il token per i comandi git successivi (per impostazione predefinita lo fa, secondo la documentazione di quell'azione), e il job open_pr che scrive ma non nomina mai il segreto. Il controllo che segue legge il file con PyYAML (dipendenza di prova, versione 6.0.3) e lo confronta con quelle regole, più un'altra che la guida di sicurezza chiede: openai/codex-action dovrebbe essere l'ultimo passo del job. Gli ho dato anche un workflow volutamente sbagliato.

# Controlla la separazione dei privilegi descritta nella documentazione:
# il job che lancia l'agente legge soltanto, e solo lì compare la chiave.
# Dipendenza di prova: PyYAML (pip install pyyaml).
import sys
import yaml

CHIAVI = ("OPENAI_API_KEY", "CODEX_API_KEY")

def usa_azione(step):
    return str(step.get("uses", "")).startswith("openai/codex-action@")

def controlla(percorso):
    with open(percorso, encoding="utf-8") as f:
        wf = yaml.safe_load(f)
    errori, avvisi = [], []
    if any(k in str(wf.get("env", "")) for k in CHIAVI):
        errori.append("chiave in env a livello di workflow")
    for nome, job in wf["jobs"].items():
        passi = job.get("steps", [])
        if any(k in str(job.get("env", "")) for k in CHIAVI):
            errori.append(f"{nome}: chiave in env a livello di job")
        indici = [i for i, s in enumerate(passi) if usa_azione(s)]
        if indici:                                   # job che esegue l'agente
            if job.get("permissions") != {"contents": "read"}:
                errori.append(f"{nome}: permessi {job.get('permissions')}, serve solo contents: read")
            dopo = len(passi) - 1 - indici[-1]
            if dopo:
                avvisi.append(f"{nome}: passi dopo l'agente: {dopo} (la guida di sicurezza dell'azione lo vuole ultimo)")
        else:                                        # tutti gli altri job
            if "secrets." in str(job):
                errori.append(f"{nome}: usa un segreto ma non lancia l'agente")
        for s in passi:
            if "github.event." in str(s.get("run", "")):
                errori.append(f"{nome}: espressione github.event dentro run:, passala con env:")
    return errori, avvisi

esito = 0
for percorso in sys.argv[1:]:
    errori, avvisi = controlla(percorso)
    print(f"== {percorso}: {'ERRORI' if errori else 'ok'}")
    for e in errori:
        print("  errore:", e)
    for a in avvisi:
        print("  avviso:", a)
    esito = esito or int(bool(errori))
sys.exit(esito)

# Output:
# == buono.yml: ok
#   avviso: generate_fix: passi dopo l'agente: 2 (la guida di sicurezza dell'azione lo vuole ultimo)
# == cattivo.yml: ERRORI
#   errore: generate_fix: chiave in env a livello di job
#   errore: generate_fix: permessi {'contents': 'write'}, serve solo contents: read
#   errore: generate_fix: espressione github.event dentro run:, passala con env:
#   errore: open_pr: usa un segreto ma non lancia l'agente
#   avviso: generate_fix: passi dopo l'agente: 1 (la guida di sicurezza dell'azione lo vuole ultimo)

Il secondo file fallisce in quattro modi, e ciascuno corrisponde a una raccomandazione delle fonti: la chiave nell'ambiente del job, il permesso di scrittura sul job dell'agente, un'espressione github.event dentro run: (che la guida chiede di passare tramite env: per evitare l'iniezione di comandi), un segreto in un job che non lancia l'agente. L'avviso sul primo file è onesto: l'esempio della documentazione ha due passi dopo l'azione, quelli che serializzano la patch, mentre la guida di sicurezza raccomanda di lanciare l'azione per ultima, perché dopo un'esecuzione con permessi ampi lo stato dell'host non è garantito. Con permessi in sola lettura e un diff come unico residuo il compromesso è ragionevole, ma resta un compromesso. Lo script controlla la forma: non sa se i segreti esistono né come girerà l'azione.

La patch come unico passaggio

Il pattern regge perché fra i due job passa solo un file di testo. Lo script di shell seguente riproduce il passaggio con git e senza agente: il job 1 modifica un file e ne crea uno nuovo, produce la patch con git diff --binary HEAD, il job 2, in un'altra copia del repository, la applica con git apply --index e fa il commit. Mostra anche perché nell'esempio della documentazione compare git add -N . prima del diff: senza quell'intento di aggiunta, un file nuovo non tracciato non entra nella patch.

#!/usr/bin/env bash
# Il passaggio di consegne del pattern a due job, riprodotto con git e senza agente:
# il "job 1" produce una patch, il "job 2" la applica in un'altra copia del repository.
set -euo pipefail
export GIT_CONFIG_NOSYSTEM=1
G="git -c user.name=demo -c user.email=demo@example.invalid"
base=$(mktemp -d)
trap 'rm -rf "$base"' EXIT
cd "$base"

$G init -q origine && cd origine
printf 'export const sconto = (p) => p * 0.9;\n' > sconto.js
$G add . && $G commit -q -m "base"
cd ..
git clone -q origine job1 && git clone -q origine job2

# --- job 1 (sola lettura sul remoto): qui lavorerebbe l'agente ---
cd job1
sed -i 's/0.9/0.85/' sconto.js                       # file modificato
printf 'import { sconto } from "./sconto.js";\n' > sconto.test.js   # file nuovo, non tracciato
git diff --binary HEAD > ../senza-N.patch
git add -N .
git diff --binary HEAD > ../con-N.patch
echo "senza 'git add -N':" $(grep '^diff --git' ../senza-N.patch | awk '{print $4}')
echo "con 'git add -N':   " $(grep '^diff --git' ../con-N.patch | awk '{print $4}')

# --- job 2 (con i permessi di scrittura): vede solo il file di patch ---
cd ../job2
git apply --stat ../con-N.patch | tail -1
git apply --index ../con-N.patch
$G commit -q -m "Correzione proposta dall'agente"
git log --format='%s' | head -2
git status --short | wc -l | xargs echo "file non committati nel job 2:"

# Output:
# senza 'git add -N': b/sconto.js
# con 'git add -N':    b/sconto.js b/sconto.test.js
#  2 files changed, 2 insertions(+), 1 deletion(-)
# Correzione proposta dall'agente
# base
# file non committati nel job 2: 0

Le prime due righe d'uscita sono la ragione per cui git add -N c'è: senza di esso la patch contiene solo sconto.js e il test creato dall'agente va perso in silenzio. La terza dice che il job 2 applica due file, con due righe aggiunte e una tolta, e l'ultima che dopo il commit non resta nulla di non versionato. Se un'istruzione nascosta in un file del repository spinge l'agente a fare qualcosa di dannoso, può al massimo produrre una patch, che un umano vede in una pull request. Il costo è un artefatto, un job in più e la fatica di rivedere la PR.

L'SDK: quando pilotare l'agente da codice

L'SDK serve per pipeline CI/CD, agenti personalizzati, strumenti interni o per incorporare Codex in un'applicazione. Il pacchetto TypeScript si installa con npm install @openai/codex-sdk e va usato lato server con Node.js 18 o successivo; nel registro npm la versione corrente, il 13 novembre 2026, è la 0.167.2, con licenza Apache-2.0. Quello Python si installa con pip install openai-codex, richiede Python 3.10 o successivo ed è alla stessa versione 0.167.2; il suo metadato dichiara una dipendenza esatta da openai-codex-cli-bin, quindi installare l'SDK installa anche un binario della CLI, ed è una cosa da sapere in un ambiente dove ogni dipendenza si controlla. Qui sotto l'esempio minimo TypeScript della documentazione, copiato com'è e non eseguito.

// schema da adattare, non eseguito: richiede @openai/codex-sdk e un accesso a Codex
import { Codex } from "@openai/codex-sdk";

const codex = new Codex();
const thread = codex.startThread();
const result = await thread.run(
  "Make a plan to diagnose and fix the CI failures"
);

console.log(result.finalResponse);

Un thread tiene la conversazione: un'altra run() sullo stesso thread la continua, e resumeThread(threadId) riprende un thread passato. Ho confrontato i nomi con il codice sorgente pubblico: startThread, resumeThread e run esistono, così come runStreamed per ricevere gli eventi uno alla volta, le opzioni di thread sandboxMode, modelReasoningEffort e threadSource (per etichettare i thread creati dalla tua integrazione, per esempio come ci), e outputSchema fra le opzioni del turno. In Python, aprendo il pacchetto pubblicato senza installarlo, ho trovato Codex, AsyncCodex, Sandbox con i preset read_only, workspace_write e full_access, thread_start e final_response. Il comando codex mcp-server è stato rimosso: le integrazioni esistenti passano dall'App Server. Per l'esito, ricorda che run() solleva un errore se il turno fallisce: in CI va dentro un try/catch che fa uscire il processo con codice diverso da 0.

SDK o codex exec?

  • codex exec se il tuo flusso è già uno script di shell o un passo CI: meno codice, un solo binario, output su stdout.
  • SDK se devi orchestrare più compiti, mantenere thread, gestire gli errori in un linguaggio vero o incorporare l'agente in un servizio. Aggiunge una dipendenza da mantenere e un runtime in più da aggiornare.

In dubbio, parti da codex exec e passa all'SDK quando lo script di shell comincia ad avere logica che vorresti testare: i due script di lettura e di controllo di questo articolo ne sono un esempio, perché sono già logica che merita test.

Prima di mettere un agente in CI: tre domande

  1. Che cosa succede se sbaglia? Se la risposta è «una patch che nessuno rivede», non farlo.
  2. Che cosa può leggere? Il suo ambiente contiene segreti? Se sì, il job è sbagliato.
  3. Quanto costa un'esecuzione fuori controllo? Con una chiave API non c'è un tetto automatico: imposta un limite di spesa sul tuo account e un timeout sul job. Il consumo per modello è nella parte 5.

Le tre domande vanno in quest'ordine perché la prima decide se ha senso procedere, la seconda come isolare l'agente e la terza quanto puoi permetterti di sbagliare. I due job rispondono alla seconda, la revisione umana della pull request alla prima; sulla terza la fonte non dà un tetto. La parte 7 riguarda ciò che si può delegare quando l'agente non gira sul tuo runner.

Domande frequenti

In che sandbox gira codex exec?

Per impostazione predefinita in read-only. Per consentire modifiche si passa --sandbox workspace-write; danger-full-access va usato solo in un ambiente isolato come un runner CI o un container. L'opzione --full-auto non è più supportata.

Dove va messa la chiave API in CI?

Solo sul singolo comando, con CODEX_API_KEY in linea, o nell'input openai-api-key del passo dell'azione, e non come variabile di ambiente dell'intero job quando questo esegue codice del repository. Meglio due job: uno che lancia l'agente senza permessi di scrittura e uno che applica la patch senza vedere la chiave.

Che cosa non è dimostrato qui

Non ho provato Codex, la GitHub Action né l'SDK: le uscite dei listati sono quelle dei miei script, non quelle dello strumento, e i flussi di eventi sono una copia della documentazione e un file costruito da me. Non so quanto reggano carichi concorrenti né quali limiti di frequenza si applichino alle chiavi API in CI. Prima di usarlo in un flusso di produzione, prova con un repository di scarto e osserva i costi di una settimana.

Nella stessa serie trovi anche il confronto con Claude Code, Copilot e Cursor (parte 8).

Fonti

Gli script sono stati eseguiti con Python 3.14 e git 2.53, due volte ciascuno, con uscite identiche; i due che usano jsonschema e PyYAML girano in un ambiente virtuale. I pacchetti dell'SDK sono stati esaminati senza installarli: l'indice npm e quello PyPI per versioni e requisiti, il codice sorgente TypeScript e il file wheel di Python per i nomi.

← Parte 5: modelli e costi Parte 7: cloud, subagenti, skill e MCP →

Commenti

Caricamento commenti...

Accedi per commentare

Articoli e strumenti nuovi anche su Telegram

Il canale Telegram segnala gli articoli e gli strumenti nuovi del sito.

Ti è piaciuto questo articolo?

Esplora altri contenuti sul blog o scopri i miei progetti