Il mio agente di programmazione chiedeva il permesso per ogni minimo passaggio
Il mio assistente AI aveva un problema importante. Non era che si rifiutasse di chiedere il permesso. Era che chiedeva il permesso troppo spesso.
Gli assegnavo un compito semplice, come leggere un PDF. L'assistente compiva una mossa, chiedeva l'approvazione, eseguiva il comando e poi chiedeva immediatamente di nuovo per il passaggio successivo. Un singolo compito si trasformava in un ciclo infinito di prompt.
I prompt di approvazione sono necessari. Si vuole che un assistente locale si fermi prima di eseguire comandi, scrivere file o aprire app. Ma il lavoro vero richiede molti passaggi. Leggere un PDF comporta il controllo della presenza di Python, la ricerca di un convertitore, l'esecuzione di quel convertitore e la lettura del testo.
Se ogni singolo passaggio richiede l'approvazione, smetti di valutare il rischio. Inizi a cliccare attraverso le interruzioni solo per farle sparire. Questo ti abitua a ignorare il sistema di sicurezza. Ed è più pericoloso che non avere alcuna sicurezza.
Il vecchio flusso di lavoro era questo:
- L'assistente sceglie uno strumento
- La policy richiede conferma
- L'utente approva
- Lo strumento viene eseguito
- L'assistente chiede di nuovo per lo strumento successivo
L'assistente non coglieva l'intento dell'utente. Non stavi approvando una piccola azione isolata. Stavi approvando un compito completo.
Ho cambiato il modo in cui funziona CliGate. Ora, una volta approvata la prima azione in una chat, il sistema imposta un flag. Questo permette ai passaggi successivi di continuare senza nuovi cicli di approvazione. L'assistente riceve comunque i risultati reali per poter continuare a lavorare.
Ho anche aggiunto una via d'uscita: /safe. Questo comando riattiva la modalità di conferma esplicita.
Ho anche risolto un bug linguistico. Quando il sistema proseguiva un compito, a volte cambiava la lingua dei prompt. Se parlavi cinese, l'assistente passava all'inglese per il prompt successivo. Ora, l'assistente analizza il tuo ultimo messaggio reale per scegliere la lingua corretta.
La soluzione non è disabilitare le approvazioni. La soluzione è ricordare il motivo per cui l'utente ha dato l'approvazione.
Per gli strumenti locali, usa la fiducia basata sul compito (task-scoped trust):
- Chiedi prima di superare un confine importante
- Ricorda l'approvazione per il compito corrente
- Fornisci un modo per tornare alla modalità restrittiva
- Non permettere ai messaggi di sistema di cambiare l'intento dell'utente
Ecco come implemento le approvazioni in CliGate. È il mio piano di controllo locale per Claude Code, Codex CLI e Gemini CLI.
Come gestite la "stanchezza da approvazione" (approval fatigue)? Approvate per ogni chiamata di strumento, per compito o per sessione?
Il mio agente di programmazione mi chiedeva il permesso per ogni minimo passaggio
Ultimamente sto sperimentando vari agenti di programmazione basati su AI e, sebbene siano incredibilmente potenti, ho riscontrato un problema frustrante: la "fatica da permessi".
Ogni volta che l'agente voleva fare qualcosa, anche il compito più banale, mi chiedeva il permesso:
- "Posso creare il file
utils.py?" - "Posso eseguire
npm install?" - "Posso leggere
package.json?" - "Posso modificare la riga 42 di
main.py?"
All'inizio sembrava una buona misura di sicurezza, ma in breve tempo è diventato un ostacolo alla produttività. Invece di programmare, passavo il tempo a cliccare "Sì" su infinite richieste di conferma.
Il problema: Interruzioni costanti
Il flusso di lavoro ideale con un agente AI dovrebbe essere simile a quello di un collaboratore senior: gli dai un obiettivo di alto livello e lui lo esegue, interpellandoti solo quando incontra un ostacolo importante o ha bisogno di una guida architettonica.
Invece, il mio agente si comportava come un junior developer troppo spaventato di commettere anche un solo errore. Questo continuo cambio di contesto interrompeva il mio "flow" e rendeva il processo più lento rispetto al semplice scrivere il codice da solo.
La soluzione: Autonomia basata sulla confidenza
Ho deciso di implementare un sistema di "autonomia basata sulla confidenza". L'idea è di passare da un approccio binario "chiedi tutto" a uno in cui l'agente decide se procedere in base al proprio livello di confidenza.
Ecco la logica:
- Punteggio di confidenza: Per ogni azione che l'agente intende intraprendere, deve generare un punteggio di confidenza compreso tra 0 e 1.
- Soglia di autonomia: Ho impostato una soglia (ad esempio, 0.8).
- Logica decisionale:
- Se
confidence_score >= soglia, l'azione viene eseguita automaticamente. - Se
confidence_score < soglia, l'agente deve chiedere il permesso all'utente.
- Se
Esempio di implementazione (Pseudo-codice)
def execute_action(action, confidence_score, threshold=0.8):
if confidence_score >= threshold:
print(f"Executing action automatically: {action.name}")
return action.run()
else:
user_approval = input(f"Agent wants to execute '{action.name}' (Confidence: {confidence_score}). Proceed? (y/n): ")
if user_approval.lower() == 'y':
return action.run()
else:
print("Action cancelled by user.")
return None
Risultati
L'implementazione di questo sistema ha cambiato tutto.
- Compiti banali: Creare file, leggere file esistenti o eseguire test unitari che non toccano il database vengono ora gestiti senza interruzioni.
- Compiti critici: Modificare file di configurazione sensibili, eseguire comandi distruttivi o effettuare il deploy in produzione richiedono ancora l'approvazione manuale, poiché il punteggio di confidenza per queste azioni è basso o viene forzato a zero.
Il risultato è un agente che sembra molto più capace e autonomo, pur mantenendo i necessari limiti di sicurezza (guardrails).
Conclusione
Se stai costruendo o utilizzando agenti AI, non accontentarti di un modello di permessi binario. Introduci una dimensione di incertezza. Lascia che l'agente sia autonomo quando è sicuro di sé e chiedi aiuto solo quando ne ha davvero bisogno.