Ottimizzazione dei costi degli agenti: una guida pratica per ridurre la spesa API

Il tuo agente funziona alla perfezione. Gestisce 200 richieste al giorno e gli utenti sono soddisfatti. Poi controlli la fattura API: $3.400 questo mese. Analizzi i numeri e ti rendi conto che l’agente effettua in media 12 chiamate API per richiesta, ciascuna con un system prompt da 4.000 token. Sono 9,6 milioni di token in input al giorno solo per i system prompt. A $3 per milione di token, sono $864/mese spesi su contenuti ripetuti.

Il costo è il principale motivo per cui i deployment di agenti in produzione vengono ridimensionati o eliminati del tutto. L’ottimizzazione non è prematura — è una questione di sopravvivenza. La buona notizia: la maggior parte dei deployment ha una riduzione dei costi del 50–80% a portata di mano, attraverso modifiche semplici che non richiedono di riscrivere l’intera architettura.

In questa guida imparerai sette strategie di riduzione dei costi, ordinate per ROI (Return on Investment). Parti dall’alto e scendi fino a raggiungere il tuo obiettivo di budget. Ogni sezione include numeri concreti per stimare i risparmi prima ancora di scrivere una singola riga di codice.

1. Contabilità dei token: sapere dove vanno i soldi

Non puoi ottimizzare ciò che non misuri. Prima di cambiare qualsiasi cosa, costruisci un quadro completo di dove va ogni euro nel tuo workflow dell’agente.

Scomposizione dei token in input

Ogni chiamata API a Claude include diverse categorie di token lato input:

• System prompt — Istruzioni, persona, vincoli. Spesso 1.000–5.000 token, ripetuti ad ogni chiamata.
• Definizioni degli strumenti — Schemi JSON per ogni strumento che l’agente può utilizzare. 10 strumenti possono consumare facilmente 2.000–3.000 token.
• Cronologia della conversazione — Tutti i messaggi precedenti nella conversazione. Cresce ad ogni step.
• Risultati degli strumenti — Output delle chiamate agli strumenti precedenti, reiniettati nel contesto. Possono essere enormi (pagine web complete, risultati di database).

Scomposizione dei token in output

I token in output sono 3–5 volte più costosi di quelli in input, rendendoli un obiettivo critico di ottimizzazione:

• Ragionamento dell’agente — Chain-of-thought interno (specialmente con il pensiero esteso).
• Generazione delle chiamate agli strumenti — Il JSON per le invocazioni degli strumenti.
• Risposta finale — La risposta visibile all’utente.

Calcolo del costo per task

Il costo totale per un singolo task dell’agente è:

Total Cost = Σ (input_tokens × input_price + output_tokens × output_price)
             for each API call in the task

Esempio di scomposizione dei costi

Ecco una scomposizione realistica per un task di ricerca in 10 step usando Claude Sonnet ($3/M input, $15/M output):

Nota come i costi in input dominino e crescano ad ogni step con l’accumulo della cronologia della conversazione. Gli step 8–10 rappresentano il 47% del costo totale pur essendo solo il 30% degli step.

Codice per il tracking dei costi

Implementa un wrapper di tracking fin dal primo giorno:

import anthropic
import time
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class CostRecord:
    step: int
    model: str
    input_tokens: int
    output_tokens: int
    cache_read_tokens: int = 0
    cache_creation_tokens: int = 0
    input_cost: float = 0.0
    output_cost: float = 0.0
    total_cost: float = 0.0
    duration_ms: float = 0.0

# Pricing per million tokens (as of early 2026)
MODEL_PRICING = {
    "claude-haiku": {"input": 0.25, "output": 1.25, "cache_read": 0.025, "cache_write": 0.30},
    "claude-sonnet": {"input": 3.00, "output": 15.00, "cache_read": 0.30, "cache_write": 3.75},
    "claude-opus": {"input": 15.00, "output": 75.00, "cache_read": 1.50, "cache_write": 18.75},
}

