---
title: "Costo di un agente di coding: passi, contesto e cache"
description: "Perché un agente di coding costa di più a ogni passo man mano che va avanti, quanto cambia la cache e quando una sessione flat batte il pagamento a token."
url: https://broadrouter.com/it/blog/ai-coding-agent-run-cost/
lang: it
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/blog/ai-coding-agent-run-cost/) (aggiornato il 2026-11-15).

# Costo di un’esecuzione di un agente di coding: passi, contesto, cache

A cura del team di BroadNet Inference · 7 min di lettura · Pubblicato 2026-11-15

Un agente rinvia tutto il contesto a ogni passo, quindi l’input cresce con il quadrato del numero di passi: 60 passi costano circa 3,5 volte l’input di 30. La cache decide gran parte della fattura; con una cronologia solo in aggiunta, oltre il 90% dell’input può essere fatturato alla tariffa in cache. Moltiplica il costo per esecuzione per le esecuzioni mensili e confrontalo con una sessione flat.

## Punti chiave

-   L’input totale di un’esecuzione è passi × contesto di base + crescita per passo × passi × (passi − 1) ÷ 2. Il numero di passi conta più di qualsiasi altro fattore.
-   Con una cronologia solo in aggiunta, sono nuovi solo i token aggiunti dall’ultima chiamata. Nell’esempio di calcolo, il 94% dell’input di un’esecuzione da 30 passi resta in cache.
-   Ai prezzi pubblicati da BroadNet per DeepSeek V4.1 Flash, la stessa esecuzione da 30 passi costa circa 8 volte di più senza cache che con la cache nel caso migliore.
-   Compattare o modificare la cronologia iniziale azzera la cache. Fallo di rado e a grandi passi.
-   Una sessione flat conviene quando esecuzioni mensili × costo per esecuzione supera il prezzo del piano. Una sessione esegue una richiesta alla volta, quindi il tempo per esecuzione limita quante esecuzioni stanno in un mese.

**In questa pagina**

1.  Come cresce il contesto durante un’esecuzione?
2.  Com’è un’esecuzione d’esempio?
3.  Quanto cambia la fattura con la cache?
4.  Come stimi la tua esecuzione?
5.  Cosa fa costare un’esecuzione più della stima?
6.  Quando una sessione flat batte il pagamento a token?
7.  Dove si inserisce BroadNet Inference

Un agente di coding non paga per attività. Paga per passo, e ogni passo rinvia tutta la conversazione fin lì. Per questo il costo di un’esecuzione dipende molto più da quanti passi richiede, e da quanta parte del contesto è in cache, che dal prezzo per token. Questo articolo costruisce il costo di un’esecuzione a partire da questi elementi, con i numeri, e mostra quando una sessione flat batte il pagamento a token.

