KI-Agenten Blog
COMPUTERZUGRIFFSSYSTEM

Caching-Strategien für KI-Agenten: Kosten senken ohne Abstriche

agent cachingprompt cachingagent cost optimizationClaude caching APItool result cacheAI agentsproduction agents

Caching-Strategien für KI-Agenten: Kosten senken ohne Abstriche

Ihr Research-Agent führt täglich 50 Aufgaben aus. Jede Aufgabe beginnt mit demselben 3.000-Token-System-Prompt, denselben 2.500-Token-Tool-Definitionen und derselben 5.000-Token-Wissensdatenbank. Das sind 10.500 Token, die 50-mal wiederholt werden — 525.000 Token pro Tag, die das Modell jedes Mal identisch liest. Zum Standardpreis bezahlen Sie dafür, denselben Inhalt immer wieder zu verarbeiten.

Caching ist die Optimierung mit dem geringsten Aufwand und dem größten Effekt für produktive Agenten. Prompt-Caching allein kann die Eingabe-Token-Kosten für gecachte Inhalte um 90 % reduzieren. In Kombination mit Tool-Result-Caching lassen sich die Gesamtkosten eines Agenten häufig halbieren — ohne Einbußen bei Qualität, Genauigkeit oder Flexibilität.

In diesem Artikel lernen Sie drei Caching-Ebenen für Agenten kennen — Prompt-Caching, Tool-Result-Caching und Response-Memoization — mit Implementierungsmustern über die Claude-API und einer klaren Kostenanalyse als Entscheidungshilfe.

Abschnitt 1: Kostenstruktur von Agenten

Bevor Sie optimieren, müssen Sie verstehen, wo Ihre Token tatsächlich verbraucht werden. Schauen wir uns einen typischen agentischen Workflow im Detail an.

Token-Verteilung pro Schritt

In einer Standard-Agentenarchitektur enthält jeder API-Aufruf an das Modell:

KomponenteCa. TokenWiederholt?
System-Prompt~1.500Jeder Schritt
Tool-Definitionen~2.000Jeder Schritt
Wissensdatenbank / Kontext~3.000Jeder Schritt
KonversationsverlaufWächstAkkumuliert
Tool-Ergebnisse~500 ØPro Tool-Aufruf

Der statische Overhead — System-Prompt, Tool-Definitionen und Wissensdatenbank — beträgt insgesamt rund 6.500 Token pro Schritt und ist jedes Mal identisch.

Das Problem der Kostenakkumulation

Agenten führen nicht nur einen API-Aufruf durch. Sie schleifen. Ein typischer Agenten-Durchlauf mit 15 Schritten sieht so aus:

Ohne Caching:

Jeder der 15 Schritte sendet den vollständigen Kontext. Angenommen, der Konversationsverlauf wächst pro Schritt um durchschnittlich ~300 Token:

  • Statische Token pro Schritt: 6.500
  • Gesamte statische Token über 15 Schritte: 97.500
  • Konversationsverlauf-Token (kumulativ): ~33.750
  • Tool-Ergebnis-Token: ~7.500
  • Gesamt-Eingabe-Token: ~138.750

Zum Claude-Sonnet-Eingabepreis von 3 $ pro Million Token ergibt das etwa 0,42 $ pro Aufgabe. Bei 50 Aufgaben pro Tag sind das 21 $/Tag — nur für Eingabe-Token.

Mit Prompt-Caching:

Gecachte Token werden mit 0,30 $ pro Million für Cache-Reads berechnet (90 % Rabatt). Wenn Sie die 6.500 statischen Token cachen:

  • Gecachte Token-Reads über 15 Schritte: 97.500 Token × 0,30 $/Mio. = 0,029 $
  • Nicht gecachte Token bleiben zum Standardpreis: ~41.250 × 3 $/Mio. = 0,124 $
  • Cache-Write (erster Schritt): 6.500 × 3,75 $/Mio. = 0,024 $
  • Gesamte Eingabekosten: ~0,18 $ pro Aufgabe

Das entspricht einer 57-prozentigen Reduzierung allein durch Caching. Bei 50 Aufgaben pro Tag sparen Sie über 12 $/Tag — rund 360 $/Monat — mit minimalen Code-Änderungen.

Abschnitt 2: Prompt-Caching mit Claude

Claudes Prompt-Caching-API ist die wirkungsvollste Einzeloptimierung, die Sie auf agentische Workflows anwenden können. Sie ermöglicht es Ihnen, der API mitzuteilen: „Dieser Teil meines Prompts hat sich nicht geändert — verwende die gecachte Berechnung wieder.”

Wie Prompt-Caching funktioniert

Wenn Sie eine Anfrage mit aktiviertem Caching senden, geht Anthropics Infrastruktur wie folgt vor:

  1. Prüft, ob eine gecachte Version des markierten Präfixes existiert
  2. Bei Cache-Miss: Verarbeitet den vollständigen Prompt, cached das Präfix und berechnet eine Cache-Write-Gebühr (25 % Aufschlag auf den Standard-Eingabepreis)
  3. Bei Cache-Hit: Verwendet die gecachte Berechnung wieder und berechnet nur die Cache-Read-Gebühr (90 % Rabatt auf den Standard-Eingabepreis)