@dataclass
class TaskCostTracker:
    task_id: str
    budget_limit: Optional[float] = None
    records: list = field(default_factory=list)
    total_cost: float = 0.0

    def record_call(self, step: int, model: str, usage) -> CostRecord:
        pricing = MODEL_PRICING.get(model, MODEL_PRICING["claude-sonnet"])

        input_cost = (usage.input_tokens / 1_000_000) * pricing["input"]
        output_cost = (usage.output_tokens / 1_000_000) * pricing["output"]
        cache_read_cost = (getattr(usage, 'cache_read_input_tokens', 0) / 1_000_000) * pricing["cache_read"]
        cache_write_cost = (getattr(usage, 'cache_creation_input_tokens', 0) / 1_000_000) * pricing["cache_write"]

        total = input_cost + output_cost + cache_read_cost + cache_write_cost

        record = CostRecord(
            step=step,
            model=model,
            input_tokens=usage.input_tokens,
            output_tokens=usage.output_tokens,
            cache_read_tokens=getattr(usage, 'cache_read_input_tokens', 0),
            cache_creation_tokens=getattr(usage, 'cache_creation_input_tokens', 0),
            input_cost=input_cost + cache_read_cost + cache_write_cost,
            output_cost=output_cost,
            total_cost=total,
        )

        self.records.append(record)
        self.total_cost += total

        print(f"  Step {step} [{model}]: {usage.input_tokens} in / {usage.output_tokens} out = ${total:.4f} (cumulative: ${self.total_cost:.4f})")

        if self.budget_limit and self.total_cost > self.budget_limit:
            raise BudgetExceededError(
                f"Task {self.task_id} exceeded budget: ${self.total_cost:.4f} > ${self.budget_limit:.4f}"
            )

        return record

    def summary(self) -> dict:
        return {
            "task_id": self.task_id,
            "total_steps": len(self.records),
            "total_input_tokens": sum(r.input_tokens for r in self.records),
            "total_output_tokens": sum(r.output_tokens for r in self.records),
            "total_cost": self.total_cost,
            "cost_by_model": self._cost_by_model(),
        }

    def _cost_by_model(self) -> dict:
        by_model = {}
        for r in self.records:
            if r.model not in by_model:
                by_model[r.model] = {"calls": 0, "cost": 0.0}
            by_model[r.model]["calls"] += 1
            by_model[r.model]["cost"] += r.total_cost
        return by_model


class BudgetExceededError(Exception):
    pass

Inizia a fare tracking oggi, ancora prima di ottimizzare. Hai bisogno di numeri di riferimento per misurare i miglioramenti.

2. Selezione del modello per task

Questa è la leva di costo più potente a tua disposizione. Non ogni step dell’agente richiede il modello più avanzato.

Fasce di modelli e prezzi

Usando la famiglia Claude come riferimento:

Haiku è 12 volte più economico di Sonnet sia in input che in output. Sonnet è 5 volte più economico di Opus su tutta la linea.

Raccomandazioni per ruolo

Abbina ogni ruolo dell’agente al modello più economico che soddisfa i requisiti di qualità:

• Agenti router/classificatori → Haiku. “È una domanda di fatturazione o tecnica?” non richiede Sonnet. Haiku gestisce la classificazione con >95% di accuratezza per categorie ben definite.
• Agenti di estrazione dati → Haiku. Estrarre campi strutturati da testo, analizzare date, identificare entità — Haiku eccelle in questi compiti.
• Agenti worker (uso degli strumenti) → Sonnet. L’orchestrazione complessa di strumenti multi-step, la sintesi della

Articoli Correlati

• Strategie di Caching per Agenti AI: Ridurre i Costi Senza Compromessi
• Modelli di ragionamento nei flussi agentici: quando il pensiero esteso vale la pena
• Pattern Multi-Agente: Orchestratori, Worker e Pipeline
• Debug e Osservabilità nei Sistemi di Agenti Autonomi