Optimisation des coûts des agents : guide pratique pour réduire les dépenses API

Votre agent fonctionne parfaitement. Il traite 200 requêtes par jour, et les utilisateurs sont satisfaits. Puis vous consultez la facture API : 3 400 $ ce mois-ci. En creusant les chiffres, vous réalisez que l’agent effectue en moyenne 12 appels API par requête, chacun avec un prompt système de 4 000 tokens. Cela représente 9,6 millions de tokens d’entrée par jour rien que pour les prompts système. À 3 $ le million de tokens, c’est 864 $/mois pour du contenu répété.

Le coût est la principale raison pour laquelle les déploiements d’agents en production sont réduits ou abandonnés. L’optimisation n’est pas prématurée — c’est une question de survie. La bonne nouvelle : la plupart des déploiements d’agents offrent 50 à 80 % de réduction des coûts grâce à des changements simples qui ne nécessitent pas de refondre entièrement votre système.

Dans ce guide, vous découvrirez sept stratégies de réduction des coûts, classées par ROI (retour sur investissement). Commencez par le début et progressez jusqu’à atteindre votre objectif budgétaire. Chaque section inclut des chiffres concrets pour estimer les économies avant d’écrire une seule ligne de code.

1. Comptabilité des tokens : sachez où va votre argent

On n’optimise pas ce qu’on ne mesure pas. Avant de modifier quoi que ce soit, dressez un tableau complet de l’origine de chaque dollar dépensé dans votre workflow d’agent.

Décomposition des tokens d’entrée

Chaque appel API à Claude comprend plusieurs catégories de tokens côté entrée :

• Prompt système — Instructions, persona, contraintes. Souvent entre 1 000 et 5 000 tokens, répété à chaque appel.
• Définitions d’outils — Schémas JSON pour chaque outil utilisable par l’agent. 10 outils peuvent facilement consommer 2 000 à 3 000 tokens.
• Historique de conversation — Tous les messages précédents de la conversation. Croît à chaque étape.
• Résultats d’outils — Sorties des appels d’outils précédents réinjectées dans le contexte. Peuvent être massives (pages web complètes, résultats de bases de données).

Décomposition des tokens de sortie

Les tokens de sortie sont 3 à 5 fois plus chers que les tokens d’entrée, ce qui en fait une cible d’optimisation critique :

• Raisonnement de l’agent — Chaîne de pensée interne (notamment avec la réflexion étendue).
• Génération d’appels d’outils — Le JSON pour les invocations d’outils.
• Réponse finale — La réponse destinée à l’utilisateur.

Calcul du coût par tâche

Le coût total d’une seule tâche d’agent est :

Coût total = Σ (tokens_entrée × prix_entrée + tokens_sortie × prix_sortie)
             pour chaque appel API de la tâche

Exemple de décomposition des coûts

Voici une décomposition réaliste pour une tâche d’agent de recherche en 10 étapes avec Claude Sonnet (3 $/M entrée, 15 $/M sortie) :

Remarquez comment les coûts d’entrée dominent, et qu’ils croissent à chaque étape au fur et à mesure que l’historique de conversation s’accumule. Les étapes 8 à 10 représentent 47 % du coût total alors qu’elles ne constituent que 30 % des étapes.

Code de suivi des coûts

Implémentez un wrapper de suivi dès le premier jour :

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

Commencez à suivre dès aujourd’hui, même avant d’optimiser. Vous avez besoin de chiffres de référence pour mesurer vos progrès.

2. Sélection du modèle par tâche

C’est le levier de coût le plus puissant à votre disposition. Chaque étape d’un agent n’a pas besoin de votre modèle le plus performant.

Niveaux de modèles et tarification

En prenant la famille Claude comme référence :

Haiku est 12 fois moins cher que Sonnet sur les tokens d’entrée et 12 fois moins cher sur les tokens de sortie. Sonnet est 5 fois moins cher qu’Opus dans l’ensemble.

Articles Connexes

• Stratégies de mise en cache pour les agents IA : réduire les coûts sans compromis
• Modèles de raisonnement dans les workflows agents : quand la réflexion étendue en vaut la peine
• Patterns Multi-Agents : Orchestrateurs, Workers et Pipelines
• Débogage et Observabilité dans les Systèmes d’Agents Autonomes