Utilizzo dei token in Claude Code: tieni l'output degli strumenti fuori dal contesto

Il tuo agente ha eseguito la suite di test tre volte, e il conto è più grande del compito. La ragione raramente è il codice che ha scritto. Sono i log dei test: una volta che il risultato di uno strumento entra nel contesto di Claude Code, ogni richiesta successiva lo trasporta di nuovo. La soluzione è ridurre l'output degli strumenti prima che il modello lo veda. Il modo ufficiale è un hook PreToolUse su Bash; il modo di terze parti è il plugin context-mode. Entrambi sono di seguito, con una stima dei costi per una sessione lunga su un modello CheapTokens.

Perché un log viene pagato molte volte#

Secondo la pagina dei costi di Claude Code (https://code.claude.com/docs/en/costs, verificata il 23 ottobre 2026), Claude Code invia l'intera conversazione con ogni richiesta, e ogni uso di uno strumento attiva un'altra richiesta che trasporta i risultati dello strumento. La cache dei prompt rilegge la cronologia a una tariffa cache più economica, ma i token sono comunque lì.

Supponiamo che l'agente esegua npm test e ottenga un log di 10.000 righe. La documentazione dice che quel tipo di log può essere decine di migliaia di token. Ipotizziamo 30.000 token. Qualunque cosa tu faccia dopo, quei 30.000 token fanno parte dell'input del passo 11, del passo 12, del passo 13, e così via finché non fai /clear o compatti. E qui sta il problema: il log è utile per un passo, e lo paghi per trenta.

Soluzione 1: un hook PreToolUse che filtra l'output dei test#

La stessa pagina di documentazione suggerisce gli hook come pre-elaborazione: un hook PreToolUse su Bash riscrive i comandi di test (npm test, pytest, go test) in modo che passino attraverso grep -A 5 -E '(FAIL|ERROR|error:)' | head -100. L'agente vede quindi solo i fallimenti più qualche riga di contesto, non 10.000 righe di puntini verdi. La documentazione dice che questo può trasformare decine di migliaia di token in centinaia.

Questo è lo script di quella pagina di documentazione (verificata il 23 ottobre 2026). Richiede jq. Crea la cartella con mkdir -p ~/.claude/hooks, salva lo script come ~/.claude/hooks/filter-test-output.sh ed esegui chmod +x su di esso:

#!/bin/bash
input=$(cat)
cmd=$(echo "$input" | jq -r '.tool_input.command')

pattern='^(npm test|pytest|go test)( [^;&|<>`$#\\[:cntrl:]]*)?$'

if [[ "$cmd" =~ $pattern ]]; then
  filtered_cmd="$cmd 2>&1 | grep -A 5 -E '(FAIL|ERROR|error:)' | head -100"
  echo "$input" | jq --arg filtered "$filtered_cmd" '{hookSpecificOutput: {hookEventName: "PreToolUse", updatedInput: (.tool_input + {command: $filtered})}}'
else
  echo "{}"
fi

Poi registralo in ~/.claude/settings.json:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [{ "type": "command", "command": "~/.claude/hooks/filter-test-output.sh" }]
      }
    ]
  }
}

Per verificare che funzioni, apri /hooks dentro Claude Code e cerca la voce PreToolUse, oppure inizia con claude --debug-file ./claude-debug.txt e chiedi all'agente di eseguire npm test. Quando l'hook ha riscritto il comando, il file ha una riga modified tool input keys con il campo command. Se i test passano, l'output è vuoto, quindi l'agente ottiene un successo silenzioso; regola il pattern se il tuo runner stampa i fallimenti in modo diverso.

Soluzione 2: context-mode per risultati di strumenti di grandi dimensioni#

