Schnellantwort: Prompt Caching senkt die LLM-API-Eingabekosten um 50% bis 90% und reduziert die Time-to-First-Token (TTFT) um bis zu 85%, indem berechnete KV-Cache-Tensoren über Requests hinweg wiederverwendet werden. Anthropic bietet 90% Lese-Rabatt mit expliziten Breakpoints (ab 1.024 Tokens). OpenAI liefert automatische 50% Rabatt ohne Schreibaufschlag. DeepSeek ermöglicht 80% bis 90% Ersparnis ab einer Schwelle von nur 64 Tokens mit persistentem NVMe-Speicher.
1. Einführung: Die Ökonomie des Zustands in zustandslosen LLM-APIs
Moderne APIs für große Sprachmodelle (LLMs) sind per Architekturprinzip zustandslos (stateless): Jeder HTTP-POST-Request an /v1/chat/completions oder /v1/messages muss den gesamten Gesprächsverlauf, Systeminstruktionen, Tool-Definitionen und Dokumentkontexte vollständig übertragen. Während dieses zustandslose Design Lastverteilung und horizontales Autoscaling in GPU-Clustern vereinfacht, verursacht es in mehrstufigen Agenten-Workflows enorme wirtschaftliche und rechnerische Ineffizienzen.
In autonomen Agenten-Loops – wie Claude Code, Roo Code, Aider, Devin oder Enterprise-RAG-Systemen – sendet der Agent bei jedem Interaktionsschritt identische System-Prompts, OpenAPI-Schemas, Model Context Protocol (MCP) Definitionen und Code-Snapshots erneut. Bei Schritt 15 einer typischen Programmieraufgabe bestehen 95% bis 98% aller übertragenen Tokens aus statischen Präfixen, die das Modell bereits mehrfach verarbeitet hat.
Bisher berechneten Cloud-Anbieter für jedes einzelne Token bei jedem Aufruf den vollen Basis-Input-Preis, wodurch Inferenzcluster rechenintensive Matrixmultiplikationen (Prefill-Phase) über unveränderten Kontext wiederholen mussten. Prompt Caching löst dieses Problem grundlegend. Durch das Vorhalten vorberechneter Key-Value (KV) Aktivierungs-Tensoren statischer Präfixe im schnellen GPU-Speicher (HBM), Host-RAM oder auf extrem schnellen NVMe-SSDs entfällt der redundante Prefill-Rechenaufwand vollständig.
Engineering-Teams, die Prompt Caching gezielt einsetzen, verzeichnen regelmäßig Kostensenkungen von 60% bis 88% auf ihren API-Rechnungen und reduzieren die Time-to-First-Token (TTFT) von mehreren Sekunden auf wenige hundert Millisekunden.
2. Architektur: KV-Cache-Mechanik und der Prefill-Flaschenhals
Um die Wirtschaftlichkeit von Prompt Caching zu verstehen, müssen Ingenieure die physikalischen Grenzen der Transformer-Inferenz auf modernen Beschleunigern (NVIDIA H100/B200, Google TPU v5e/v6e, AMD MI300X) betrachten.
Traditionelle zustandslose Inferenz-Pipeline:
[Statischer System-Prompt + Tool-Schemas + Verlauf (64.000 Tokens)]
│
▼
[Vollständige Prefill-Phase (O(N²) FLOPs)]
Dichte Matrixmultiplikation berechnet alle Q, K, V neu
│
▼
[Erstes Token generiert (TTFT: 2.8s)]
[Kosten: Voller Basis-Input-Tarif × 64.000 Tokens]
Inferenz-Pipeline mit Prompt Caching:
[Statisches Präfix (60.000 Tokens)] ──► [Präfix-Hash-Treffer!] ──► [Gespeicherte KV-Tensoren laden]
│ (Überspringt Matrix-FLOPs)
[Dynamische Abfrage (4.000 Tokens)] ──► [Prefill nur für Delta] ───────┤
▼
[Erstes Token generiert (TTFT: 0.35s)]
[Kosten: Cache-Read-Tarif×60k + Basis×4k]Der Rechenflaschenhals der Self-Attention
In der standardmäßigen Multi-Head Self-Attention werden Input-Tokens in Query- ($Q$), Key- ($K$) und Value- ($V$) Matrizen der Dimension $d_k$ projiziert:
$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$
Während der Prefill-Phase verarbeitet die GPU alle Prompt-Tokens parallel. Da Self-Attention die Wechselbeziehungen zwischen allen Token-Paaren evaluiert, skaliert die rechnerische Komplexität (FLOPs) quadratisch mit der Sequenzlänge $N$:
$$\text{FLOPs}_{\text{prefill}} \approx 2 \cdot P \cdot N^2 + 4 \cdot N \cdot d_{\text{model}} \cdot d_{\text{ffn}}$$
Bei einem 70B-Modell und einem 64.000-Token-Prompt erfordert allein der Prefill etwa $5.8 \times 10^{14}$ Gleitkommaoperationen, bevor das erste Antwort-Token erzeugt wird.
In der Decode-Phase werden Tokens autoregressiv nacheinander generiert. Um vorherige Tokens nicht neu zu berechnen, speichert die Engine die Aktivierungsvektoren $K$ und $V$ im Speicher – den KV-Cache. Der Speicherbedarf pro Token über $L$ Schichten mit $H_{kv}$ KV-Köpfen der Dimension $D$ beträgt:
$$\text{Memory}_{\text{KV}} = 2 \times 2 \times L \times H_{kv} \times D \quad \text{(Bytes in FP16 / BF16)}$$
Prompt Caching erweitert diesen prozessinternen KV-Cache zu einer anfrageübergreifenden Speicherebene. Stimmt der kryptografische SHA-256-Hash eines eingehenden Präfix mit einem existierenden KV-Block überein, lädt das System die Tensoren direkt und umgeht die Prefill-Phase vollständig.
3. Provider-Vergleichsmatrix: Anthropic vs OpenAI vs DeepSeek
| Architektur-Dimension | Anthropic Claude | OpenAI (GPT-4o / o1 / o3) | DeepSeek (V3 / V4 / R1) |
|---|---|---|---|
| Aktivierungsmechanismus | Explizite Breakpoints (cache_control) |
Vollautomatisch (Longest Common Prefix) | Vollautomatisch (Longest Common Prefix) |
| Mindestaktivierungsschwelle | 1.024 Tokens (Sonnet/Opus) 2.048 Tokens (Haiku) |
1.024 Tokens | 64 Tokens (KV-Blockgröße) |
| Block-Granularität | Frei wählbare Breakpoints (max. 4/Request) | 128-Token-Schritte oberhalb von 1.024 | Exakte 64-Token-Hardwaregrenze |
| Gültigkeitsdauer (TTL) | 5 Minuten (Standard) 1 Stunde (Erweiterte TTL) |
5 bis 10 Minuten (dynamisches LRU) | Mehrere Stunden bis persistent (NVMe) |
| TTL-Verlängerung | Verlängerung um 5m / 1h bei jedem Treffer | Automatische Verlängerung bei Zugriff | Dauerhafte Speicherung auf SSD |
| Schreibaufschlag (Write) | +25% (1.25x Basistarif für 5m) +100% (2.0x Basistarif für 1h) |
$0.00 (1.0x Basis-Input-Tarif) | $0.00 (1.0x Basis-Input-Tarif, kein Aufpreis) |
| Lese-Rabatt (Read) | 90% Rabatt (0.10x Basistarif) | 50% Rabatt (0.50x Basistarif) | 75% bis 90% Rabatt (0.10x–0.25x Basistarif) |
| Speichergebühren | Im Schreibaufschlag enthalten | Kostenlos | Kostenlos (NVMe-basiert) |
| Latenzreduktion (TTFT) | Bis zu 85% schneller | Bis zu 50% schneller | Bis zu 80% schneller |
4. Vollständige Preismatrix nach Modellen (USD pro 1M Tokens)
| Modell | Standard Input ($/1M) | Cache Write ($/1M) | Cache Read ($/1M) | Lese-Rabatt | Output ($/1M) | Min. Cache-Schwelle |
|---|---|---|---|---|---|---|
| Claude 3.5 / 3.7 Haiku | $0.80 | $1.00 (5m) / $1.60 (1h) | $0.08 | 90.0% | $4.00 | 2.048 Tokens |
| Claude 3.7 Sonnet | $3.00 | $3.75 (5m) / $6.00 (1h) | $0.30 | 90.0% | $15.00 | 1.024 Tokens |
| Claude 3 Opus / Opus 4.6 | $15.00 | $18.75 (5m) / $30.00 (1h) | $1.50 | 90.0% | $75.00 | 1.024 Tokens |
| OpenAI GPT-4o mini | $0.15 | $0.15 | $0.075 | 50.0% | $0.60 | 1.024 Tokens |
| OpenAI GPT-4o | $2.50 | $2.50 | $1.25 | 50.0% | $10.00 | 1.024 Tokens |
| OpenAI o1 | $15.00 | $15.00 | $7.50 | 50.0% | $60.00 | 1.024 Tokens |
| OpenAI o3-mini | $1.10 | $1.10 | $0.55 | 50.0% | $4.40 | 1.024 Tokens |
| DeepSeek V3 / V4 (Off-Peak) | $0.14 | $0.14 | $0.014 | 90.0% | $0.28 | 64 Tokens |
| DeepSeek V3 / V4 (Peak) | $0.27 | $0.27 | $0.027 | 90.0% | $1.10 | 64 Tokens |
| DeepSeek R1 (Reasoning) | $0.55 | $0.55 | $0.14 | 74.5% | $2.19 | 64 Tokens |
| Google Gemini 2.5 Flash | $0.15 | $0.15 | $0.0375 | 75.0% | $0.60 | 32.768 Tokens |
| Google Gemini 2.5 Pro | $1.25 | $1.25 | $0.3125 | 75.0% | $5.00 | 32.768 Tokens |
5. Mathematische Modellierung & Beweis der 90% Ersparnis
Break-Even-Berechnung ($N^*$)
Bei Anthropic mit 25% Schreibaufschlag ($R_{\text{write}} = 1.25 R_{\text{base}}$, $R_{\text{read}} = 0.10 R_{\text{base}}$):
$$1.25 + 0.10(N - 1) \le N \implies 1.15 \le 0.90N \implies N \ge \frac{1.15}{0.90} \approx 1.278$$
Theorem 1: Bei Anthropics 5-Minuten-TTL erreicht Prompt Caching den Break-Even bei exakt 2 Aufrufen. Jede Session ab 2 Requests ist profitabel.
Bei der 1-stündigen TTL ($R_{\text{write}} = 2.0 R_{\text{base}}$):
$$2.0 + 0.10(N - 1) \le N \implies 1.90 \le 0.90N \implies N \ge 2.11$$
Theorem 2: Bei der 1-Stunden-TTL amortisiert sich das Caching bereits ab dem 3. Request.
Asymptotischer Beweis der 90% Kostenreduktion
Bei langen Sitzungen ($N \to \infty$):
$$\lim_{N \to \infty} S(N) = 1 - \frac{R_{\text{read}}}{R_{\text{base}}}$$
- Anthropic / DeepSeek: $1 - 0.10 = \mathbf{90.0\%}$ maximale theoretische Ersparnis.
- OpenAI: $1 - 0.50 = \mathbf{50.0\%}$ maximale theoretische Ersparnis.
6. Code-Implementierung: Python & TypeScript
Anthropic Claude (Python)
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-3-7-sonnet-20250219",
max_tokens=2048,
system=[
{
"type": "text",
"text": "Umfangreiche Systemrichtlinien...\n" * 400,
"cache_control": {"type": "ephemeral"} # Expliziter Breakpoint
}
],
messages=[{"role": "user", "content": "Refaktoriere den Auth-Service."}]
)
print("Cache Read Tokens:", getattr(response.usage, "cache_read_input_tokens", 0))OpenAI (TypeScript / Node.js)
import OpenAI from "openai";
const openai = new OpenAI();
const res = await openai.chat.completions.create({
model: "gpt-4o",
messages: [
{ role: "system", content: "Statische Richtlinien...\n".repeat(400) },
{ role: "user", content: "Zeige Status von Auftrag #123." }
]
});
console.log("Cached Tokens:", (res.usage as any)?.prompt_tokens_details?.cached_tokens ?? 0);7. Praxiserprobte Fallstudien aus der Industrie
- Coding-Agenten (Claude Code, 250k LOC Monorepo): 20 Entwickler senkten monatliche Kosten von $29.700 auf $4.334 / Monat (85.4% Netto-Ersparnis).
- Enterprise Long-Doc RAG (OpenAI GPT-4o): 50.000 Monatsabfragen auf 45k-Token-Regelwerk sanken von $5.625 auf $2.975,63 / Monat (47.1% Ersparnis).
- High-Scale Support Bot (DeepSeek V3/V4): 2 Millionen Interaktionen fielen von $3.360 auf $378,34 / Monat (88.7% Ersparnis).
8. Fünf kritische Anti-Patterns, die den Cache zerstören
- Dynamische Zeitstempel im System-Prompt: Verändern den SHA-256-Hash im Sekundentakt und senken die Trefferquote auf 0%.
- Unsortierte Tool-Definitionen: Zufällige JSON-Objektreihenfolgen führen zu Cache-Misses. Tool-Arrays stets alphabetisch sortieren.
- Dynamische Variablen inmitten des Präfix: Das Caching erfordert identische Präfixe. Statische Anteile stets an den Anfang stellen.
- Übersehen des 5-Minuten-TTL-Fensters: Nach Pausen fällt der Cache weg. Bei langen Denkpausen 1h-TTL nutzen.
- Unterschreiten der Mindestgröße: Prompts unter 1.024 Tokens werden unbemerkt zum Vollpreis abgerechnet.
9. Fazit & LLMPodium-Empfehlung
- Für autonome Coding-Agenten: Anthropic Claude 3.7 Sonnet mit 90% Lese-Rabatt ist der unangefochtene Standard.
- Für bestehende Pipelines ohne Umbau: OpenAI GPT-4o bietet sofortige 50% Ersparnis ohne Codeänderungen.
- Für maximales Volumen zum Tiefstpreis: DeepSeek V3/V4 liefert dank 64-Token-Schwelle und $0.014/1M unschlagbare Wirtschaftlichkeit.