Der Cache hat eine TTL von 5 Minuten (Time to Live — die Dauer, bevor gecachte Daten ablaufen). Jeder Cache-Hit setzt die TTL zurück, sodass aktive Agenten ihren Cache auf natürliche Weise warm halten. Bei Batch-Jobs mit Pausen von mehr als 5 Minuten zwischen den Aufrufen fallen häufiger Cache-Write-Kosten an.

Was gecacht werden sollte

Nicht alles kann oder sollte gecacht werden. Cachen Sie stabile, wiederholte Präfixe:

  • System-Prompts — Fast immer identisch über mehrere Durchläufe. Diese zuerst cachen.
  • Tool-Definitionen — Ihre Tool-Schemata ändern sich selten zwischen Aufrufen.
  • Statische Wissensdatenbanken — Referenzdokumente, Richtlinien, Regelwerke.
  • Konversationspräfixe — Bei mehrstufigen Konversationen die frühen Schritte cachen, die sich nicht ändern.

Wichtige Einschränkungen:

  • Caching ist präfixbasiert — Sie können nur Inhalte vom Anfang des Prompts in der richtigen Reihenfolge cachen. Ein Abschnitt in der Mitte lässt sich nicht cachen, während frühere Abschnitte ungecacht bleiben.
  • Es gibt eine Mindestlänge von 1.024 Token für Claude Sonnet und Haiku (2.048 für Opus).
  • Sie können bis zu 4 Cache-Breakpoints in einer einzelnen Anfrage setzen.

Implementierung

Hier ist ein vollständiges Beispiel für ein Agenten-Setup mit Prompt-Caching:

Vorher (ohne Caching):

import anthropic


client = anthropic.Anthropic()


SYSTEM_PROMPT = """You are a research assistant specializing in market analysis.
You have access to tools for searching databases, reading files, and performing
calculations. Always cite your sources and provide confidence levels for your
findings. [... detailed instructions totaling ~1,500 tokens ...]"""


TOOLS = [
    {
        "name": "search_database",
        "description": "Search the company database for market data, competitor info, or financial records.",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "Search query"},
                "database": {"type": "string", "enum": ["market", "competitors", "financial"]},
                "limit": {"type": "integer", "description": "Max results", "default": 10}
            },
            "required": ["query", "database"]
        }
    },
    {
        "name": "read_file",
        "description": "Read the contents of a research file.",
        "input_schema": {
            "type": "object",
            "properties": {
                "file_path": {"type": "string", "description": "Path to the file"}
            },
            "required": ["file_path"]
        }
    },
    # ... more tools totaling ~2,000 tokens in definitions
]


KNOWLEDGE_BASE = """## Company Policies and Guidelines
[... reference material totaling ~3,000 tokens ...]"""


def run_agent(user_query: str):
    messages = [{"role": "user", "content": user_query}]


    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        system=f"{SYSTEM_PROMPT}\n\n{KNOWLEDGE_BASE}",
        tools=TOOLS,
        messages=messages,
    )
    # Log token usage
    print(f"Input tokens: {response.usage.input_tokens}")
    return response

Nachher (mit Prompt-Caching):

import anthropic


client = anthropic.Anthropic()


SYSTEM_PROMPT = """You are a research assistant specializing in market analysis.
You have access to tools for searching databases, reading files, and performing
calculations. Always cite your sources and provide confidence levels for your
findings. [... detailed instructions totaling ~1,500 tokens ...]"""


KNOWLEDGE_BASE = """## Company Policies and Guidelines
[... reference material totaling ~3,000 tokens ...]"""


TOOLS = [
    {
        "name": "search_database",
        "description": "Search the company database for market data, competitor info, or financial records.",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "Search query"},
                "database": {"type": "string", "enum": ["market", "competitors", "financial"]},
                "limit": {"type": "integer", "description": "Max results", "default": 10}
            },
            "required": ["query", "database"]
        }
    },
    {
        "name": "read_file",
        "description": "Read the contents of a research file.",
        "input_schema": {
            "type": "object",
            "properties": {
                "file_path": {"type": "string", "description": "Path to the file"}
            },
            "required": ["file_path"]
        },
        "cache_control": {"type": "ephemeral"}  # Cache breakpoint after tools
    },
]


def run_agent_cached(user_query: str):
    messages = [{"role": "user", "content": user_query}]


    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        system=[
            {
                "type": "text",
                "text": SYSTEM_PROMPT,
            },
            {
                "type": "text",
                "text": KNOWLEDGE_BASE,
                "cache_control": {"type": "ephemeral"},  # Cache breakpoint
            },
        ],
        tools=TOOLS,
        messages=messages,
    )
    # Log token usage — now includes cache metrics
    usage = response.usage


---


## Verwandte Artikel


- [Agentkosten optimieren: Ein praktischer Leitfaden zur Senkung von API-Ausgaben](/de/blog/agent-cost-optimization-a-practical-guide-to-reducing-api-spend/)
- [Agent-Fehlerbehandlung: 5 Muster für Produktionszuverlässigkeit](/de/blog/agent-error-recovery-patterns/)
- [Tool-Nutzungsmuster: Zuverlässige Agent-Tool-Schnittstellen entwickeln](/de/blog/agent-tool-use-patterns/)