Perché gli agenti AI usano così tanti token (un esempio di 20 passi)

Fai una domanda a un agente, questo lavora per qualche minuto e la pagina di utilizzo mostra centinaia di migliaia di token. Nulla è rotto. Un agente è un ciclo, e ogni giro del ciclo rimanda tutto ciò che è stato detto finora (l'elenco degli strumenti, la cronologia, qualunque cosa gli strumenti abbiano restituito) come token di input. La risposta che scrive è minuscola. Ciò che rilegge più e più volte non lo è.

Cos'è un agente, in un'immagine#

Un modello di chat risponde una volta. Un agente è lo stesso modello dentro un ciclo con strumenti: leggere un file, cercare sul web, eseguire un comando. E il modello non ricorda nulla tra una chiamata e l'altra. Immagina un assistente che dimentica tutto ogni volta che riattacca: ogni volta che richiama, rileggi gli appunti dall'inizio, poi aggiungi una riga. È così che funziona l'API.

La documentazione sull'uso degli strumenti di Anthropic (verificata il 26 ottobre 2026) descrive il ciclo così:

1. La tua app invia il messaggio dell'utente e l'elenco degli strumenti.
2. Il modello risponde con stop_reason: "tool_use" e un blocco tool_use: quale strumento, con quali argomenti.
3. La tua app esegue lo strumento e invia una seconda richiesta. Contiene i messaggi precedenti, la chiamata allo strumento del modello, un blocco tool_result e lo stesso elenco di strumenti.
4. Il modello risponde, o chiede un altro strumento, e il ciclo ricomincia.

La stessa pagina dice che le richieste di uso degli strumenti vengono fatturate sul totale dell'input inviato, incluso il parametro tools, più l'output. Quindi il passo 3 non è mai "solo la parte nuova": è di nuovo tutta la conversazione.

Request 1  tools + system + task
Request 2  tools + system + task + call 1 + result 1
Request 3  tools + system + task + call 1 + result 1 + call 2 + result 2
...

È lo stesso meccanismo di perché una chat lunga costa di più, solo più veloce. Una chat cresce di un messaggio quando digiti. Un agente cresce di due blocchi a ogni passo, e nessuno digita nulla.

Tre cose viaggiano insieme a ogni passo#

L'elenco degli strumenti. Nomi, descrizioni e schemi dei parametri di ogni strumento entrano in ogni richiesta, anche quando il modello non ne usa nessuno in questo turno. La documentazione aggiunge un piccolo extra: con gli strumenti attivi, l'API aggiunge il proprio prompt per l'uso degli strumenti, 286 token su Claude Sonnet 5.5, Opus 5.5 e Haiku 5.5, e altri modelli hanno altri conteggi.

La cronologia. Il tuo compito, le chiamate agli strumenti precedenti del modello, i suoi appunti.

L'output degli strumenti. Questo è quello subdolo. Un file che l'agente ha letto, una pagina di risultati di ricerca, un log di test: una volta che entra nella cronologia, viene pagato di nuovo a ogni passo successivo.

Un token è un piccolo pezzo di testo, all'incirca una parola breve o parte di una, e ognuna di queste tre cose viene contata in token.

Un'esecuzione di 20 passi, contata#

Supponi di eseguire un piccolo agente di coding con tre strumenti (leggere un file, cercare, eseguire test) e di dargli un compito che richiede 20 passi. Prendi queste ipotesi:

• definizioni degli strumenti: 1.500 token, prompt di sistema: 500, il tuo compito: 200, quindi ogni richiesta parte da 2.200 token;
• a ogni passo il modello scrive una chiamata allo strumento di 150 token, e lo strumento restituisce 800 token;
• entrambi entrano nella cronologia, quindi ogni passo aggiunge 950 token alla richiesta successiva.

Per ottenere il totale dell'esecuzione, somma tutte e 20 le richieste. La base di 2.200 viene inviata 20 volte, e i giri vengono riportati dai passi successivi: il passo 1 non ne porta nessuno, il passo 2 uno, e così via fino a 19, che fa 190 giri in tutto.

20 × 2.200 = 44.000

950 × 190 = 180.500

44.000 + 180.500 = 224.500 token di input, e 20 × 150 = 3.000 token di output.

L'agente ha scritto 3.000 token e ne ha letti 224.500. I token di output costano più di quelli di input ciascuno (vedi token di input vs output), ma sono così pochi che è comunque il lato input a decidere il conto. Ecco quell'esecuzione ai prezzi attuali:

Su DeepSeek-V4-Flash una di queste esecuzioni costa $0.0037, su GLM-5.3-Flash $0.0046. Cento esecuzioni sono 22.450.000 token di input e 300.000 di output: $0.367 su DeepSeek-V4-Flash. La tabella sopra conta input e output insieme, e in totale i modelli lì risultano più economici di OpenRouter.

Il numero di passi conta più di quanto sembri. Un'esecuzione di 5 passi con le stesse ipotesi:

5 × 2.200 = 11.000

950 × 10 = 9.500

11.000 + 9.500 = 20.500 token di input. Quattro volte i passi hanno dato circa undici volte l'input, perché ogni nuovo passo rilegge anche tutti quelli vecchi.

Dove tagliare: quattro abitudini#

Il risultato di uno strumento è il punto più facile dove risparmiare. Supponi che un'esecuzione di test al passo 3 restituisca un log di 4.000 token. Viene poi rimandato dalle 17 richieste che seguono:

• prima: 4.000 × 17 = 68.000 token di input portati da quel singolo log;
• dopo, se lo strumento restituisce solo le 40 righe rilevanti (circa 400 token): 400 × 17 = 6.800.

Stesso compito, stessa risposta, un decimo dell'input da quel singolo risultato. Questo dà quattro abitudini:

• Restituisci meno dagli strumenti. Le righe intorno all'errore, non tutto il log; la funzione, non tutto il file. C'è un approfondimento più lungo in tenere l'output degli strumenti fuori dal contesto.
• Dai all'agente meno strumenti. Ogni definizione viaggia in ogni richiesta.
• Limita i passi e inizia un nuovo compito quando la vecchia cronologia non conta più.
• Somma l'utilizzo di ogni passo, e ferma l'esecuzione a un budget che hai scelto in anticipo. Per il lato stima, vedi come stimare il costo di un agente AI.

Conta la tua esecuzione#

Ogni risposta riporta quanti token ha ricevuto e prodotto, nel suo campo usage. Sommali su tutti i passi e hai i numeri reali del tuo agente invece delle mie ipotesi. Uno schema con l'SDK Python di OpenAI puntato su CheapTokens (messages e tools sono del tuo agente):

from openai import OpenAI

client = OpenAI(base_url="https://api.cheaptokens.dev/v1", api_key="YOUR_API_KEY")

total_in = total_out = 0
for step in range(20):  # your agent loop
    resp = client.chat.completions.create(
        model="deepseek-ai/DeepSeek-V4-Flash-0731",
        messages=messages,
        tools=tools,
    )
    total_in += resp.usage.prompt_tokens
    total_out += resp.usage.completion_tokens
    # ...run the tool, append the result to messages

print(total_in, total_out)

I due totali si inseriscono direttamente nella tabella dei costi sopra. Per cronologie lunghe come questa, DeepSeek-V4-Flash ti dà una finestra di contesto di 380K e fino a 32.768 token di output per risposta, a un unico prezzo a qualsiasi ora; GLM-5.3-Flash ha un contesto di 390K e fino a 8.192 token di output. La configurazione è nella documentazione, il prezzo attuale di ogni modello è sulla pagina dei prezzi, e il modello ha la sua pagina, DeepSeek economico.