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. 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. 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. 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 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.
Come stimi la tua esecuzione?
Questo script legge i prezzi attuali dal pricing.json pubblico di BroadNet, quindi non invecchia mai, e stampa i totali di token e il costo per esecuzione per ciascun caso di cache:
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:
- Registra
prompt_tokens,prompt_tokens_details.cached_tokensecompletion_tokensper ogni chiamata, come nell’articolo sul budget di token di un agente. - B è il
prompt_tokensdella prima chiamata. g è l’aumento medio diprompt_tokensda una chiamata alla successiva. - L’output per passo è la media di
completion_tokens. Include i token di ragionamento, che si pagano come output. - La tua percentuale di cache reale è la somma di
cached_tokensdivisa per la somma diprompt_tokens.
Lo stimatore gratuito del costo di un’esecuzione 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 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_effortsulowper 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 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:
- 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).
- 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.
| 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.
Prima verifica un limite. La documentazione di BroadNet indica il tool calling solo per GLM 5.3 e Qwen3.8 27B, e nessuno dei due è su un piano flat. Gli agenti che modificano tramite testo, come Aider, 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.
