Agentkosten optimieren: Ein praktischer Leitfaden zur Senkung von API-Ausgaben

Dein Agent funktioniert hervorragend. Er bearbeitet 200 Anfragen pro Tag, und die Nutzer sind zufrieden. Dann schaust du auf die API-Rechnung: 3.400 $ in diesem Monat. Du analysierst die Zahlen und stellst fest, dass der Agent im Durchschnitt 12 API-Aufrufe pro Anfrage macht, jeder mit einem 4.000-Token-System-Prompt. Das sind 9,6 Millionen Input-Token pro Tag allein für System-Prompts. Bei 3 $ pro Million Token sind das 864 $/Monat für wiederholte Inhalte.

Kosten sind der häufigste Grund, warum produktive Agenten-Deployments zurückgefahren oder ganz eingestellt werden. Optimierung ist keine Überoptimierung – sie ist überlebenswichtig. Die gute Nachricht: Bei den meisten Agenten-Deployments lassen sich 50–80 % der Kosten einsparen – durch unkomplizierte Änderungen, ohne das gesamte System neu zu architekturieren.

In diesem Leitfaden lernst du sieben Kostenreduzierungsstrategien kennen, geordnet nach ROI (Return on Investment). Beginne oben und arbeite dich durch, bis du dein Budget-Ziel erreichst. Jeder Abschnitt enthält konkrete Zahlen, damit du Einsparungen abschätzen kannst, bevor du eine einzige Zeile Code schreibst.

1. Token-Buchhaltung: Wisse, wo dein Geld hingeht

Du kannst nicht optimieren, was du nicht misst. Bevor du etwas änderst, verschaffe dir ein vollständiges Bild davon, wo in deinem Agenten-Workflow jeder Dollar hinfließt.

Aufschlüsselung der Input-Token

Jeder API-Aufruf an Claude enthält auf der Input-Seite mehrere Token-Kategorien:

• System-Prompt — Anweisungen, Persona, Einschränkungen. Oft 1.000–5.000 Token, bei jedem Aufruf wiederholt.
• Tool-Definitionen — JSON-Schemas für jedes Tool, das der Agent verwenden kann. 10 Tools können leicht 2.000–3.000 Token verbrauchen.
• Gesprächsverlauf — Alle vorherigen Nachrichten im Gespräch. Wächst mit jedem Schritt.
• Tool-Ergebnisse — Ausgaben vorheriger Tool-Aufrufe, die zurück in den Kontext eingespeist werden. Können massiv sein (vollständige Webseiten, Datenbankresultate).

Aufschlüsselung der Output-Token

Output-Token sind 3–5× teurer als Input-Token und daher ein kritisches Optimierungsziel:

• Agenten-Reasoning — Interner Chain-of-Thought (besonders bei erweitertem Denken).
• Generierung von Tool-Aufrufen — Das JSON für Tool-Invokationen.
• Abschließende Antwort — Die nutzerorientierte Antwort.

Kostenberechnung pro Aufgabe

Die Gesamtkosten für eine einzelne Agenten-Aufgabe betragen:

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

Beispiel zur Kostenaufschlüsselung

Hier ist eine realistische Aufschlüsselung für eine 10-Schritt-Rechercheagenten-Aufgabe mit Claude Sonnet (3 $/M Input, 15 $/M Output):

Beachte, wie Input-Kosten dominieren und mit jedem Schritt wachsen, da sich der Gesprächsverlauf ansammelt. Die Schritte 8–10 machen 47 % der Gesamtkosten aus, obwohl sie nur 30 % der Schritte darstellen.

Code für die Kostenverfolgung

Implementiere von Anfang an einen Tracking-Wrapper:

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

Beginne noch heute mit dem Tracking, noch vor der Optimierung. Du brauchst Ausgangszahlen, um Verbesserungen zu messen.

2. Modellauswahl nach Aufgabe

Dies ist der größte einzelne Kostenhebel, der dir zur Verfügung steht. Nicht jeder Agentenschritt erfordert dein leistungsstärkstes Modell.

Modell-Tiers und Preise

Am Beispiel der Claude-Familie:

Haiku ist 12× günstiger als Sonnet bei Input und 12× günstiger bei Output. Sonnet

Verwandte Artikel

• Caching-Strategien für KI-Agenten: Kosten senken ohne Abstriche
• Reasoning-Modelle in Agent-Workflows: Wann sich Extended Thinking lohnt
• Multi-Agenten-Muster: Orchestratoren, Worker und Pipelines
• Debugging und Observability in Autonomen Agentensystemen