Per capire da dove vengono i token di ogni chiamata (schemi dei tool, letture di file, cronologia), vedi [dove vanno i token di un ciclo da agente](https://broadrouter.com/it/blog/agent-token-budget/). Questo articolo riguarda l’aritmetica di un’intera esecuzione.

## Come cresce il contesto durante un’esecuzione?

Ogni chiamata contiene:

-   un **contesto di base** inviato a ogni chiamata: system prompt, definizioni dei tool, file di regole, una mappa del repository;
-   **tutto ciò che hanno aggiunto i passi precedenti**: le risposte e le chiamate ai tool del modello, il contenuto dei file e l’output dei comandi;
-   la nuova istruzione o il nuovo risultato di un tool.

Chiama quel contesto di base _B_ e i token che ogni passo aggiunge _g_. Il passo 1 invia _B_. Il passo 2 invia _B + g_. Il passo _n_ invia _B + (n − 1) × g_. Sommando, un’esecuzione di _n_ passi invia:

**Input totale = n × B + g × n × (n − 1) ÷ 2**

Il secondo termine cresce con il quadrato del numero di passi. Ecco perché le esecuzioni lunghe sorprendono: l’ultimo passo di un’esecuzione da 60 è molto più grande del primo, e ogni passo nel mezzo paga di nuovo per tutti quelli precedenti.

## Com’è un’esecuzione d’esempio?

Prendi un agente con un contesto di base di 15.000 token (system prompt, una dozzina di tool e una mappa del repository). Ogni passo aggiunge 3.000 token: un file o un log di test più la risposta del modello. Ogni passo scrive 800 token di output, ragionamento compreso.

| Passi | Input totale | Output | Chiamata singola più grande |
| --- | --- | --- | --- |
| 10 | 285.000 | 8.000 | 42.000 |
| 30 | 1.755.000 | 24.000 | 102.000 |
| 60 | 6.210.000 | 48.000 | 192.000 |

Passare da 30 a 60 passi raddoppia il lavoro ma moltiplica l’input per circa 3,5. L’output si limita a raddoppiare. In queste esecuzioni l’input vale da 36 a 130 volte l’output, ed è per questo che per gli agenti contano soprattutto il prezzo dell’input e quello dell’input in cache.

Anche la chiamata più grande deve stare nella [finestra di contesto](https://broadrouter.com/it/glossary/context-window/). 192.000 token stanno in DeepSeek V4.1 Flash e GLM 5.3 (1.048.576 token ciascuno) e in Qwen3.8 27B (262.144). Non stanno in Gemma 4 VL 26B (32.768): in questo esempio la settima chiamata è già troppo grande.

## Quanto cambia la fattura con la cache?

I provider fatturano un prefisso del prompt ripetuto a una tariffa più bassa per l’[input in cache](https://broadrouter.com/it/glossary/cached-input-tokens/). Un agente che si limita ad aggiungere alla sua cronologia invia ogni volta lo stesso prefisso più qualcosa, quindi nel caso migliore sono nuovi solo i token aggiunti dall’ultima chiamata:

**Input nuovo (caso migliore) = B + (n − 1) × g**

Tutto il resto è un cache hit. La quota di input in cache sale man mano che l’esecuzione si allunga:

| Passi | Input nuovo, caso migliore | Quota in cache |
| --- | --- | --- |
| 10 | 42.000 | 85% |
| 30 | 102.000 | 94% |
| 60 | 192.000 | 97% |

Gli agenti reali raramente raggiungono il caso migliore, quindi conviene dare un prezzo a tre casi. Ai prezzi di BroadNet per DeepSeek V4.1 Flash ($0.175 di input, $0.0055 in cache, $0.52 di output per 1M di token, pubblicati il 2026-11-14), ecco il costo di ogni esecuzione rispetto al caso migliore da 30 passi:

| Passi | Cache nel caso migliore | 80% in cache | Senza cache |
| --- | --- | --- | --- |
| 10 | 0,33× | 0,39× | 1,37× |
| 30 | 1× | 2,07× | 8,11× |
| 60 | 2,33× | 6,84× | 28,2× |

Saltano all’occhio due cose. Senza cache, un’esecuzione da 60 passi costa 28 volte un’esecuzione da 30 passi ben messa in cache. E la cache conta di più quanto più l’esecuzione si allunga. Nel caso migliore da 30 passi, l’output è circa un terzo del costo, l’input nuovo meno della metà e l’input in cache meno di un quarto: dopo la cache, il prossimo risparmio sta nell’output.

La cache non è qualcosa che si accende. Dipende dal fatto che il provider conservi il prefisso e che il tuo agente non lo cambi. La guida di OpenAI descrive una corrispondenza esatta del prefisso con una lunghezza minima memorizzabile. L’API di DeepSeek salva unità di cache alla fine dell’input e dell’output di ogni richiesta, quindi una richiesta successiva che estende la precedente può fare hit. La [pagina dei prezzi](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-ai-coding-agent-run-cost&utm_content=body) di BroadNet dice che l’input in cache non richiede configurazione, e la sua documentazione riporta gli hit in `usage.prompt_tokens_details.cached_tokens` quando il modello li fornisce. Il catalogo dei modelli di BroadNet elenca DeepSeek V4.1 Flash tra i «models we never ran on our hardware» (traduzione: modelli che non abbiamo mai eseguito sul nostro hardware), e i suoi Termini (§7.3) coprono il modello «when partner-hosted» (traduzione: quando è ospitato da un partner), quindi su BroadNet viene servito tramite un partner. Misura la tua percentuale di hit invece di presumere i numeri di DeepSeek. Scrivi il prefisso in modo che possa andare in cache: [struttura del prompt per la cache](https://broadrouter.com/it/blog/prompt-structure-for-caching/).

## Come stimi la tua esecuzione?

Questo script legge i prezzi attuali dal [pricing.json](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-ai-coding-agent-run-cost&utm_content=body) pubblico di BroadNet, quindi non invecchia mai, e stampa i totali di token e il costo per esecuzione per ciascun caso di cache:

```python
import json, urllib.request

PRICES = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
m = next(x for x in PRICES["models"] if x["id"] == "broadnet/deepseek-v4.1-flash")
p_in, p_cached, p_out = m["input_per_m"], m["cached_input_per_m"], m["output_per_m"]

def run_tokens(steps, base=15_000, growth=3_000, out_per_step=800, cache_rate=None):
    total_in = steps * base + growth * steps * (steps - 1) // 2
    if cache_rate is None:                      # best case: only new tokens miss
        new_in = base + (steps - 1) * growth
    else:
        new_in = round(total_in * (1 - cache_rate))
    return total_in, new_in, steps * out_per_step

def run_cost(total_in, new_in, out):
    return ((new_in * p_in) + (total_in - new_in) * p_cached + out * p_out) / 1e6

for steps in (10, 30, 60):
    for label, rate in (("best", None), ("80%", 0.8), ("none", 0.0)):
        t, n, o = run_tokens(steps, cache_rate=rate)
        print(f"{steps:>3} steps  cache {label:>4}  input {t:>9,}  new {n:>9,}  "
              f"output {o:>6,}  cost/run {run_cost(t, n, o):.4f} USD")
```

Sostituisci i valori predefiniti con i tuoi numeri. Non indovinarli; leggili da un’esecuzione reale:

1.  Registra `prompt_tokens`, `prompt_tokens_details.cached_tokens` e `completion_tokens` per ogni chiamata, come nell’[articolo sul budget di token di un agente](https://broadrouter.com/it/blog/agent-token-budget/).
2.  **B** è il `prompt_tokens` della prima chiamata. **g** è l’aumento medio di `prompt_tokens` da una chiamata alla successiva.
3.  L’output per passo è la media di `completion_tokens`. Include i [token di ragionamento](https://broadrouter.com/it/glossary/reasoning-tokens/), che si pagano come output.
4.  La tua percentuale di cache reale è la somma di `cached_tokens` divisa per la somma di `prompt_tokens`.

Lo [stimatore gratuito del costo di un’esecuzione](https://broadrouter.com/tools/agent-run-cost-estimator/) fa lo stesso calcolo nel browser, così puoi provare altri numeri di passi, tassi di crescita e percentuali di cache senza scrivere codice.

## Cosa fa costare un’esecuzione più della stima?

-   **Retry.** Una chiamata a un tool fallita o un retry dopo un 429 è un’altra chiamata con tutto il contesto. Contali come passi.
-   **Cambiare il prefisso.** Un timestamp nel system prompt, tool elencati in un ordine diverso o un file di regole modificato a metà esecuzione trasformano di nuovo l’input in cache in input nuovo, dal punto della modifica in poi.
-   **Compattazione.** Riassumere la cronologia riduce il contesto, e quindi l’input successivo, ma la nuova cronologia non è mai stata in cache, quindi la chiamata successiva paga il prezzo pieno dell’input. Compatta di rado e a grandi passi; [la gestione del contesto per agenti di lunga durata](https://broadrouter.com/it/blog/long-running-agent-context-management/) spiega quando.
-   **Output dei tool voluminoso.** Un log di test da 20.000 righe aggiunto al passo 5 viaggia con ogni passo successivo. Nella formula aggiunge 20.000 × (passi rimanenti) token di input.
-   **Sforzo di ragionamento.** Uno sforzo alto può moltiplicare l’output per passo. Imposta `reasoning_effort` su `low` per le modifiche di routine.
-   **Vagare.** Un agente che impiega 60 passi per un’attività da 30 paga il quadrato, non il doppio. Un limite ai passi è un limite al costo. [Dieci modi per ridurre i costi degli agenti di coding](https://broadrouter.com/it/blog/cut-coding-agent-llm-costs/) descrive le leve.

## Quando una sessione flat batte il pagamento a token?

Trasforma il costo per esecuzione in una cifra mensile: **costo mensile = costo per esecuzione × esecuzioni al mese**. Poi confrontala con un piano flat. Su BroadNet i piani coprono DeepSeek V4.1 Flash senza contatore di token: Full Moon costa $60 al mese, Orbit $15 a settimana e Meteor $1 all’ora, ognuno per sessione.

**Esecuzioni al mese per il pareggio = prezzo del piano ÷ costo per esecuzione.**

Due cose rendono questo confronto meno semplice di quanto sembri:

1.  **La tua percentuale di cache determina il lato a token.** Con una percentuale di cache alta, il pagamento a token su Flash costa poco e servono molte esecuzioni per superare $60. Con una bassa, lo superi in fretta. L’articolo sul flat mostra il pareggio come volume mensile: circa 917 milioni di di input e 46 milioni di di output con l’80% in cache ([i conti del punto di pareggio](https://broadrouter.com/it/blog/flat-rate-vs-pay-per-token-llm-api/)).
2.  **Il tempo fissa il tetto del lato flat.** Una sessione esegue una richiesta alla volta. Se una chiamata richiede in media 20 secondi (prefill, circa 800 token di output a circa 100 token al secondo, più il tempo dei tool), un’esecuzione da 30 passi richiede circa 10 minuti. In una sessione stanno quindi al massimo circa sei esecuzioni all’ora. Più agenti in parallelo richiedono più sessioni.

Per brevi raffiche Meteor funziona allo stesso modo su scala ridotta: se in un’ora stanno sei esecuzioni, ognuna costa $1 ÷ 6. Confrontalo con il costo a token di un’esecuzione calcolato dallo script. Per provare i tuoi volumi, usa il [calcolatore flat vs a token](https://broadrouter.com/tools/flat-rate-vs-per-token-calculator/).

| Il tuo schema d’uso | Di solito costa meno |
| --- | --- |
| Poche esecuzioni brevi al giorno | A token |
| Esecuzioni lunghe con cache scarsa | Sessione flat |
| Agenti attivi per gran parte della giornata lavorativa | Sessione flat |
| Più agenti in parallelo, tutto il giorno | Una sessione flat per agente |
| Serve il tool calling nativo su BroadNet | A token su GLM 5.3 o Qwen3.8 27B |

## Dove si inserisce BroadNet Inference

BroadNet riporta i token in cache e di ragionamento nel blocco usage, quindi puoi misurare ogni numero qui sopra dalle tue esecuzioni. DeepSeek V4.1 Flash ha un prezzo basso per l’input in cache e un contesto di 1.048.576 token, e i piani illimitati tolgono il suo contatore di token; [come funzionano le sessioni](https://broadrouter.com/it/guides/unlimited-llm-api-sessions/).

Prima verifica un limite. La documentazione di BroadNet indica il tool calling solo per [GLM 5.3](https://broadrouter.com/it/models/glm-5.3/) e [Qwen3.8 27B](https://broadrouter.com/it/models/qwen3.8-27b/), e nessuno dei due è su un piano flat. Gli agenti che modificano tramite testo, come [Aider](https://broadrouter.com/it/guides/aider-unlimited-deepseek/), non hanno bisogno di chiamate native ai tool. Se il tuo ne ha bisogno, prova DeepSeek V4.1 Flash con il tuo agente prima di comprare un piano, oppure metti a budget GLM o Qwen a token. E se il tuo agente gira solo ogni tanto, pagare a token di solito costerà meno di qualsiasi piano flat.

Strumenti gratuiti sul tema (in inglese)

-   [Agent run cost estimator](https://broadrouter.com/tools/agent-run-cost-estimator/) Context growth per step, total tokens and cost of one agent run, with a DeepSeek session comparison.
-   [LLM batch job planner](https://broadrouter.com/tools/llm-batch-job-planner/) Run time, binding limit, cost per model and the flat sessions needed to finish a big job by a deadline.
-   [Flat-rate vs per-token LLM cost calculator](https://broadrouter.com/tools/flat-rate-vs-per-token-calculator/) Break-even between an unlimited plan and paying per token, per agent.
-   [LLM rate limit and concurrency calculator](https://broadrouter.com/tools/llm-rate-limit-calculator/) Which limit binds first: RPM, TPM or concurrency, with Little's law.

[Strumenti gratuiti (in inglese)](https://broadrouter.com/tools/)

## Termini in questo articolo

[Token](https://broadrouter.com/it/glossary/token/)

Un token è l’unità di testo che un modello linguistico legge e scrive: una parola, una parte di parola, un segno di punteggiatura o una sequenza di byte prodotta dal tokenizer del modello. Le API LLM contano, limitano e di solito fatturano l’uso in token.

[Token di input in cache (cached input)](https://broadrouter.com/it/glossary/cached-input-tokens/)

I token di input in cache sono token del prompt che un provider LLM ha elaborato da poco e può riusare da una cache invece di ricalcolarli, di solito un prefisso ripetuto come un system prompt o un documento. I provider li fatturano a una tariffa più bassa dei token di input nuovi.

[Tool calling (chiamata di strumenti)](https://broadrouter.com/it/glossary/tool-calling/)

Il tool calling, detto anche function calling, è una funzionalità delle API LLM in cui il modello restituisce una richiesta strutturata di eseguire una funzione definita dallo sviluppatore, con argomenti JSON. L’applicazione esegue la funzione e rimanda il risultato; il modello non esegue mai codice da solo.

[Piano LLM flat (flat-rate)](https://broadrouter.com/it/glossary/flat-rate-llm-plan/)

Un piano LLM flat applica un prezzo fisso per un periodo, per esempio un mese, per accedere all’API di un modello linguistico invece di fatturare per token. Di solito questi piani limitano qualcos’altro, come concorrenza, velocità, modelli o finestre di utilizzo, quindi i limiti contano quanto il prezzo.

[System prompt (prompt di sistema)](https://broadrouter.com/it/glossary/system-prompt/)

Il system prompt è il testo di istruzioni che un’applicazione invia a un modello linguistico prima della conversazione, di solito come messaggio con ruolo system o developer. Stabilisce ruolo, regole, tono e formato di output del modello, che dovrebbe seguirlo anche quando i messaggi dell’utente lo contraddicono.

[Token di input e di output](https://broadrouter.com/it/glossary/input-and-output-tokens/)

I token di input sono quelli che un modello linguistico legge in una richiesta: system prompt, cronologia, definizioni degli strumenti e immagini. I token di output sono quelli che genera in risposta, ragionamento compreso. Le API LLM di solito li prezzano separatamente, e l’output costa di più.

[Agente di coding AI (AI coding agent)](https://broadrouter.com/it/glossary/coding-agent/)

Un agente di coding AI è uno strumento software in cui un modello linguistico lavora su una codebase in un ciclo: legge file, li modifica, esegue comandi come i test, legge l’output e decide il passo successivo finché il compito è finito o si raggiunge un limite.

[Context compaction (compattazione del contesto)](https://broadrouter.com/it/glossary/context-compaction/)

La context compaction è la pratica di riassumere una conversazione che si avvicina al limite della finestra di contesto e di proseguire la sessione da quel riassunto, così un agente conserva decisioni chiave e stato e scarta la cronologia grezza, come i vecchi output dei tool.

## Domande frequenti

### Quanto costa un’esecuzione di un agente di coding AI?

Conta i token, poi dagli un prezzo. Nell’esempio di questo articolo, un’esecuzione da 30 passi con un contesto di base di 15.000 token e 3.000 token aggiunti a ogni passo invia 1.755.000 token di input e 24.000 di output. Quanto costa dipende soprattutto da quanta parte dell’input viene fatturata alla tariffa in cache.

### Perché un’esecuzione più lunga costa in modo sproporzionato?

Ogni passo rinvia tutto quello che c’era prima. L’input per passo cresce in linea retta, quindi il totale di un’esecuzione cresce con il quadrato del numero di passi. Raddoppiando un’esecuzione da 30 a 60 passi, nell’esempio di calcolo l’input si moltiplica per circa 3,5.

### Che percentuale di cache hit devo aspettarmi da un agente di coding?

Dipende dall’agente e dal provider. Con una cronologia rigorosamente solo in aggiunta mancano solo i token più recenti, e nei nostri esempi si va dall’85% al 97%. Una cronologia modificata, timestamp nel system prompt e pause lunghe la abbassano. Misurala da prompt\_tokens\_details.cached\_tokens.

### Quando una sessione flat costa meno del pagamento a token per un agente?

Quando costo per esecuzione × esecuzioni al mese supera il prezzo del piano. Su BroadNet, Full Moon costa $60 al mese per sessione per DeepSeek V4.1 Flash. L’uso leggero od occasionale di solito costa meno a token.

### I token di ragionamento cambiano la stima?

Sì. Si pagano come output, e l’output costa più dell’input per token. Inserisci nell’output per passo il ragionamento che misuri. Su BroadNet lo riporta completion\_tokens\_details.reasoning\_tokens, quando il modello lo fornisce.

## Continua a leggere

-   [Budget di token di un agente: dove vanno i token di un ciclo](https://broadrouter.com/it/blog/agent-token-budget/)
-   [10 modi per ridurre i costi LLM degli agenti di coding, con i risparmi](https://broadrouter.com/it/blog/cut-coding-agent-llm-costs/)
-   [API LLM a tariffa flat o a consumo per token: i conti del pareggio](https://broadrouter.com/it/blog/flat-rate-vs-pay-per-token-llm-api/)
-   [Token di input in cache: come ridurre la bolletta delle API LLM](https://broadrouter.com/it/blog/cached-input-tokens-explained/)
-   [Contesto degli agenti a lungo termine con una finestra da 1M](https://broadrouter.com/it/blog/long-running-agent-context-management/)
-   [Claude Code con modelli open-weight: proxy, endpoint nativi e limiti](https://broadrouter.com/it/blog/claude-code-with-openai-compatible-models/)
-   [OpenClaw e Hermes Agent con un modello economico: setup e costi](https://broadrouter.com/it/blog/openclaw-hermes-agent-cheap-model/)
-   [Guida: Come funzionano i piani API LLM illimitati per gli agenti](https://broadrouter.com/it/guides/unlimited-llm-api-sessions/)
-   [Guida: Usare Aider con DeepSeek V4.1 Flash illimitato](https://broadrouter.com/it/guides/aider-unlimited-deepseek/)

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

[Inizia](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-ai-coding-agent-run-cost&utm_content=page-cta) ·

**Fonti**

-   [Riferimento API di BroadNet Inference: campi di utilizzo, cached\_tokens, il ragionamento conta in max\_tokens, limiti (verificato il 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-ai-coding-agent-run-cost&utm_content=sources)
-   [Pagina dei prezzi e pricing.json di BroadNet Inference, prezzi aggiornati il 2026-11-14 (verificati il 2026-11-15) (in inglese)](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-ai-coding-agent-run-cost&utm_content=sources)
-   [Pagina dei piani di BroadNet Inference: una richiesta alla volta per sessione, nessun contatore di token (verificata il 2026-11-15) (in inglese)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-ai-coding-agent-run-cost&utm_content=sources)
-   [Guida al prompt caching di OpenAI: corrispondenza del prefisso e lunghezza minima in cache (verificata il 2026-11-15)](https://developers.openai.com/api/docs/guides/prompt-caching)
-   [Documentazione dell’API DeepSeek, context caching: unità di cache ai confini delle richieste (verificata il 2026-11-15)](https://api-docs.deepseek.com/guides/kv_cache)
