Cost Optimizer

Agent Cost Optimizer

Quand utiliser ce skill

Dès qu'un agent IA consomme trop de tokens, que la facture API dépasse le budget, ou qu'on cherche à passer en production à coût maîtrisé. S'applique aussi pour mettre en place des garde-fous préventifs avant le déploiement.

---

Workflow

Étape 1 — Audit baseline (ne rien optimiser sans mesure)

Objectif : identifier les 20 % de requêtes qui causent 80 % du coût.

# Structure minimale de log — ajouter à chaque appel LLM
import anthropic, time

client = anthropic.Anthropic()

def call_with_cost_log(messages, model, system=""):
    t0 = time.time()
    resp = client.messages.create(
        model=model, max_tokens=1024,
        system=system, messages=messages
    )
    cost = (
        resp.usage.input_tokens  * pricing[model]["in"]  +
        resp.usage.output_tokens * pricing[model]["out"]
    )
    print(f"[COST] model={model} in={resp.usage.input_tokens} "
          f"out={resp.usage.output_tokens} cost_usd={cost:.5f} "
          f"latency_ms={int((time.time()-t0)*1000)}")
    return resp

Tarifs 2026 indicatifs (vérifier anthropic.com/pricing) :

| Modèle | Input / 1M tokens | Output / 1M tokens | |---|---|---| | claude-haiku-3-5 | $0.80 | $4.00 | | claude-sonnet-4 | $3.00 | $15.00 | | claude-opus-4 | $15.00 | $75.00 | | gpt-4o-mini | $0.15 | $0.60 | | gemini-2.0-flash | $0.10 | $0.40 |

Critère de décision : si le coût médian par requête > $0.02, optimiser en priorité. Si variance > 10×, le routing est le levier le plus impactant.

---

Étape 2 — Model routing (levier le plus rapide)

Router chaque tâche vers le modèle le moins cher capable de la traiter.

ROUTING_RULES = {
    "simple":   "claude-haiku-3-5",   # classification, extraction, reformulation
    "moderate": "claude-sonnet-4",    # raisonnement, synthèse, code standard
    "complex":  "claude-opus-4",      # architecture, décisions critiques, audit
}

def classify_task(prompt: str) -> str:
    """Classifier cheap (Haiku) pour décider du modèle à utiliser."""
    resp = client.messages.create(
        model="claude-haiku-3-5", max_tokens=10,
        messages=[{"role": "user", "content":
            f"Complexity of this task (simple/moderate/complex):\n{prompt[:300]}"}]
    )
    return resp.content[0].text.strip().lower()

def route(prompt: str):
    level = classify_task(prompt)
    return ROUTING_RULES.get(level, "claude-sonnet-4")

> Règle : le coût du classifier doit être 1024 tokens pour activer le cache "cache_control": {"type": "ephemeral"} }], messages=messages )

Les appels suivants avec le même system prompt utilisent le cache (prix cache_read list:

total = sum(len(m["content"].split()) * 1.3 for m in messages) # estimation rapide if total str: key = hashlib.sha256(f"{model}:{prompt}".encode()).hexdigest() if key in cache: return cache[key] result = client.messages.create(model=model, max_tokens=512, messages=[{"role": "user", "content": prompt}]) text = result.content[0].text cache[key] = text return text

- **Semantic cache** (GPTCache, Redis VSS) : utile quand les prompts varient légèrement mais la réponse est identique.
- **Tool result cache** : cacher les résultats d'API externes coûteuses (recherches web, bases de données).
- TTL recommandé : 1 h pour données fraîches, 24 h pour données statiques.

---

### Étape 7 — Batch processing

```bash
# Batch API Anthropic — jusqu'à 50 % de réduction, délai = self.max_usd * 0.8:
            print(f"[WARN] 80% du budget atteint ({self.spent:.4f}$/{self.max_usd}$)")
        if self.spent >= self.max_usd:
            raise RuntimeError(f"Budget dépassé : {self.spent:.4f}$ > {self.max_usd}$")

Paramétrage recommandé :

• Par conversation : $0.10–$0.50 selon cas d'usage
• Par agent/jour : $5–$50 en production
• Toujours combiner limite côté code et max_tokens dans chaque requête API.

---

Étape 10 — Monitoring continu

Métriques minimales à tracker :

| Métrique | Cible | |---|---| | Coût par tâche complétée | 30 % | | % requêtes routées vers cheap model | > 60 % | | Token ratio output/input | 20 % dès le départ

• [ ] Dashboard coût/tâche opérationnel (pas juste coût total)

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: khalilbenaz
• Source: khalilbenaz/claude-skills-collection
• License: MIT
• Homepage: https://khalilbenaz.github.io/claude-skills-collection/

Install and usage instructions live in the source repository linked above.