Un hook copre solo i comandi che puoi reindirizzare. Le istantanee di pagina da Playwright o un elenco di venti issue di GitHub provengono da strumenti MCP. È questo che context-mode prende di mira. Secondo il suo README (https://github.com/mksglu/context-mode, verificato il 23 ottobre 2026; non mostra versione né data), è un server MCP e un plugin che tiene l'output grezzo degli strumenti fuori dalla finestra di contesto, memorizza lo stato della sessione in SQLite e instrada le chiamate agli strumenti attraverso hook. Richiede Claude Code v1.0.33 o successivo, e la sua licenza è Elastic License 2.0, che non è una licenza open source OSI.

Installa dentro Claude Code:

/plugin marketplace add mksglu/context-mode
/plugin install context-mode@context-mode

Riavvia o esegui /reload-plugins, poi verifica con /context-mode:ctx-doctor. La variante solo MCP, claude mcp add context-mode -- npx -y context-mode, aggiunge gli strumenti ma non ha instradamento automatico.

Il progetto riporta grandi riduzioni: 315 KB diventano 5,4 KB (98%), un'istantanea di pagina da 56 KB diventa 299 byte, 986 KB diventano 62 KB. Questi sono i numeri dell'autore: trattali come il tetto massimo e misura sulla tua sessione con /context prima e dopo.

Quanto costa una sessione lunga, con e senza filtraggio#

Ecco l'aritmetica su una sessione ipotizzata. È una sessione di programmazione di 40 passi su un contesto base medio di 20.000 token, 500 token di output per passo, e tre esecuzioni di test, ai passi 10, 20 e 30. Ogni log grezzo è di 30.000 token; la versione filtrata è di 500.

• Un log dal passo 10 viene reinviato nelle 30 richieste successive: 30 × 30.000 = 900.000 token. Passo 20: 20 × 30.000 = 600.000. Passo 30: 10 × 30.000 = 300.000. Input extra: 900.000 + 600.000 + 300.000 = 1.800.000.
• Filtrato: (30 + 20 + 10) × 500 = 30.000 input extra.
• Input base: 40 × 20.000 = 800.000. Output: 40 × 500 = 20.000.
• Quindi la sessione è 800.000 + 1.800.000 = 2.600.000 token di input senza filtraggio e 800.000 + 30.000 = 830.000 con filtraggio, con 20.000 token di output in entrambi i casi.

Il calcolo conta ogni token di input a tariffa piena. La cache abbassa il numero reale, ma abbassa entrambi i casi con la stessa logica. I prezzi live per MiniMax-M2.7 (MiniMaxAI/MiniMax-M2.7, contesto 180K, fino a 8.192 token di output), che è il modello adatto a cicli di agenti con input pesante come questo, sono nel grafico qui sotto.

Ipotesi: 40 passi, contesto base di 20.000 token, 500 token di output per passo, tre esecuzioni di test da 30.000 token (filtrate: 500).

Su MiniMax-M2.7 la sessione costa $0.133 senza filtraggio e $0.0445 con filtraggio, e in totale, contando input e output insieme, è più economica del prezzo di riferimento di OpenRouter. Circa due terzi dell'input nel caso senza filtraggio sono log che l'agente ha letto una volta.

Il punto non sono i dollari esatti. È che il filtro rimuove circa 1.770.000 di 2.600.000 token di input (2.600.000 − 830.000 = 1.770.000) su qualsiasi modello, e un modello più economico abbassa il prezzo di ogni token che rimane.

Esegui Claude Code su un modello CheapTokens#

Claude Code parla il protocollo Anthropic Messages, e CheapTokens lo supporta. L'URL di base per Claude Code non ha /v1. La configurazione completa è in come connettere Claude Code a CheapTokens. La versione breve, con una chiave segnaposto:

export ANTHROPIC_BASE_URL=https://api.cheaptokens.dev
export ANTHROPIC_AUTH_TOKEN=YOUR_CHEAPTOKENS_KEY
export ANTHROPIC_MODEL=MiniMaxAI/MiniMax-M2.7
claude

Usa l'id completo dalla documentazione; i nomi brevi delle tabelle dei prezzi non sono accettati dall'API. I prezzi per ogni modello sono sulla pagina dei prezzi. Per le altre abitudini che riducono il conto di Claude Code (/clear, /compact, /mcp, subagenti), vedi Come rendere Claude Code più economico. Per vedere come vengono contati input e output su una richiesta reale, leggi Quanti token usa una richiesta API.

Checklist rapida#

1. Esegui /context in una sessione lunga e vedi cosa occupa spazio.
2. Aggiungi l'hook Bash per i comandi di test; conferma la riscrittura in /hooks o nel log di debug.
3. Se gli strumenti MCP restituiscono grandi istantanee, prova context-mode e confronta /context prima e dopo.
4. /clear tra attività non correlate, così i vecchi log smettono di viaggiare insieme.