# Claude Code: 7 regole per limitare la spesa degli agenti
> 7 regole per impostare i limiti in Claude Code, così un agente autonomo non ti lascia al verde: limiti del fornitore, Task Budgets, hook, liste consentite, interruttori di emergenza, chiavi sandbox e limiti di iterazioni.
Source: https://ailoot.ai/blog/it/ai-agent-burned-budget-claude-code/
Canonical: https://ailoot.ai/blog/it/ai-agent-burned-budget-claude-code/
Language: it
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-122
Revision: sha256-f82ff513650fff9ec45a9a253c3703d1c802a3e555389354558db32e36b6e98c
Punti chiave
Un agente autonomo con accesso illimitato al cloud può accumulare una fattura elevata in una sola notte. Analizzo 7 regole per Claude Code che puoi mettere in pratica in una sera per prevenire questo tipo di problema.
Scopri come usare il servizio nella [documentazione di Ailoot](https://ailoot.ai/docs/).
## Dove finiscono i soldi: 3 categorie di spesa per un agente autonomo
Punti chiave
Dove spende i tuoi soldi un agente autonomo? Attraverso tre canali distinti: token su Anthropic/OpenAI, risorse cloud (AWS/GCP/Yandex Cloud) e azioni a pagamento nelle API di terze parti (addebiti Stripe, gateway SMS, Twilio, bot Telegram con abbonamenti). Ogni canale ha una propria fatturazione e un proprio modo per fermare la corsa alle spese.
Non confondere questi tre canali: funzionano in modo indipendente e richiedono impostazioni diverse:
1. **Token LLM.** Claude, OpenAI o Gemini addebitano i token del contesto di input e output di ogni richiesta. I Task Budgets di Anthropic (vedi Regola 2) e un abbonamento al posto del pagamento a consumo tramite API possono essere d’aiuto.
2. **Infrastruttura cloud.** Tramite MCP o uno strumento Bash, l’agente crea risorse EC2, RDS, S3 o distribuisce funzioni Lambda. AWS Budgets, GCP o Yandex Cloud con un interruttore di emergenza possono essere d’aiuto (Regola 5).
3. **API di terze parti.** L’agente effettua un addebito con Stripe, invia 100 SMS tramite un gateway o attiva mille abbonamenti Telegram. Chiavi sandbox con ambiti limitati e un limite massimo effettivo nella dashboard del fornitore possono essere d’aiuto (Regola 6).
Seguono 7 regole. Ognuna riguarda uno o due canali.
## Come impostare un limite massimo effettivo alle spese API (Regola 1)
Punti chiave
Come si imposta un limite massimo effettivo alle spese API? Anthropic e OpenAI hanno un limite di spesa dell’organizzazione integrato che riduce automaticamente la velocità dell’account quando raggiunge l’importo specificato. Non confonderlo con gli avvisi, che si limitano a inviare un’email. Un limite massimo effettivo è una barriera; gli avvisi sono una spia. Configurali entrambi, iniziando dalla barriera.
Dove attivarlo (considera almeno 2 minuti per ogni fornitore):
**Anthropic Console.** [console.anthropic.com](https://console.anthropic.com) → Settings → Limits → Monthly spend limit. Imposta un importo che sei disposto a spendere nel mese peggiore. Quando viene raggiunto, l’API restituisce 429 e registra l’evento. Niente «ci riprovo tra un minuto»: l’accesso è bloccato fino alla fine del mese.
**OpenAI Platform.** [platform.openai.com](https://platform.openai.com/account/billing/limits) → Billing → Usage limits. Analogamente, c’è un limite flessibile (avviso via email) e un limite rigido (arresto dell’API). Impostali entrambi; imposta il limite rigido a 1,5 volte quello flessibile per lasciare tempo di reagire.
**AWS Bedrock / Google Vertex.** Se accedi a Claude/Anthropic tramite un intermediario cloud, il limite massimo effettivo deve essere sul lato cloud, non su Anthropic. Questa è la Regola 5.
Cosa **non** costituisce un limite massimo effettivo: gli avvisi via email («hai consumato l’80% del tuo budget»). Arrivano in ritardo e di notte nessuno legge le email. Solo una barriera sincrona lato fornitore.
## Come funzionano gli Anthropic Task Budgets e dove impostarli (Regola 2)
Punti chiave
Cosa sono gli Anthropic Task Budgets e da cosa ti proteggono? Sono una funzionalità beta della linea Opus 4.7/4.8 e Fable/Mythos: imposti un budget per un flusso di lavoro autonomo e Claude riduce la profondità del ragionamento quando il budget si esaurisce, terminando con un riepilogo invece di dire «è tutto, ho finito il budget» nel mezzo dell’attività. Non è una soluzione completa per le spese cloud, ma previene l’80% dei casi in cui l’agente «si è bloccato in un ciclo senza accorgersene».
Per i dettagli, consulta la [documentazione ufficiale](https://platform.claude.com/docs/en/build-with-claude/task-budgets) di Anthropic. Il punto chiave: è un **limite flessibile**, non rigido. Se l’agente ha già creato un’istanza EC2, Task Budget non la annullerà.
Come funziona in pratica: passi il campo `task_budget` nel payload della richiesta (per esempio, 100.000 token di input per l’intera attività). Claude riceve informazioni sul budget e **ridimensiona autonomamente i propri piani**, semplificando i passaggi o saltando sottoattività. Quando il budget si avvicina allo zero, conclude e restituisce un riepilogo provvisorio invece di «grazie per l’ascolto».
Limitazioni:
- **Solo API Anthropic.** Non funziona su Bedrock/Vertex, che hanno una propria fatturazione
- **Solo modelli beta** (Opus 4.7, 4.8, Fable 5, Mythos 5). Non su Sonnet 4.6 o Haiku
- **Non copre le spese cloud né le API di terze parti.** Se Claude avvia un’istanza EC2, Task Budget non interviene
Usalo insieme alla Regola 1 (limite massimo effettivo), non al suo posto.
I limiti ai costi fanno parte del context engineering: decidi cosa può e non può fare l’agente e dove si trova il suo arresto di emergenza.
## Cosa bloccare con gli hook PreToolUse in Claude Code (Regola 3)
Punti chiave
Cosa sono gli hook PreToolUse in Claude Code e perché servono? Sono script che vengono eseguiti **prima** che Claude effettui una chiamata a uno strumento. Possono bloccare una richiesta (`exit 2`), richiedere la conferma dell’utente o lasciarla passare senza chiedere. Il punto chiave: gli hook vengono eseguiti prima di `--dangerously-skip-permissions`. Questo significa che puoi bloccare azioni pericolose anche in modalità di bypass.
In Claude Code (al 1° giugno 2026), i permessi vengono valutati nell’ordine **deny → ask → allow**. Questo significa che:
- verifica separatamente la modalità dei permessi selezionata; una regola deny provata in modalità normale non dimostra protezione in bypass
- se un hook restituisce `exit 2`, la chiamata allo strumento viene bloccata
- `allowedTools` si applica solo quando le regole di negazione e gli hook non intervengono
Un hook PreToolUse minimo che controlla alcune forme testuali di comandi pericolosi. È un filtro di testo, non un parser shell completo o un confine di accesso: comandi equivalenti, script, altri strumenti e risorse cloud esistenti richiedono controlli separati.
```bash
#!/usr/bin/env bash
# ~/.claude/hooks/block-dangerous-bash.sh
INPUT=$(cat)
if ! COMMAND=$(printf '%s\n' "$INPUT" | jq -er '.tool_input.command | select(type == "string")'); then
echo "Blocked: invalid Bash hook input" >&2
exit 2
fi
# Controlla gli schemi elencati; non copre ogni operazione equivalente
if echo "$COMMAND" | grep -qiE '(rm -rf|aws s3 rb|terraform destroy|kubectl delete|drop database)'; then
echo "Blocked: destructive command" >&2
exit 2
fi
exit 0
```
Salva lo script nel percorso indicato, verifica la disponibilità di `jq` e rendilo eseguibile con `chmod +x ~/.claude/hooks/block-dangerous-bash.sh`. Associalo a `~/.claude/settings.json`:
```json
{
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"hooks": [{ "type": "command", "command": "~/.claude/hooks/block-dangerous-bash.sh" }]
}
]
}
}
```
Consulta la [documentazione ufficiale](https://code.claude.com/docs/en/permissions).
Controlla `/hooks` per confermare la registrazione, poi passa allo script JSON di prova innocuo senza eseguirne il campo comando. Una forma distruttiva elencata deve restituire 2; un comando innocuo, 0. Prova anche input malformati. La regex controlla solo le chiamate Bash corrispondenti: usa credenziali ristrette e isolamento per il vero confine di autorità. Consulta l’[esempio ufficiale di input e output degli hook](https://code.claude.com/docs/en/hooks-guide#read-input-and-return-output).
## Perché usare una whitelist `allowedTools` e perché `--dangerously-skip-permissions` non va usato sull’host (Regola 4)
Punti chiave
Dove si inserisce la lista consentita degli strumenti e perché l’host è un posto inadeguato per la modalità di bypass? `allowedTools` in settings.json è un elenco di comandi specifici che l’agente può eseguire senza conferma; per tutto il resto ti viene chiesto il permesso. `--dangerously-skip-permissions` disattiva completamente le richieste di conferma, quindi non eseguirlo sulla macchina host, usalo solo in un container o in una VM.
Una whitelist applica il principio del privilegio minimo. Invece di «consenti tutto» (`--dangerously-skip-permissions`), aggiungi solo ciò che serve all’attività:
```json
{
"permissions": {
"allow": [
"Bash(npm install:*)",
"Bash(npm run build)",
"Bash(git add:*)",
"Bash(git commit:*)",
"Read(./src/**)",
"Write(./src/**)"
],
"deny": [
"Bash(rm -rf:*)",
"Bash(curl * | sh)",
"Write(/etc/**)",
"Write(~/.ssh/**)"
]
}
}
```
Cosa bisogna sapere sulla modalità di bypass:
- **Linux/macOS rifiutano di avviare Claude Code in modalità di bypass come root o con sudo**: è una protezione integrata
- Sulla tua macchina, la modalità di bypass disattiva tutte le richieste di conferma e l’agente può eseguire `rm -rf` su qualsiasi cosa, aprire chiavi SSH e caricare dati sul cloud
- **Non eseguire mai** `--dangerously-skip-permissions` sull’host, solo in:
- un container Docker con un montaggio limitato del volume (solo la cartella necessaria)
- una VM isolata (Multipass, Lima, Orbstack)
- GitHub Codespaces / Replit / un’altra sandbox
Un comando docker run minimo per la modalità di bypass:
```bash
docker run --rm -it \
-v "$PWD:/workspace" \
-w /workspace \
--network host \
ghcr.io/anthropics/claude-code:latest \
claude --dangerously-skip-permissions
```
Se l’agente ha bisogno di credenziali cloud, usa **chiavi separate con ambiti limitati**, non quelle principali (Regola 6).
## Come impostare avvisi sul budget cloud con un interruttore di emergenza in AWS, GCP e Yandex Cloud (Regola 5)
Punti chiave
Un avviso budget riporta spesa osservata o prevista e può arrivare tardi. Una funzione di risposta può bloccare nuove operazioni dell’agente oppure arrestare risorse specifiche: sono azioni diverse. Disabilitare una chiave IAM non ferma gli addebiti delle risorse già attive. Definisci e prova separatamente il loro arresto.
Come configurarlo in ciascun servizio cloud:
**AWS Budgets** ([documentazione](https://aws.amazon.com/aws-cost-management/aws-budgets/)). Crea un budget mensile con soglie (50%, 80%, 100%). Alla soglia del 100%, un argomento SNS può richiamare una Lambda di risposta. L’esempio seguente disattiva soltanto le chiavi IAM dell’utente nominato: non arresta risorse e non stabilisce un tetto rigido di spesa:
```python
import boto3
def lambda_handler(event, context):
iam = boto3.client('iam')
# Deactivate all keys for the 'claude-agent' user
keys = iam.list_access_keys(UserName='claude-agent')['AccessKeyMetadata']
for key in keys:
iam.update_access_key(
UserName='claude-agent',
AccessKeyId=key['AccessKeyId'],
Status='Inactive'
)
return {'statusCode': 200, 'body': 'IAM keys deactivated; existing resources unchanged'}
```
**Procedura circoscritta di arresto delle risorse:** per una sandbox dedicata con istanze EC2 approvate basate su EBS, registra prima account, regioni e ID esatti. Nella console EC2 seleziona solo quelle istanze → **Instance state → Stop instance** → conferma e verifica `stopped` per ciascuna. Conserva prima i dati necessari dell’instance store: l’arresto li cancella. Controlla che scheduler o sistemi di scaling approvati non le sostituiscano. Ferma quel consumo di calcolo, non ogni costo dell’account: esamina separatamente storage conservato e altri servizi. Segui la [procedura EC2 ufficiale](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Stop_Start.html).
La [documentazione AWS Budgets](https://docs.aws.amazon.com/cost-management/latest/userguide/budgets-managing-costs.html) avverte che le notifiche sono in ritardo rispetto all’uso e altri costi possono maturare prima e dopo. Attivarsi al 100% non impone quindi un tetto monetario esatto.
**GCP Budget Alerts**. Crea un budget → argomento Pub/Sub → Cloud Function che disattiva il Service Account. Un consiglio importante tratto dalla documentazione: **gli avvisi inviano solo notifiche, non arrestano i servizi**, quindi la Cloud Function è essenziale.
**Yandex Cloud** ([documentazione](https://yandex.cloud/ru/docs/billing/concepts/budget)). Imposta i budget in Billing → Budgets e aggiungi quote delle risorse come limite massimo effettivo. Puoi collegare le notifiche a un bot Telegram tramite Cloud Functions.
**OpenAI API**. I limiti di spesa flessibile e rigido sono direttamente nella dashboard: il limite rigido arresta automaticamente l’API; non serve Lambda.
Usa un limite rigido del fornitore verificato dove disponibile, avvisi budget ritardati, credenziali ristrette e una risposta provata per le risorse specifiche creabili dall’agente. Revocare credenziali blocca alcune nuove operazioni; per il consumo in corso serve verificare l’arresto. Né un avviso né il successo della Lambda di revoca dimostrano che tutta la fatturazione sia ferma.
## Perché un agente ha bisogno di una chiave API sandbox separata con ambito limitato (Regola 6)
Punti chiave
Perché un agente ha bisogno di una chiave API separata? Per contenere i danni in caso di errore. Crea un utente IAM o un Service Account dedicato a un solo agente, assegnagli le autorizzazioni minime (EC2, non *), e collegalo a un progetto di fatturazione separato con un limite massimo effettivo. Se l’agente consuma tutto, brucerà i suoi 50 $ in un’ora, non l’intero budget aziendale.
Configurazione AWS minima:
1. Crea l’utente IAM `claude-agent-scan`
2. Policy: solo le azioni richieste (per esempio, `ec2:RunInstances` in una regione con dimensione `t3.micro`, senza un indirizzo IP elastico VPC)
3. Collegalo a un account AWS separato (tramite Organizations) con un budget mensile di 100 $
4. Genera chiavi di accesso e consegnale **solo all’agente**; non inserirle nel tuo `~/.aws/credentials`
5. Al termine della sessione, ruota le chiavi o elimina l’utente
Lo stesso vale per gli altri fornitori:
- **OpenAI / Anthropic:** una chiave API separata per ogni agente, un limite massimo effettivo per ogni chiave nella dashboard e tag `agent_id` nei metadati della richiesta
- **Stripe / YooKassa:** una chiave API con restrizioni per una sola azione (per esempio, solo `charges:read`) e, se possibile, un commerciante separato
- **Telegram Bot API:** un token bot separato, non quello principale
Qui vale il vecchio principio di sicurezza: **privilegio minimo**: l’agente ottiene esattamente ciò che serve all’attività, neanche un byte in più. Se l’attività consiste nello «scansionare la rete», non concedergli `ec2:*` e `s3:*`; concedigli solo `ec2:DescribeInstances` e basta.
## Quando usare una simulazione preliminare e un limite alle iterazioni (Regola 7)
Punti chiave
Perché far mostrare all’agente il piano prima dell’avvio e quante iterazioni al massimo consentire? Plan Mode è una funzionalità integrata di Claude Code: prima l’agente descrive cosa intende fare e tu lo approvi. È un controllo preliminare gratuito. Inoltre, `--max-turns N` limita il numero di passaggi in una sessione, così l’agente non può continuare all’infinito. Per la modalità autonoma, imposta al massimo 10–30 turni.
Plan Mode (`/plan`) si attiva all’inizio di una sessione. L’agente prepara un piano, lo mostra nella chat, attende l’approvazione e **solo dopo** si mette al lavoro. È gratuito e previene il 70% dei casi in cui qualcuno dice «ops, pensavo che me lo avrebbe chiesto prima».
`--max-turns` è un’opzione di avvio. Ogni turno è un ciclo di «l’agente ragiona + chiamata allo strumento + risultato». Per le attività autonome:
- modifica piccola: 5–10 turni
- attività media: 15–30 turni
- attività autonoma grande: 50–80 turni
Tecniche aggiuntive:
- **Timeout di tempo reale** con il comando Linux `timeout`:
```bash
timeout 1800 claude --dangerously-skip-permissions --max-turns 30 -p "scan task"
# 1800 seconds = 30 minutes. Stop the process gracefully.
```
- Registra ogni chiamata agli strumenti in un file con un hook PostToolUse per poter vedere cos’è successo in seguito
- **Monitoraggio cron**: ogni 5 minuti controlla che non ci siano 10 processi Claude in esecuzione contemporaneamente (un segnale tipico che qualcosa è andato storto)
## Una checklist pronta all’uso di 5 minuti prima di avviare Claude Code in modalità autonoma
Punti chiave
Cosa deve essere pronto prima di premere Invio per un’attività autonoma? Sette caselle, ognuna richiede circa un minuto. Se anche una sola è vuota, non avviare l’agente.
**Checklist prima di `claude --dangerously-skip-permissions`:**
```
[ ] 1. Limite massimo effettivo presso il fornitore API (Anthropic Console → Limits → Monthly spend limit)
[ ] 2. Task Budget nel payload della richiesta (se usi Opus 4.7+/Fable/Mythos)
[ ] 3. Hook PreToolUse per bloccare rm -rf, aws s3 rb, terraform destroy
[ ] 4. Whitelist allowedTools in settings.json oppure lavoro all’interno di un container Docker
[ ] 5. Avvisi budget cloud ritardati + revoca chiavi e arresto risorse approvato e verificato
[ ] 6. Chiavi API sandbox (una chiave separata per l’agente, non quella principale)
[ ] 7. --max-turns N + timeout di NNN secondi + monitoraggio cron dei processi
```
Se sono tutte e sette, avvia l’agente. Se ne manca anche una sola, **fermalo e configuralo**. Trenta minuti adesso possono farti risparmiare 6.000–500.000 $ più avanti.
Un esempio per contesto: un vibe coder ha avviato un’app di negozio online con la password predefinita del database postgres. Nel giro di un paio di giorni qualcuno l’ha trovata, ha installato miner e distribuito i propri backdoor. È stato necessario terminare il server e la fattura del mese è aumentata a causa del mining di criptovalute di qualcun altro.
Questa storia riguarda la categoria 3 della Sezione 1 (terze parti che eseguono attività sulla tua infrastruttura), ma la logica è la stessa: i controlli sulle spese non dovrebbero dipendere da chi le ha avviate: il tuo agente, un dipendente o un miner in Nigeria.
Approfondimenti:
- [Come proteggere Claude Code dai danni](https://ailoot.ai/blog/it/claude-code-safe-overnight-setup/): parla di `--dangerously-skip-permissions` e dei permessi da un’altra prospettiva
- [Sicurezza nel vibe coding](https://ailoot.ai/blog/it/vibe-coding-security/): il pilastro della sicurezza
- [Come non esaurire i limiti di Claude Code in un giorno](https://ailoot.ai/blog/it/claude-code-token-limits-saving/): parla dei token dell’abbonamento (non confonderla con questa guida alle fatture cloud)
### Fonti
- [Documentazione Anthropic: Task Budgets](https://platform.claude.com/docs/en/build-with-claude/task-budgets)
- [Documentazione Claude Code: configurare i permessi](https://code.claude.com/docs/en/permissions)
- [AWS Budgets: configurare budget personalizzati per costi e utilizzo](https://aws.amazon.com/aws-cost-management/aws-budgets/)
- [Yandex Cloud: Budgets](https://yandex.cloud/ru/docs/billing/concepts/budget)
Scopri [Ailoot](https://ailoot.ai/).
## Domande frequenti
### Revocare le chiavi IAM dell’agente ferma la fattura cloud?
No. Blocca nuove richieste autenticate con quelle chiavi, mentre le risorse esistenti possono continuare a generare costi. Mantieni un elenco delle risorse di tua competenza, arresta le istanze approvate, verificane lo stato e controlla separatamente storage conservato e altri servizi.
### La regex di esempio può far rispettare un confine completo di sicurezza?
No. Esamina solo le chiamate Bash corrispondenti e alcuni testi di comando. Prova lettura del JSON e codici di uscita, ma usa permessi cloud ristretti e isolamento per il vero confine d’accesso. Operazioni equivalenti e altri strumenti possono sfuggire al filtro.
## Ailoot · L’azienda e il suo portafoglio di progetti
Ailoot si basa su un’esperienza operativa consolidata, un’ampia base di clienti, un servizio stabile e un controllo costante dei KPI.
L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.
Ailoot mette questa esperienza operativa al servizio dell’accesso API alle funzioni AI nei prodotti dei clienti, negli agenti, nelle applicazioni e nelle automazioni.