---
title: Optimierung von Kosten und Intelligenz
url: https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence
description: Bringe Kosten und Intelligenz auf der Claude Platform ins Gleichgewicht, mit gemessenen Ergebnissen für Prompt-Caching, Effort, Modellwahl, Ausgabelimits und Multi-Modell-Strategien.
---
Das leistungsfähigste Modell kann im großen Maßstab zu teuer sein, und das günstigste Modell kann bei der Qualität zu kurz kommen. Die Claude Platform gibt dir direkte Kontrolle über diesen Zielkonflikt. Du wählst für jede Anfrage das Modell, die Effort-Stufe und die Architektur, wodurch du einen Workload nahezu überall auf der Grenze zwischen Kosten und Intelligenz platzieren kannst.
Kosten und Intelligenz werden meist als Grenzlinie dargestellt, auf der das eine das andere erkauft. Die erste Gruppe von Hebeln auf dieser Seite bewegt einen Workload auf diese Grenze zu, indem sie Kosten senkt, ohne die Qualität anzutasten; nur die zweite Gruppe bewegt ihn entlang der Grenze:
Es gibt zwei Arten von Hebeln:
* **Kostenlose Gewinne** senken die Ausgaben, ohne die Qualität anzutasten: „prompt caching" (Prompt-Caching), Token-Hygiene, ein Prompt-Audit gegen das Modell, das du verwendest, [Batch-Verarbeitung](https://platform.claude.com/docs/de/build-with-claude/batch-processing) mit 50 % Rabatt für Arbeit, die bis zu 24 Stunden warten kann, und [Ausgabenlimits für Workspaces](https://platform.claude.com/docs/de/api/rate-limits#setting-lower-limits-for-workspaces) als Absicherung.
* **Zielkonflikte** tauschen Kosten gegen Intelligenz: Modellwahl, Effort, Ausgabelimits und Sitzungsbudgets, eine Uhr für die verstrichene Zeit und Multi-Modell-Architekturen.
Zu jedem Hebel gibt es gemessene Ergebnisse und die Regel, wann er sich lohnt. In den Messungen von Anthropic war Prompt-Caching meist der größte Hebel. Die Multi-Modell-Hebel sind enger gefasst; ein zweites Modell wurde in zwei Formen gemessen, als Advisor und als Orchestrator.
## Hier beginnen
Ordne deine Situation einer Zeile zu.
| Deine Situation | Tu Folgendes | Wo |
| ---------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Jeder Workload, jedes Modell | Aktiviere Prompt-Caching und kürze unnötige Token; beides ist kostenlos | [Wiederholten Kontext cachen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context) · [Token kürzen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
| Eine Person wartet zwischen den Turns | Zähle die Lücken zwischen deinen Anfragen und wähle dann die Cache-Dauer aus der Tabelle im verlinkten Abschnitt | [Cache-Dauer wählen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#pick-the-cache-duration) |
| Die Kosten sind zu hoch; die Qualität passt | Probiere einen niedrigeren Effort mit dem Modell, das du jetzt verwendest | [Effort abstimmen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort) |
| Du verwendest nicht das neueste Modell | Führe ein Upgrade durch; in den Messungen von Anthropic löste jedes neuere Modell mindestens so viele Aufgaben wie sein Vorgänger, meist zu geringeren Kosten pro gelöster Aufgabe | [Modell upgraden](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#upgrade-the-model) |
| Du wählst oder wechselst Modelle | Vergleiche anhand der Kosten pro abgeschlossener Aufgabe, nicht pro Token | [Modelle vergleichen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) |
| Arbeit mit hohem Volumen und überprüfbaren Ausgaben | Probiere zuerst Claude Haiku 5.5 | [Modelle vergleichen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) |
| Die Qualität reicht nicht aus | Wenn du den Effort gesenkt hast, stelle ihn wieder her; andernfalls probiere die nächsthöhere Stufe mit ihrem Standard-Effort | [Effort abstimmen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort) · [Modelle vergleichen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) |
| Versuche enden mit `stop_reason: max_tokens` | Erhöhe `max_tokens` auf 64.000: In Anthropics Tests waren nur 2 von etwa 14.000 Turns länger, und die Kosten pro gelöster Aufgabe blieben etwa gleich | [Budgets festlegen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps) |
| Du kannst Ausgaben prüfen (Tests, ein Verifier) | Arbeite mit `low` Effort und wiederhole Fehlschläge mit `high`: In Anthropics Tests etwa 40 % geringere Kosten als alles mit `high`, bei gleicher Erfolgsquote | [Fehlschläge wiederholen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#re-run-failures-at-higher-effort) |
| Agent-Schleifen mit einigen sehr teuren Durchläufen | Lege ein Sitzungsbudget für Claude Managed Agents und ein Ausgabenlimit für den Workspace fest | [Budgets festlegen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps) |
| Du möchtest, dass Agent-Durchläufe schneller fertig werden | Sag dem Modell, dass Zeit wichtig ist, und zeige ihm die verstrichene Zeit: 7 % bis 47 % weniger Zeit in Anthropics Tests, für ein paar Punkte Score | [Dem Modell die verstrichene Zeit zeigen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time) |
| Ein günstigeres Modell kommt nur bei schwierigen Entscheidungen nicht weiter | Probiere einen Advisor. Er kann nur helfen, wenn dein Modell ihn konsultiert; berechne zuerst die Kosten seines Modells allein bei niedrigem Effort und miss die Konsultationsrate | [Advisor-Strategie](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions) |
| Die Arbeit übersteigt ein Kontextfenster | Teile die Arbeit auf und übergib die Teile an günstigere Modelle | [Orchestrator-Strategie](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#orchestrator-strategy-delegate-bulk-work) |
Diese Ergebnisse sind Anthropic-intern ([Referenzierte Benchmarks](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs)) und richtungsweisend, keine Garantien; miss also auf deinem eigenen Workload mit der [Vier-Schritte-Methode](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#measure-on-your-own-workload).
## Ausgaben senken, ohne Qualität zu verlieren
Prompt-Caching, Token-Hygiene, Batch-Verarbeitung und ein Prompt-Audit gegen dein aktuelles Modell senken alle, was du zahlst, ohne die Ausgabequalität zu senken. Zwei Vorbehalte gelten: Batch-Verarbeitung tauscht Latenz gegen ihren Rabatt, und Context Editing, ein Token-Hygiene-Hebel, kostete im in diesem Abschnitt gemessenen Lauf mehr, als es einsparte.
### Wiederholten Kontext cachen
#### Warum Caching an erster Stelle steht
Aktiviere [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching) vor jedem anderen Hebel, denn jeder Turn einer agentischen Aufgabe sendet die gesamte wachsende Konversation erneut: System-Prompt, Tool-Definitionen und jeden vorherigen Turn.
* Eine Aufgabe mit 40 Turns sendet ihren ersten Turn 40-mal, sodass die Kosten einer Aufgabe ungefähr mit dem Quadrat der Anzahl der Turns wachsen.
* Caching verhindert das erneute Senden nicht, aber jedes erneute Senden kostet etwa ein Zehntel (ein Zwanzigstel bei Claude Opus 5.5 und Claude Sonnet 5.5, ein Vierzigstel bei Claude Fable 5.1 und Claude Mythos 5.1) und wird schneller verarbeitet.
* Das Präfix wird zum [Cache-Lesepreis](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#pricing) statt zum Eingabepreis abgerechnet, und jeder Turn zahlt den Cache-Schreibpreis von 1,25x nur für das, was neu ist.
**Wie gute Werte aussehen.**
* Über einen ganzen Tag echten Traffics lasen Agent-Schleifen im Median 84 % ihrer Eingabe aus dem Cache, und die besten 10 % davon, ob Coding oder nicht, lasen 94 % oder mehr[17](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs).
* Tief in einer Aufgabe zahlt eine gut gebaute Schleife für weniger als 1 % ihrer Eingabe den vollen Preis.
* Unter etwa 80 % solltest du nach etwas suchen, das den Cache bricht (siehe [Was den Cache bricht](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#what-breaks-the-cache)).
In den gemessenen Durchläufen von Anthropic sind Cache-Reads regelmäßig der größte Einzelposten der Aufgabenkosten, wodurch Caching mehr wert ist als die meisten Entscheidungen zur Modellwahl. Anthropic hat die Durchläufe von DeepResearch Bench II[7](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) mit und ohne Caching berechnet:
Die Standardlebensdauer des Caches beträgt 5 Minuten, und die Turns einer Agent-Schleife liegen Sekunden auseinander, sodass der Rabatt bei jedem Turn für die meisten Token gilt. Die Durchläufe im Caching-Diagramm lasen 84 % bis 90 % ihrer Eingabe-Token aus dem Cache.
Berechnet man die aufgezeichneten Token-Zahlen anderer Durchläufe auf dieselbe Weise, mit jedem Modell bei seinem Standard-Effort, ergeben sich die durchschnittlichen Token-Kosten pro Aufgabe ohne Caching (keiner dieser Durchläufe wurde mit deaktiviertem Caching durchgeführt):
| Benchmark | Modell | Ohne Caching |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------------------------------ |
| SWE-bench Pro[3](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Opus 5.5 | das 3,3-Fache der Kosten mit Caching |
| SWE-bench Pro | Claude Sonnet 5.5 | das 3,1-Fache der Kosten mit Caching |
| Aufgabenset für Claude Managed Agents[25](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs), dessen Sitzungen kurz sind | Claude Haiku 5.5 | das 1,7-Fache der Kosten mit Caching |
| Ein kleiner Agent, der Fehlerberichte sichtet ([Input- und Kontext-Token kürzen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens))[16](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Sonnet 5.5 | das 7,3-Fache der Kosten mit Caching |
Die Ersparnis hängt davon ab, wie viele Turns eine Aufgabe benötigt, denn kürzere Schleifen lesen weniger erneut.
Bei Claude Haiku 5.5 solltest du [eine lange Sitzung komprimieren](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#manage-the-context-lifecycle), und zwar an einer Aufgabengrenze, bevor ihre Anfragen 100.000 Prompt-Token überschreiten. Eine Anfrage, deren Prompt über 100.000 Token liegt, zahlt für jedes ihrer Token das 5-Fache, einschließlich der Ausgabe. Cache-Lese- und Cache-Schreibvorgänge zählen zu den 100.000 Token, sodass eine Anfrage mit einem großen gecachten Präfix trotzdem darüber liegen kann. Siehe [Preise für langen Kontext](https://platform.claude.com/docs/de/about-claude/pricing#long-context-pricing).
#### Cache-Dauer wählen
Wenn deine Schleife zwischen den Turns auf eine Person wartet, verwende die [1-Stunden-Cache-Dauer](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#1-hour-cache-duration), sobald etwa 1 von 20 Turns auf eine Pause zwischen 5 Minuten und einer Stunde folgt und nur wenige Lücken länger als eine Stunde dauern. Bei Claude Fable 5.1, Claude Opus 5.5 und Claude Sonnet 5.5 kann es günstiger sein, den 5-Minuten-Cache warm zu halten.
Die 1-Stunden-Dauer kostet beim Schreiben mehr (das 2-Fache des Eingabepreises statt des 1,25-Fachen). Ein Cache-Miss bei beiden Dauern rechnet das gesamte Präfix zum Schreibpreis statt zum Lesepreis ab.
Anthropic hat einen kleinen Agenten gemessen, der Fehlerberichte sichtet ([Input- und Kontext-Token kürzen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens)), wobei vor einigen Turns Pausen eingefügt wurden, um die Verzögerung durch eine Person zu simulieren[16](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs). Die Genauigkeit blieb bei jeder gemessenen Einstellung innerhalb des Rauschens zwischen Durchläufen. Anthropic hat außerdem zusätzliche Anfragen gemessen, die den 5-Minuten-Cache warm halten (Keep-alive-Anfragen).
Um zu entscheiden, zähle die Lücken zwischen aufeinanderfolgenden Anfragen in einer Konversation und finde deine Zeile in der folgenden Tabelle:
| Deine Lücken zwischen Anfragen | Modell | Verwende |
| ------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------- | --------------------------------------------------------- |
| Turns kommen im Sekundenabstand | Alle | 5-Minuten-Standard |
| Etwa 1 von 20 Lücken oder mehr liegt zwischen 5 Minuten und einer Stunde, und nur wenige Lücken dauern länger als eine Stunde | Alle | 1-Stunden-Dauer |
| Lücken über einer Stunde sind häufig: Etwa 60 % oder mehr deiner Pausen, die länger als 5 Minuten sind, dauern auch länger als eine Stunde | Alle | 5-Minuten-Standard |
| Nur 1 oder 2 von 20 Lücken liegen zwischen 5 Minuten und einer Stunde, und keine dauert länger als etwa eine halbe Stunde | Claude Opus 5.5 und Claude Sonnet 5.5 | Warm gehaltener 5-Minuten-Cache statt der 1-Stunden-Dauer |
| Vor jedem Turn kommt eine Pause | Claude Opus 5.5 und Claude Sonnet 5.5 | 1-Stunden-Dauer |
| Pausen dauern Minuten | Claude Fable 5.1 | Warm gehaltener 5-Minuten-Cache statt der 1-Stunden-Dauer |
| Pausen dauern fast eine Stunde | Claude Fable 5.1 | 1-Stunden-Dauer |
Verwende bei Claude Haiku 5.5 die Zeilen „Alle“. Keep-alive-Anfragen wurden dort nicht gemessen. Nach Listenpreisen, nicht nach Messung, kostet jede davon im Verhältnis zum Eingabepreis doppelt so viel wie bei Claude Opus 5.5 und Claude Sonnet 5.5: Claude Haiku 5.5 liest den Cache zum Standardwert von 0,1x, diese beiden zu 0,05x.
**Warum, Zeile für Zeile.**
* **Jedes Modell.**
* **Turns kommen im Sekundenabstand.** Keine Pausen: Der Standard kostete bei Claude Sonnet 5.5 etwa 19 % weniger als die 1-Stunden-Einstellung, bei Claude Opus 5.5 etwa 15 % bis 18 % weniger.
* **Etwa 1 von 20 Lücken oder mehr.** Der aus Token-Zahlen berechnete Break-even liegt bei Claude Sonnet 5.5 und Claude Opus 5.5 bei etwa 1 von 30 Turns.
* **Lücken über einer Stunde sind häufig.** Bei jedem Modell lässt eine Lücke von über einer Stunde beide Dauern ablaufen, und die 1-Stunden-Einstellung schreibt das Präfix dann zu ihrem höheren Schreibpreis neu.
* **Claude Opus 5.5 und Claude Sonnet 5.5**, deren Cache-Lesevorgänge das 0,05-Fache des Eingabepreises kosten.
* **Nur 1 oder 2 von 20 Lücken.** Beim Standard-Effort kosteten Keep-alive-Anfragen bei Claude Opus 5.5 8 % bis 13 % weniger als die 1-Stunden-Dauer, bei Claude Sonnet 5.5 8 % bis 16 % weniger.
* **Vor jedem Turn kommt eine Pause.** Bei Claude Opus 5.5 und Claude Sonnet 5.5 kosteten Keep-alive-Anfragen bei 6-minütigen Pausen ein paar Prozent mehr als die 1-Stunden-Dauer und bei 45-minütigen Pausen über 50 % mehr.
* **Claude Fable 5.1**, deren [Cache-Lesevorgänge](https://platform.claude.com/docs/de/about-claude/pricing#prompt-caching) das 0,025-Fache des Eingabepreises kosten.
* **Pausen dauern Minuten.** Bei Claude Fable 5.1 kosteten Keep-alive-Anfragen[19](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) 13 % bis 20 % weniger als der 1-Stunden-Cache, sowohl mit 10 % pausierten Turns als auch mit einer 6-minütigen Pause vor jedem Turn.
* **Pausen dauern fast eine Stunde.** Bei Claude Fable 5.1 gewann der 1-Stunden-Cache nur mit einer 45-minütigen Pause vor jedem Turn, und zwar um etwa 0,12 $ bei einer Sitzung mit 5 Fehlerberichten.
Das folgende Diagramm zeigt die Kosten pro Sitzung in Abhängigkeit vom Anteil pausierter Turns bei Claude Sonnet 5.5:
Das folgende Diagramm ergänzt den durch Keep-alive-Anfragen warm gehaltenen 5-Minuten-Cache bei Claude Fable 5.1, Claude Opus 5.5 und Claude Sonnet 5.5:
**Was du wissen solltest.**
* Die 1-von-20-Regel lässt einen Spielraum gegenüber dem Break-even von etwa 1 von 30 Turns. Bei 1 von 20 Turns kosteten die 5-Minuten- und die 1-Stunden-Einstellung bei Claude Sonnet 5.5 etwa gleich viel, innerhalb der Schwankung zwischen Durchläufen; bei 1 von 10 Turns kostete die 5-Minuten-Einstellung 54 % mehr (Referenz 16).
* Bei anderen Modellen als Claude Sonnet 5.5 und Claude Opus 5.5 legen die Preise den Break-even in denselben Bereich: Jedes aktuelle Modell verwendet dieselben Cache-Schreibmultiplikatoren, und jedes Modell außer Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5 und Claude Sonnet 5.5 denselben Lesepreis.
* Die Keep-alive-Werte für Claude Opus 5.5 und Claude Sonnet 5.5 stammen von Anfragen, die mit `max_tokens: 1` gesendet wurden. Ob eine Anfrage mit `max_tokens: 0` einen bestehenden Cache-Eintrag auffrischt, wurde bei Claude Opus 5.5 nicht gemessen (Referenz 16).
So hältst du den Cache warm:
1. Nimm die vorherige Anfrage, setze `max_tokens` auf 0 und entferne `stream`, falls es gesetzt war. Ändere kein einziges Byte des Präfixes.
2. Sende die Header der Anfrage zusammen mit ihrem Body erneut. Ohne den `anthropic-beta`-Header der ursprünglichen Anfrage werden die Beta-gebundenen Felder im erneut gesendeten Body abgelehnt.
3. Sende sie innerhalb von 4 Minuten nach dem Start der vorherigen Anfrage und danach alle 4 Minuten. Zähle ab dem Start der Anfrage, denn die [5-minütige Lebensdauer des Caches](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#how-prompt-caching-works) läuft ab dort.
Das ist die [Pre-Warming-Anfrage](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#pre-warming-the-cache): Sie frischt die Lebensdauer des Caches auf, gibt keine Ausgabe zurück und kostet kaum mehr als der Cache-Lesevorgang. Sobald der Cache abgelaufen ist, schreibt die nächste Anfrage, ob Keep-alive oder nicht, das Präfix zum Cache-Schreibpreis neu[16](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs).
Eine Anfrage mit `max_tokens: 0` wird in den folgenden Fällen abgelehnt:
* Die Anfrage setzt `thinking.type: "enabled"` (das standardmäßige adaptive Nachdenken bei Claude Fable 5.1 ist in Ordnung), strukturierte Ausgaben oder eine erzwungene Tool-Auswahl ([ihre Einschränkungen](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#limitations)). Kaufe bei diesen Workloads stattdessen die 1-Stunden-Dauer.
* Die Anfrage enthält den Top-Level-Parameter `compaction`; sende also keine Compaction-Anfrage aus [Komprimierung auf Anfrage](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand) als Keep-alive-Anfrage erneut.
```bash cURL
# Innerhalb von 4 Minuten nach dem Start der letzten Anfrage (die Generierungszeit zählt
# zur Lebensdauer des Caches) sendest du diese Anfrage erneut mit max_tokens auf
# 0 und ohne stream (eine Anfrage mit max_tokens: 0 kann nicht streamen). Sende dieselben
# Header wie bei der ursprünglichen Anfrage, einschließlich eines anthropic-beta-Headers.
jq '.max_tokens = 0 | del(.stream)' last_request.json | \
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
--data-binary @-
```
#### Caching einschalten
Die Einrichtung erfordert wenig Aufwand. [Automatisches Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#automatic-caching) setzt Breakpoints für dich; andernfalls kann der [Claude API Skill](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/claude-api-skill), der mit Claude Code ausgeliefert wird, einer bestehenden Integration mit einem einzigen Prompt Caching hinzufügen: `/claude-api add prompt caching to this integration`. Im Code, der diese Messungen erzeugt hat, setzte er einen Breakpoint auf den System-Block und je einen auf die beiden jüngsten User-Turns; [Explizite Cache-Breakpoints](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#explicit-cache-breakpoints) erklärt, wo du sie platzierst.
#### Was den Cache bricht
Halte anfragespezifischen Text im neuesten User-Turn, nach dem letzten Cache-Breakpoint, und nimm jede Cache-invalidierende Änderung an einer natürlichen Unterbrechung vor, etwa bei der ersten Anfrage nach einer Compaction. Der Cache ist ein byte-genauer Präfixabgleich über die Anfrage in ihrer Reihenfolge (Tools, dann System-Prompt, dann Nachrichten), sodass eine Änderung an beliebiger Stelle alles danach invalidiert.
Am meisten steht bei Claude Fable 5.1 und Claude Mythos 5.1 auf dem Spiel, wo ein Bruch das Präfix zum 1,25-Fachen des Eingabepreises neu schreibt, statt es zum 0,025-Fachen zu lesen. Die folgende Tabelle zeigt, was ein gebrochener Turn bei einem Präfix von 100.000 Token kostet, berechnet aus Listenpreisen mit dem 5-Minuten-Cache, nicht gemessen:
| Modell | Ein gebrochener Turn | Stattdessen der Lesevorgang | Im Vergleich zum Lesevorgang |
| -------------------------------------- | -------------------- | --------------------------- | ---------------------------- |
| Claude Fable 5.1 und Claude Mythos 5.1 | 1,25 $ | 0,025 $ | 50-fach |
| Claude Opus 5.5 | 0,50 $ | 0,02 $ | 25-fach |
| Claude Sonnet 5.5 | 0,25 $ | 0,01 $ | 25-fach |
Bei den anderen aktuellen Modellen kostet er das 12,5-Fache des Lesevorgangs.
**Was du tun solltest.**
* Setze nichts, was sich pro Anfrage ändert, etwa einen Zeitstempel oder eine Warteschlangenposition, vor das stabile Präfix: Es macht jede Anfrage zu einem vollständigen Cache-Schreibvorgang. In einer Messung mit einem früheren Modell führte eine 25 Token lange Statuszeile am Anfang des System-Prompts dazu, dass ein Durchlauf eines kleinen Agenten, der Fehlerberichte sichtet ([Input- und Kontext-Token kürzen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens)), mehr kostete als ein Durchlauf mit deaktiviertem Caching[18](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs).
* Die Seite zu [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#what-invalidates-the-cache) listet die Änderungen auf, die den Cache invalidieren, etwa eine Änderung an [`effort`](https://platform.claude.com/docs/de/build-with-claude/effort), an der Konfiguration für das Nachdenken, am System-Prompt oder an einer Tool-Definition. Eine Änderung des Ausgabeformats invalidiert den Cache für diese Konversation (siehe [Strukturierte Ausgaben](https://platform.claude.com/docs/de/build-with-claude/structured-outputs#prompt-modification-and-token-costs)).
* Ändere bei den neuesten Modellen Anweisungen mit einer [System-Nachricht mitten in der Konversation](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages), einer an `messages` angehängten `{"role": "system"}`-Nachricht, statt das Top-Level-Feld `system` zu bearbeiten: Das gecachte Präfix bleibt intakt. Prüfe auf dieser Seite, welche Modelle das unterstützen. Eine Effort-Änderung pro Nachricht lässt das gecachte Präfix ebenfalls intakt, allerdings bei weniger Modellen: [Effort mitten im Gespräch ändern](https://platform.claude.com/docs/de/build-with-claude/effort#changing-effort-mid-conversation) listet sie auf.
* Prüfe nach einer Cache-invalidierenden Änderung, dass die Cache-Lesevorgänge nicht gesunken sind; falls doch, zeigt [Cache-Diagnose](https://platform.claude.com/docs/de/build-with-claude/cache-diagnostics), wo das Präfix abgewichen ist.
Anthropic hat den Zeitpunkt einer Änderung mit einem früheren Modell an den langen Sitzungen des Triage-Agenten gemessen[18](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs). In dieser Messung kosteten Sitzungen mehr, wenn eine Effort-Änderung und ein hinzugefügtes Tool mitten in der Sitzung oder bei der Anfrage, die die Compaction auslöste, vorgenommen wurden, als wenn dieselben beiden Änderungen bei der ersten Anfrage nach der Compaction vorgenommen wurden. Die Genauigkeit lag in jedem Fall innerhalb des Rauschens zwischen Durchläufen.
Die Sitzungen ohne Änderungen kosteten mehr als die nach der Compaction geänderten Sitzungen, aber nicht wegen des Cachings. Sie liefen durchgehend mit dem Standard-Effort, und zwei wurden ein zweites Mal komprimiert, während die anderen mit niedrigem Effort begannen (Referenz 18):
### Input- und Kontext-Token kürzen
Die meisten Agent-Anfragen enthalten Token, die die Antwort nie beeinflussen. Sie zu kürzen kostet selten Ausgabequalität, auch wenn nicht jeder Hebel hier in der Messung Geld gespart hat. Es gibt zwei Ansatzpunkte:
* **Input-Trimming.**
* [Dynamisches Filtern](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool#dynamic-filtering) im Web-Fetch-Tool hält Boilerplate aus abgerufenen Seiten heraus.
* [Bildgrößenanpassung](https://platform.claude.com/docs/de/build-with-claude/vision#evaluate-image-size) bringt Vision-Eingaben auf die richtige Größe.
* [Tool-Suche mit verzögertem Laden](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-search-tool) lädt Tool-Definitionen nur bei Bedarf (weiter unten in diesem Abschnitt gemessen).
* [Programmatische Tool-Aufrufe](https://platform.claude.com/docs/de/agents-and-tools/tool-use/programmatic-tool-calling) lassen Claude mehrere Tool-Aufrufe aus Code ausführen, sodass nur das gefilterte Ergebnis in den Kontext gelangt; die zugehörige Dokumentation berichtet von 24 % weniger Eingabe-Token bei agentischen Such-Benchmarks, mit höherem Score.
* [Tool-Kontext verwalten](https://platform.claude.com/docs/de/agents-and-tools/tool-use/manage-tool-context) vergleicht Tool-Suche, programmatische Tool-Aufrufe, Prompt-Caching und Context Editing.
* **Kontext-Lebenszyklus.** [Context Editing](https://platform.claude.com/docs/de/build-with-claude/context-editing) löscht veraltete Tool-Ergebnisse. [Automatische Compaction](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold) mit ihrem Schwellenwert verhindert, dass lange Schleifen ihren gesamten Verlauf mitschleppen.
Die Hebel wirken mit dem Cache und untereinander zusammen; beurteile sie daher nach ihrem Nettoeffekt und verwende [Cache-Diagnose](https://platform.claude.com/docs/de/build-with-claude/cache-diagnostics), um zu bestätigen, dass dein gecachtes Präfix jede Änderung übersteht.
In Messungen mit einem früheren Modell[28](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) hat Anthropic sie an einem Issue-Triage-Agenten getestet, der 20 echte Fehlerberichte mit Screenshots aus einem öffentlichen Repository abarbeitete, sowie an einer längeren Variante derselben Aufgabe mit dem 2,6-Fachen an Token. Bei aktiviertem Caching senkte Input-Trimming (Bildgrößenanpassung und Tool-Suche) die Kosten beider Durchläufe weiter.
#### Ungenutzte Tool-Definitionen verzögert laden
Jede an eine Anfrage angehängte Tool-Definition ist bei jedem Turn Eingabe, und ein paar MCP-Server summieren sich auf Hunderte davon.
In einer Messung mit einem früheren Modell[27](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) hat Anthropic den Triage-Agenten mit seinen eigenen zwei Tools plus einem Katalog echter Tool-Definitionen aus öffentlichen MCP-Servern ausgeführt, insgesamt bis zu 502 Tools, wobei entweder alle geladen oder die zusätzlichen hinter der [Tool-Suche](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-search-tool) als `defer_loading` markiert wurden:
* Mit allen geladenen Definitionen stiegen die Durchlaufkosten mit wachsendem Katalog, entsprechend den Schema-Token in jeder Anfrage.
* Mit Tool-Suche blieben die Durchlaufkosten bei jeder Kataloggröße konstant.
* Die Genauigkeit lag in beiden Fällen im selben Bereich, und das Modell rief nie ein falsches Tool auf; in dieser Größenordnung kostet der Katalog also Geld, nicht Korrektheit.
* Mit demselben früheren Modell und einem öffentlichen GitHub-MCP-Server, der über den [MCP-Connector](https://platform.claude.com/docs/de/agents-and-tools/mcp-connector) angebunden war, senkte das verzögerte Laden seines Toolsets (`default_config: {defer_loading: true}`) die Durchlaufkosten bei gleicher Genauigkeit.
#### Datendateien aus dem Prompt heraushalten
Wenn das Modell über eine Tabelle rechnen muss, lade sie mit der [Files API](https://platform.claude.com/docs/de/build-with-claude/files) hoch und lass das Modell sie mit [Code-Ausführung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool) abfragen, statt sie einzufügen. Anthropic stellte 25 Aggregatfragen[15](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) (Summen, gefilterte Zählungen, Group-bys und ein Datumsfilter) zu einer öffentlichen CSV-Datei mit 1.862 Zeilen, wobei die Antworten mit pandas berechnet wurden:
In den Prompt eingefügt umfasst die Tabelle bei jeder Anfrage etwa 91.000 Eingabe-Token, und Claude Sonnet 5 beantwortete 7 von 25 Fragen richtig. Hochgeladen, mit Code-Ausführung, beantwortete es alle 25, und der Durchlauf kostete etwa ein Zwölftel. Claude Opus 5 zeigte dasselbe Muster.
#### Den Kontext-Lebenszyklus verwalten
Die Kontext-Hebel zahlen sich nur bei einer Sitzung aus, die lang genug ist, um sie zu brauchen:
Anthropic hat diese Hebel mit einem früheren Modell gemessen[28](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs):
* Beim Durchlauf mit 20 Issues sparten die Hebel wenig oder nichts, und Context Editing machte den Durchlauf teurer.
* Beim langen Durchlauf senkten sowohl das Pruning als auch die Compaction die Kosten, während Context Editing nichts änderte.
* Das Pruning besteht aus ein paar Zeilen, die du selbst schreibst: Ersetze an jeder Aufgabengrenze große veraltete Tool-Ergebnisse durch einen einzeiligen Auszug.
* Das Pruning lässt sich gut cachen, weil die Änderungen am Ende der Konversation liegen, wo die nächste Aufgabe ohnehin neuen Inhalt hinzufügt.
* Über den gesamten Durchlauf cachen Pruning und Context Editing etwa gleich gut. Wenn du Context Editing verwendest, [lösche in wenigen großen Batches](https://platform.claude.com/docs/de/build-with-claude/context-editing#context-editing-and-prompt-caching).
Bei Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 und Claude Haiku 5.5 [invalidiert das Umschreiben eines früheren Tool-Ergebnisses jeden Thinking-Block danach](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#prefix-check); verwende daher stattdessen Compaction. Das Pruning wurde mit einem früheren Modell ohne [erhaltenes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking) gemessen; bei diesen vier Modellen laufen [Context Editing](https://platform.claude.com/docs/de/build-with-claude/context-editing) und [Compaction](https://platform.claude.com/docs/de/build-with-claude/compaction) auf dem Server und invalidieren keine Thinking-Blöcke.
Das Pruning, adaptiert aus dem Code des Triage-Agenten:
```python
import re
PRUNED = "[pruned at issue boundary]"
def prune_task_boundary(messages, tool_name_by_id, threshold=2000):
"""Call once per task boundary. Replaces large, stale search results with a one-line extract."""
for message in messages:
if message["role"] != "user" or not isinstance(message["content"], list):
continue
for block in message["content"]:
if not (isinstance(block, dict) and block.get("type") == "tool_result"):
continue
if tool_name_by_id.get(block.get("tool_use_id")) != "search_issues":
continue
result_text = block.get("content")
if not isinstance(result_text, str) or len(result_text) <= threshold:
continue
if result_text.startswith(PRUNED):
continue # already pruned on an earlier boundary
# einzeilige Ergebnisse begrenzen, damit der Auszug kurz bleibt
first_line = result_text.split("\n", 1)[0].strip()[:200]
refs = re.findall(r"#(\d+)", result_text)[:5]
extract = f"{PRUNED} {first_line}"
if refs:
extract += " kept refs: " + " ".join("#" + r for r in refs)
block["content"] = extract
```
### Arbeit batchen, die warten kann
Leite jede Anfrage, auf die niemand wartet, über die [Batch API](https://platform.claude.com/docs/de/build-with-claude/batch-processing) und behalte den interaktiven Pfad für den Rest. Die Batch API gewährt 50 % Rabatt auf jedes Token einer Anfrage, einschließlich gecachter Token, im Gegenzug dafür, dass die Ergebnisse irgendwann innerhalb von 24 Stunden eintreffen.
* Batching ist nach Caching der zweitgrößte kostenlose Hebel für unbeaufsichtigte Agent-Arbeit: Evaluierungsläufe, Backfills und geplante Jobs wie ein wiederkehrender Lauf des Issue-Triage-Agenten aus der [Token-Trimming-Messung](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens).
* Batching lässt sich mit allem auf dieser Seite kombinieren außer mit Interaktivität, ist aber nicht für Sitzungen von Claude Managed Agents verfügbar, die von Natur aus interaktiv sind (siehe [Preise für Claude Managed Agents](https://platform.claude.com/docs/de/about-claude/pricing#claude-managed-agents-pricing)).
### Prompts gegen das aktuelle Modell auditieren
Auditiere Prompts gegen das Modell, das du jetzt verwendest, und erneut bei jedem Modellwechsel: Es ist ein kostenloser Gewinn.
* Jede Modellgeneration reagiert anders auf Prompts, sodass sich in einem Prompt Text ansammelt, der für ein Modell geschrieben wurde, das du nicht mehr verwendest.
* Der übliche Fall sind übermäßig spezifische Anweisungen, die hinzugefügt wurden, um ein älteres Modell auszugleichen: „zweimal überprüfen“, „maximal gründlich sein“, ein verpflichtendes Schritt-für-Schritt-Verfahren oder ein selbst gebautes Reasoning-Scratchpad.
* Ein neueres Modell befolgt solche Anweisungen buchstabengetreu, was zusätzliche Tool-Runden und zusätzlichen Text erzeugt, sodass die Rechnung ohne Genauigkeitsgewinn steigt.
Das Audit ist ein einziger Befehl. Der [Claude API Skill](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/claude-api-skill), der mit Claude Code ausgeliefert wird, hat einen `prompt-audit`-Befehl, der die Prompts und den Anfrage-Code eines Projekts liest und meldet, was für ein anderes Modell geschrieben wurde. Dieser gekürzte Auszug zeigt ihn bei der Ausführung gegen einen Support-Desk-Prompt und Anfrage-Code, die diese Muster enthalten:
```text wrap
$ claude
> /claude-api prompt-audit
10 findings. The three that matter most:
1. budget_tokens returns a 400 on Opus 5 (support_agent.py:10). This code
does not run against its own target model. Everything else here is
quality; this one is an outage.
2. The prompt contains two live contradictions. Line 15 says confirm before
every refund, line 17 says process every eligible refund immediately.
Line 19 asks for a complete recap *and* a three-sentence maximum.
3. The reasoning scaffold and the 6-step script fight the model rather than
steer it. + "reason step by step" is now a request
parameter, not prose; the mandatory 6-step procedure plus "investigate
fully even when the ticket looks simple" forces four tool calls on a
"where's my package" ticket.
...
-After any refund or escalation, verify twice before submitting: re-fetch
-the order, re-check every figure in your reply against the fresh lookup,
-and review the reply a second time for errors.
+Before submitting a refund or an escalation, re-fetch the order and confirm
+every figure in your reply matches the fresh lookup.
```
Der Befehl schlägt seine Änderungen dann als Diff vor (ein Hunk gezeigt) und listet auf, was er bewusst unverändert gelassen hat: das Rückerstattungsfenster, die Tonalitätsanforderung und die Qualitätsmesslatte. Du prüfst einen Patch, keine Neufassung.
Anthropic hat den Effekt an einer Support-Desk-Evaluierung[14](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) über zwei Migrationen zwischen früheren Modellen gemessen:
* Von Claude Opus 4.8 zu Claude Opus 5 kosteten für das ältere Modell geschriebene Prompts beim neueren Modell mehr pro Ticket, ohne Änderung der Genauigkeit.
* Das Audit über dieselben Prompts machte Claude Opus 5 sowohl günstiger als die ungeprüfte Version als auch genauer, ein Gewinn außerhalb des Rauschens.
* Von Claude Sonnet 4.6 zu Claude Sonnet 5 senkte das Audit die Kosten pro Ticket bei gleicher Genauigkeit.
Die beiden Arten veralteten Texts haben unterschiedliche Kosten:
* Anweisungen, die das neue Modell zu wörtlich befolgt, kosten Geld: Das Entfernen von „zweimal überprüfen“ senkte die Kosten pro Ticket bei Claude Opus 5, und das Entfernen von „maximal gründlich sein“ senkte sie fast ebenso stark.
* Text, der nicht mehr zum Modell passt, kostet stattdessen Genauigkeit: Eine eingestellte Einstellung für das Nachdenken, widersprüchliche Regeln und ein selbst gebautes Scratchpad, das mit dem eigenen Nachdenken des Modells kollidiert, stellten bei ihrer Entfernung jeweils die Genauigkeit bei Claude Opus 5 wieder her.
Dieselben Muster tauchen oft in Tool-Beschreibungen und Skills auf, die ebenfalls ein Audit wert sind.
## Kosten gegen Intelligenz abwägen
Diese Hebel legen fest, wo ein einzelnes Modell zwischen Kosten und Intelligenz steht: Modellwahl, Effort, das Wiederholen von Fehlschlägen mit einer höheren Einstellung, die Budgets und Obergrenzen, innerhalb derer es arbeitet, und ob es sehen kann, wie viel Zeit vergangen ist. Beginne mit einem Effort-Sweep auf deinem aktuellen Modell ([Effort abstimmen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort)). Von den niedrigsten zu den höchsten Kosten und Fähigkeiten sind die aktuellen Modelle Claude Haiku 5.5, Claude Sonnet 5.5, Claude Opus 5.5 und Claude Fable 5.1 (das Frontier-Modell); die [Modellübersicht](https://platform.claude.com/docs/de/models/overview) enthält das vollständige Angebot und die Preise.
### Modelle nach Kosten pro Aufgabe vergleichen
Vergleiche Modelle nach den Kosten pro abgeschlossener Aufgabe, nicht pro Token, denn du bezahlst für abgeschlossene Aufgaben. Beginne bei den meisten Agent-Workloads mit Claude Opus 5.5 bei seinem Standard-Effort (`medium`).
Ein leistungsfähigeres Modell kann eine Aufgabe mit weniger Arbeit erledigen, was einen Großteil des Aufpreises pro Token ausgleichen kann. Anthropic hat dies auf der Teilmenge von SWE-bench Pro[3](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) gemessen, deren Ergebnisse nicht mit dem öffentlichen Leaderboard vergleichbar sind, und zwar zu den Preisen, die einem Kunden in Rechnung gestellt werden:
Die folgende Tabelle listet die Ergebnisse auf:
| Benchmark | Modell | Effort | Ergebnis | Kosten |
| ----------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------------- | --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| SWE-bench Pro[3](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs)-Teilmenge | Claude Sonnet 5.5 | `high` (Standard) | 87,6 % der Aufgaben gelöst | 0,11 $ pro gelöster Aufgabe |
| SWE-bench Pro-Teilmenge | Claude Opus 5.5 | `low` | 87,4 % der Aufgaben gelöst | 0,12 $ pro gelöster Aufgabe |
| SWE-bench Pro-Teilmenge | Claude Opus 5.5 | `medium` (Standard) | 92,8 % der Aufgaben gelöst | 0,22 $ pro gelöster Aufgabe |
| SWE-bench Pro-Teilmenge | Claude Fable 5.1 | `high` (Standard) | 92,3 % der Aufgaben gelöst (ein einzelner Durchlauf) | 1,19 $ pro gelöster Aufgabe |
| Interner Agentic-Coding-Benchmark[11](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Opus 5.5 | `medium` (Standard) | 86,6 % | 0,84 $ pro Versuch |
| Interner Agentic-Coding-Benchmark | Claude Fable 5.1 | `medium` | 84,2 % (ein einzelner Durchlauf) | 2,68 $ pro Versuch |
| GPQA Diamond[9](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Haiku 5.5 | `medium` (Standard) | 85 % Genauigkeit, verglichen mit jeweils 91 % für Claude Opus 5.5 und Claude Sonnet 5.5 | Etwa ein Zwanzigstel der Kosten von Claude Opus 5.5 pro richtiger Antwort und etwa ein Zehntel der Kosten von Claude Sonnet 5.5 |
| Claude Managed Agents-Aufgabenset[25](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs), 79 Aufgaben | Claude Haiku 5.5 | `medium` | 93 % der Versuche bestanden (ein einzelner Durchlauf) | Etwa 0,011 $ pro bestandenem Versuch |
**Was du tun solltest.**
* Beginne mit Claude Opus 5.5 bei seinem Standard-Effort: Auf der SWE-bench Pro-Teilmenge erreichte es Claude Fable 5.1 bei dessen Standard, innerhalb des Rauschens zwischen Durchläufen, für etwa ein Fünftel der Kosten pro gelöster Aufgabe. Opus 5.5 und Fable 5.1 sättigen die SWE-bench Pro-Teilmenge beide weitgehend. Verwende Claude Fable 5.1 für anspruchsvolles Reasoning und agentische Arbeit mit langem Horizont oder wenn deine Evals mit Claude Opus 5.5 bei höherem Effort immer noch nicht ausreichen.
* Am anderen Ende eignet sich Claude Haiku 5.5 für Arbeit mit hohem Volumen und latenzkritische Arbeit mit überprüfbaren Ausgaben.
* Bepreise jeden Kandidaten in Kosten pro abgeschlossener Aufgabe auf deinem eigenen Traffic, einschließlich Claude Opus 5.5 bei seinem Standard-Effort und des Frontier-Modells bei reduziertem Effort. Jeder Token-Preis von Claude Opus 5.5, einschließlich Cache-Lesevorgängen, ist doppelt so hoch wie der von Claude Sonnet 5.5, aber auf der SWE-bench Pro-Teilmenge löste Opus 5.5 bei `low` etwa denselben Anteil an Aufgaben wie Sonnet 5.5 bei dessen Standard, innerhalb des Rauschens zwischen Durchläufen, für etwa 7 % mehr pro gelöster Aufgabe.
* Die Rangfolge kehrt sich je nach Workload um, und keine Preisliste sagt dir, in welche Richtung, also miss sie auf deinem eigenen Workload. Bei langen Recherche-Schleifen kann Claude Fable 5.1 mehr Arbeit leisten, nicht weniger, und daher mehr pro Aufgabe kosten (DeepResearch Bench II[7](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs)).
* Bepreise das Ende der Verteilung deines Workloads, nicht den Median: Vergleiche Modelle auf dem schwierigsten Zehntel deiner Aufgaben, nicht auf der typischen Aufgabe.
Die Rechnung wird von den Aufgaben bestimmt, an denen das günstigere Modell scheitert, denn eine gescheiterte Aufgabe berechnet trotzdem ihre Token, dann den erneuten Versuch und dann alles, was der Fehler nachgelagert kostet. Am Ende der Verteilung fließt das Geld auch dann hin, wenn nichts scheitert. Bei einem WideSearch[1](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs)-Durchlauf mit 20 Problemen entfielen 43 % der Ausgaben auf zwei Probleme:
Die [Multi-Modell-Strategien](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#combine-models) existieren, um Frontier-Intelligenz für dieses Ende der Verteilung einzusetzen, ohne für den Rest Frontier-Preise zu zahlen.
### Modell upgraden
Wenn du ein oder zwei Modelle zurückliegst, ist der günstigste Hebel der Modell-String. In Anthropics Messungen löste jedes neuere Modell mindestens so viele Aufgaben wie sein Vorgänger, meist zu geringeren Kosten pro gelöster Aufgabe. Das Diagramm zeigt aktuelle Claude-Modelle auf der SWE-bench Pro[3](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs)-Teilmenge, bei der jedes Modell mit demselben Testaufbau lief, und auf Terminal-Bench 3[20](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs); die Tabelle listet auf, was jedes Upgrade verändert hat:
| Benchmark | Upgrade | Effort | Ergebnis | Kosten |
| ---------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------- | ------------------------------------------------- | --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| SWE-bench Pro[3](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs)-Teilmenge | Claude Sonnet 4.6 auf Claude Sonnet 5 | Standard | 5 Punkte mehr | 16 % weniger pro gelöster Aufgabe |
| SWE-bench Pro-Teilmenge | Claude Sonnet 5 auf Claude Sonnet 5.5 | Standard | Etwa 10 Punkte mehr | 87 % weniger pro gelöster Aufgabe; 85 % weniger zu den Preisen von Claude Sonnet 5 |
| SWE-bench Pro-Teilmenge | Claude Opus 5 auf Claude Opus 5.5 | Standard: `high` auf `medium` | Etwa gleich: 91,9 % auf 92,8 % der Aufgaben gelöst | 78 % weniger pro gelöster Aufgabe; etwa 69 % weniger zu den Preisen von Claude Opus 5 |
| SWE-bench Pro-Teilmenge | Claude Fable 5 auf Claude Fable 5.1 | Standard | Etwa gleiches Ergebnis | 43 % weniger pro gelöster Aufgabe |
| DeepResearch Bench II[7](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Fable 5 auf Claude Fable 5.1 | `high` | 2 bis 3 Punkte mehr bei den 21 Aufgaben, bei denen kein Versuch abgebrochen wurde | 46 % mehr pro Aufgabe über alle 50 Aufgaben |
| DeepResearch Bench II | Claude Fable 5 auf Claude Fable 5.1 | `low` | 2 bis 3 Punkte mehr bei den 21 Aufgaben, bei denen kein Versuch abgebrochen wurde | 94 % mehr pro Aufgabe über alle 50 Aufgaben |
| Terminal-Bench 3[20](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Opus 4.7 auf Claude Opus 4.8 | `high` | Von 7 % auf 15 % der Aufgaben gelöst | Von 183 $ auf 63 $ pro gelöster Aufgabe |
| Terminal-Bench 3 | Claude Opus 4.8 auf Claude Opus 5 | `high` | Von 15 % auf 41 % der Aufgaben gelöst | Von 63 $ auf 28 $ pro gelöster Aufgabe, eine Ersparnis von 56 % |
| Claude Managed Agents-Aufgabenset[25](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Haiku 4.5 auf Claude Haiku 5.5 | Wie bereitgestellt; `medium` bei Claude Haiku 5.5 | Von 62 % auf 93 % der Versuche bestanden, ein Durchlauf pro Modell | Von 0,041 $ auf etwa 0,010 $ an Token-Kosten pro Versuch; etwa 84 % weniger pro bestandenem Versuch |
**Wann es sich lohnt.**
* Wo ältere Modelle bereits die meisten Aufgaben lösen, bestimmen die Kosten jedes Versuchs die Ersparnis: Auf der SWE-bench Pro-Teilmenge erzielt Claude Opus 5.5 etwa dasselbe Ergebnis wie Claude Opus 5 für 78 % weniger pro gelöster Aufgabe.
* Wo ältere Modelle meist scheitern, bestimmt die Erfolgsquote die Ersparnis: Auf Terminal-Bench 3[20](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) erhöht das Upgrade von Claude Opus 4.8 auf Claude Opus 5 die gelösten Aufgaben von 15 % auf 41 % und kostet 56 % weniger pro gelöster Aufgabe.
* Miss das Upgrade auf deinem eigenen Workload, bevor du annimmst, dass es Geld spart. Die Ersparnis ist nicht garantiert: Auf DeepResearch Bench II[7](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) kostet Claude Fable 5.1 mehr pro Aufgabe als Claude Fable 5, weil das neue Modell dort mehr Arbeit pro Aufgabe leistet, obwohl die Eingabe- und Ausgabepreise gleich sind und der Cache-Lesevorgang 4-mal günstiger ist.
* Vergleiche nach Kosten pro gelöster Aufgabe, nicht pro Token: Derselbe Text kostet bei Claude 4.7 und späteren Modellen etwa 30 % mehr Token, sodass ein Vergleich pro Token die neueren Modelle konstruktionsbedingt teurer erscheinen lässt.
### Effort abstimmen
Teste verschiedene Effort-Stufen auf deinem eigenen Workload, bevor du ein zweites Modell hinzufügst. Niedrigerer Effort kostet weniger und ist oft schneller, und wie viel Genauigkeit er kostet, hängt von der Aufgabe ab: Beim Coding mit langem Horizont brachte Effort Genauigkeit, und bei Recherche-Aufgaben brachte er in einer Messung viel und in einer anderen nichts. Der Parameter [`effort`](https://platform.claude.com/docs/de/build-with-claude/effort) steuert, wie viel Nachdenken, Tool-Aufrufe und Selbstüberprüfung das Modell durchführt; `high` ist bei den meisten Modellen der Standard, und `medium` bei Claude Opus 5.5 und Claude Haiku 5.5.
Die folgende Tabelle listet Anthropics Messungen auf zwei Benchmarks mit aktuellen Modellen auf; Ergebnisse und Kosten sind zwischen den beiden Benchmarks nicht vergleichbar. Die Kosten gelten pro Aufgabe, nicht pro gelöster Aufgabe wie in [Modelle nach Kosten pro Aufgabe vergleichen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task). Jedes Ergebnis fasst zwei Durchläufe auf SWE-bench Pro und drei auf DeepResearch Bench II zusammen, sofern die jeweilige Zelle nichts anderes angibt:
| Benchmark | Modell | Effort | Ergebnis | Kosten pro Aufgabe |
| ----------------------------------------------------------------------------------------------------------------------------- | ---------------- | ------------------- | ---------------------------------------------------- | ------------------ |
| SWE-bench Pro[3](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs)-Teilmenge | Claude Opus 5.5 | `low` | 87,4 % der Aufgaben gelöst | 0,11 $ |
| SWE-bench Pro-Teilmenge | Claude Opus 5.5 | `medium` (Standard) | 92,8 % der Aufgaben gelöst | 0,21 $ |
| SWE-bench Pro-Teilmenge | Claude Opus 5.5 | `high` | 95,3 % der Aufgaben gelöst | 0,29 $ |
| SWE-bench Pro-Teilmenge | Claude Opus 5.5 | `xhigh` | 96,7 % der Aufgaben gelöst (ein einzelner Durchlauf) | 0,74 $ |
| DeepResearch Bench II[7](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Fable 5.1 | `low` | Rubrik-Ergebnis 66 % | 4,48 $ |
| DeepResearch Bench II | Claude Fable 5.1 | `high` (Standard) | Rubrik-Ergebnis 65 % | 6,89 $ |
Das folgende Diagramm zeigt die Genauigkeit im Verhältnis zu den Kosten pro Aufgabe für Claude Opus 5.5 auf der SWE-bench Pro[3](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs)-Teilmenge:
Das folgende Diagramm zeigt das Rubrik-Ergebnis im Verhältnis zu den Kosten pro Aufgabe für Claude Fable 5.1 auf DeepResearch Bench II[7](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs):
**Was du tun solltest.**
* Teste zwei oder drei Effort-Stufen an einer Stichprobe deines eigenen Traffics, jeweils in einer separaten Sitzung: Das Ändern des Effort auf oberster Ebene mitten in einer Sitzung [macht den Cache ungültig](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context) und verzerrt den Vergleich. Die Kurve ist die Baseline, die jede Multi-Modell-Strategie übertreffen muss ([Schritt 2 der Messung auf deinem eigenen Workload](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#measure-on-your-own-workload)).
* Beim Coding mit langem Horizont ist Effort ein echter Zielkonflikt, den das [erneute Ausführen von Fehlschlägen mit höherem Effort](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#re-run-failures-at-higher-effort) wieder in eine Ersparnis verwandelt. Bei `medium` erzielte Claude Sonnet 5.5 auf der SWE-bench Pro[3](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs)-Teilmenge etwa 7 Punkte weniger als bei seinem Standard, `high`, für etwa 59 % der Kosten pro Aufgabe (jeweils 2 Durchläufe), und erzielte auf dem internen Agentic-Coding-Benchmark[11](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) 62,7 % im Vergleich zu 77,8 % (1 Versuch pro Aufgabe).
* Miss bei Recherche-Aufgaben das Modell, das du auslieferst. Claude Fable 5.1 erzielte auf DeepResearch Bench II von `low` bis `high` nahezu dasselbe Ergebnis; Claude Opus 5.5 erzielte auf DRACO[21](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) bei `low` 13,3 Punkte weniger als bei `medium`. Die beiden Ergebnisse stammen von verschiedenen Modellen auf verschiedenen Benchmarks, sie zeigen also, dass die Antwort variiert, nicht warum.
* Bei `low` benötigte die typische Aufgabe von Claude Opus 5.5 auf DRACO[21](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) 84 % weniger Zeit als bei `medium`, auf HLE[22](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) 30 % weniger und auf einem internen Satz von Physikproblemen[23](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) 47 % weniger, und das Ergebnis lag um 13,3, 3,4 bzw. 14,0 Punkte niedriger (3, 3 bzw. 4 Versuche pro Aufgabe).
* Auf einem internen Benchmark zur Fehlersuche für Arbeit, die größer als ein Kontextfenster ist[8](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs), benötigte Claude Fable 5.1 bei `low`, `medium` und `high` 15,2, 17,5 bzw. 19,9 Stunden pro Durchlauf (jeweils 3 Durchläufe). Um Zeit zu sparen, vergleiche niedrigeren Effort auch mit den beiden Änderungen in [Dem Modell die verstrichene Zeit zeigen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time): `low`-Effort sparte mehr Zeit, und die Änderungen bewahrten mehr vom Ergebnis.
### Fehlschläge mit höherem Effort erneut ausführen
Wenn das Ergebnis einer Aufgabe überprüfbar ist, ist die günstigste Strategie auf der Effort-Kurve keine feste Einstellung: Führe jede Aufgabe mit einer niedrigen Einstellung aus und führe nur die Fehlschläge mit einer höheren erneut aus.
Anthropic hat diese Strategie Aufgabe für Aufgabe aus den Effort-Durchläufen von Claude Opus 5.5 auf der SWE-bench Pro[3](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs)-Teilmenge in [Effort abstimmen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort) berechnet:
In der folgenden Tabelle berücksichtigen die Kosten der erneuten Ausführung die fehlgeschlagenen günstigen Versuche:
| Strategie | Gelöste Aufgaben | Kosten pro Aufgabe |
| ---------------------------------------------------- | ---------------- | ------------------ |
| `low`, fehlgeschlagene Aufgaben erneut bei `high` | Etwa 97 % | Etwa 0,17 $ |
| `medium`, fehlgeschlagene Aufgaben erneut bei `high` | Etwa 97 % | Etwa 0,24 $ |
| Alles bei `high` | 95,3 % | 0,29 $ |
* Bei `low` schlugen 13 % der Aufgaben fehl. Wurden diese bei `high` erneut ausgeführt, war die Erfolgsquote etwas höher als mit allem bei `high`, für etwas mehr als die Hälfte der Kosten.
* Verwende diese Strategie wegen der Ersparnis, nicht wegen der Verbesserung. Der Großteil der kleinen Verbesserung stammt vom zweiten Versuch: Die fehlgeschlagenen Aufgaben eines `high`-Durchlaufs erneut bei `high` auszuführen, erzielt etwa dasselbe Ergebnis, für mehr Geld.
Es gelten zwei Bedingungen. Erstens brauchst du ein Fehlersignal (hier die eigenen Tests des Benchmarks); ein Prüfer, der schlechte Arbeit durchlässt, lässt diese Fehlschläge durch. Zweitens benötigt jeder Fehlschlag im ersten Durchlauf die Echtzeit von zwei Durchläufen, sodass die Einsparung bei den Fehlschlägen mit Latenz bezahlt wird.
### Budgets und Ausgabelimits festlegen
Zwei Steuerungen erfüllen zwei verschiedene Aufgaben: Ein Sitzungsbudget begrenzt, was eine Claude Managed Agents-Sitzung ausgeben kann, und `max_tokens` begrenzt die Länge einer Antwort. Setze jede dort ein, wo sie greift, mit einem [Ausgabenlimit für den Workspace](https://platform.claude.com/docs/de/api/rate-limits#setting-lower-limits-for-workspaces) als letzter Absicherung.
* **Sitzungsbudgets bei Claude Managed Agents** sind ein harter Stopp für Ausgaben. Ein [Sitzungsbudget](https://platform.claude.com/docs/de/managed-agents/budgets) ist eine Dollar-Obergrenze für die [Listenkosten](https://platform.claude.com/docs/de/managed-agents/budgets#how-list-cost-is-measured) einer Sitzung, die die Plattform für Token, Websuchen und Laufzeit der Sitzung misst.
* Bei Erreichen der Obergrenze oder kurz danach pausiert die Sitzung mit `stop_reason: budget_reached`; das Erhöhen des Budgets setzt sie fort. Dies wird von der Plattform durchgesetzt und funktioniert mit jedem Modell, das einen Listenpreis hat. Deployments wenden dasselbe Budget auf jede Sitzung an, die sie starten.
* **`max_tokens`** begrenzt eine einzelne Antwort, für das Modell unsichtbar, sodass ein niedrigerer Wert das Modell nicht sparsamer macht. Die Turns, die den Platz benötigt hätten, werden verworfen und trotzdem berechnet. Begrenzte Versuche erneut auszuführen hilft selten: Bei derselben Obergrenze scheitern die meisten erneut, und bei einer höheren zahlst du zusätzlich für den verschwendeten Versuch.
* Setze `max_tokens` für agentische Arbeit auf 64.000 oder auf 128.000, das Maximum, wenn ein einzelner abgebrochener Versuch teuer ist. [Streame Antworten](https://platform.claude.com/docs/de/build-with-claude/streaming) dieser Größe, behandle [`stop_reason: max_tokens`](https://platform.claude.com/docs/de/build-with-claude/handling-stop-reasons#max-tokens) als Fehler und spare Geld mit Effort, den das Modell sehen kann.
Die folgende Tabelle zeigt, was jedes Modell bei jeder Obergrenze auf einem internen Repository-Aufgaben-Benchmark[12](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) gelöst hat und was eine gelöste Aufgabe gekostet hat, ein Versuch pro Aufgabe, jedes Modell bei seinem Standard-Effort. Die Zeilen bei 16.384 sind der Durchschnitt aus zwei Durchläufen, die anderen Zeilen jeweils ein Durchlauf:
| Modell | `max_tokens` | Durch die Obergrenze beendete Versuche | Gelöste Aufgaben | Kosten pro gelöster Aufgabe |
| ---------------- | ------------ | -------------------------------------- | ---------------- | --------------------------- |
| Claude Opus 5.5 | 16.384 | 25 % | 57,6 % | 5,38 $ zu Listenpreisen |
| Claude Opus 5.5 | 64.000 | 0 % | 75,6 % | 5,38 $ zu Listenpreisen |
| Claude Opus 5.5 | 128.000 | 0 % | 68,9 % | 5,94 $ zu Listenpreisen |
| Claude Fable 5.1 | 16.384 | 43 % | 36,3 % | 21,37 $ wie abgerechnet |
| Claude Fable 5.1 | 64.000 | 0 % | 58,5 % | 21,53 $ wie abgerechnet |
| Claude Fable 5.1 | 128.000 | 1 % | 60,0 % | 21,74 $ wie abgerechnet |
**Claude Opus 5.5 bei 64.000 und 128.000:** Bei keiner der beiden Obergrenzen wurde ein Versuch abgebrochen, daher erklärt die Obergrenze nicht, warum sich diese beiden Zeilen bei den gelösten Aufgaben oder den Kosten pro gelöster Aufgabe unterscheiden. Jede Zeile ist ein Durchlauf.
Vergleiche die Obergrenzen innerhalb jedes Modells. Die beiden Modelle wurden im Abstand von einem Monat ausgeführt, und ihre Kosten sind auf unterschiedlichen Grundlagen bepreist.
Bitte um kürzere Antworten. Ausgabe-Token kosten bei Claude Haiku 5.5, Claude Sonnet 5.5, Claude Opus 5.5 und Claude Fable 5.1 das Fünffache von Eingabe-Token, und in einer Agent-Schleife kommt jedes Token, das das Modell schreibt, in jedem späteren Turn als Eingabe zurück, sodass du für eine lange Antwort immer wieder bezahlst.
In einer Messung mit einem früheren Modell[26](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) ließ Anthropic einen kleinen Agenten, der Fehlerberichte sichtet ([Input- und Kontext-Token kürzen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens)), unter drei Anweisungen für die endgültige Antwort laufen, jeweils drei Durchläufe, mit demselben Modell und denselben Tools:
* Das Original verlangte zwei Zeilen.
* Die kürzere Variante verlangte eine.
* Die längere Variante verlangte ein Memo mit sechs Abschnitten mit Überschriften.
Das folgende Diagramm zeigt die Kosten pro Durchlauf für jedes Format:
Alle drei lagen gegenüber den korrekten Labels innerhalb des Rauschens zwischen Durchläufen, sodass sich die Formate weit mehr darin unterscheiden, was du bezahlst, als darin, was sie richtig machen. Bitte um die Antwort, die du lesen wirst, nicht um die, die gründlich aussieht.
Bei den internen Repository-Aufgaben[12](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) endet fast jeder Turn weit unterhalb einer Obergrenze von 16.384 Token. Der seltene lange Turn ist das, was eine höhere Obergrenze erkauft:
### Dem Modell die verstrichene Zeit zeigen
Damit ein Agent schneller fertig wird und weniger kostet, sag ihm, dass Zeit wichtig ist, und zeige ihm bei jeder Anfrage die verstrichene Zeit. In Anthropics Messung verkürzten die beiden Änderungen die Zeit eines einzelnen Claude Opus 5.5-Agenten bei `medium`-Effort um 47 % und seine Kosten um 60 % bei der typischen (Median-)Recherche-Aufgabe von DRACO[21](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs), und sein durchschnittliches Ergebnis lag 4,1 Punkte niedriger.
Auf HLE[22](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) und einem internen Physik-Satz[23](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) benötigte die typische Aufgabe 14 % bzw. 7 % weniger Zeit, und das Physik-Ergebnis lag 3,0 Punkte niedriger. Das Senken des Effort auf `low` sparte mehr Zeit und Kosten als die Änderungen und kostete mehr Punkte (Referenz 21). Überprüfe das Ergebnis auf deinen eigenen Aufgaben, bevor du die Änderungen übernimmst.
Funktionierenden Code findest du im Claude Cookbook-Rezept [Multi-agent teams under latency pressure and budgets](https://github.com/anthropics/claude-cookbooks/blob/main/patterns/agents/latency_multi_agent.ipynb), das beide Änderungen auf ein Team von Agenten anwendet. Wenn du stattdessen im System-Prompt angeben möchtest, dass Zeit wichtig ist, siehe [Zeitsignale für Multiagenten-Harnesses](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#time-signals-for-multi-agent-harnesses).
Das folgende Diagramm zeigt außerdem ein Team, dessen leitender Agent selten Helfer startete, und einen einzelnen Agenten bei `low`-Effort:
## Modelle kombinieren
Stimme ein Modell ab, bevor du ein zweites hinzufügst: Teste zuerst verschiedene Effort-Stufen auf deinem aktuellen Modell, denn die meisten Workloads enden dort, und wenn der Test eine Lücke zeigt, bepreise das stärkere Modell allein bei niedrigem Effort. Baue eine Paarung nur, wenn sie die gesamte Kurve des Einzelmodells aus Ergebnis und Ausgaben übertrifft. Die Multi-Modell-Ergebnisse auf dieser Seite wurden mit demselben Modell bei niedrigerem Effort und mit dem nächstkleineren Modell allein verglichen, und genau diesen Vergleich solltest du auf deinem eigenen Workload durchführen.
Die folgende Tabelle vergleicht die beiden Strategien:
| Strategie | Kontrollfluss | Rolle des Frontier-Modells | Passt zu | Frontier-Kosten skalieren mit |
| ---------------- | ------------------------------------------------------------------ | ------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- |
| **Advisor** | Kleineres Modell führt die Schleife aus, eskaliert bei Bedarf | Wird für Pläne und Korrekturen konsultiert | Serielle Arbeit, die stellenweise schwer ist, etwa die vielen Turns eines Coding-Agenten zwischen wenigen echten Entscheidungen | Wie oft der Executor stecken bleibt |
| **Orchestrator** | Frontier-Modell führt die Schleife aus, delegiert die Massenarbeit | Plant, verteilt und synthetisiert | Arbeit, die sich über wirklich unabhängige Dateien, Dokumente oder Fälle auffächert, besonders mehr als ein Kontextfenster davon | Wie schwer die Teile zu koordinieren sind |
### Advisor-Strategie: schwierige Entscheidungen eskalieren
Ein Advisor kann nur helfen, wenn der Executor ihn konsultiert.
In Anthropics Messungen mit aktuellen Modellen erzielte die einzige Paarung, deren Executor häufig konsultierte, auf einem Coding-Benchmark 1,7 Punkte mehr als der Executor allein bei gleichem Effort, am Rand des Rauschens zwischen Durchläufen, für etwa das 2,1-Fache der Kosten. Wo der Executor selten oder nie konsultierte, lag die Paarung innerhalb des Rauschens zwischen Durchläufen des Executors allein oder darunter.
Um sie zu aktivieren, füge deiner Anfrage das [Advisor-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool) hinzu, eine Beta-Funktion. Bei Claude Managed Agents [gibst du der Session einen Advisor](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration#give-the-session-an-advisor). Für Claude Code siehe [Schwierige Entscheidungen mit dem Advisor-Tool eskalieren](https://code.claude.com/docs/de/advisor).
Die folgende Tabelle vergleicht jede Paarung mit ihrem Executor allein bei gleichem Effort:
| Benchmark | Ergebnis | Kosten | Advisor konsultiert |
| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| Interner Agentic-Coding-Benchmark[11](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) | 90,1 %, 1,7 Punkte über dem Executor allein, am Rand des Rauschens zwischen Durchläufen | 2,92 $ pro Versuch, etwa das 2,1-Fache des Executors allein | Etwa 1,4-mal pro Versuch; 4 % der Versuche erhielten keinen Rat |
| GPQA Diamond[9](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Innerhalb des Rauschens zwischen Durchläufen des Executors allein | 12 % mehr pro Frage für Claude Haiku 5.5, 25 % mehr für Claude Sonnet 5.5 | Bei keiner der 198 Fragen, in jeweils zwei Durchläufen; kein System-Prompt forderte Konsultationen an |
| Chartography[13](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) | 61,7, 7 Punkte unter dem Executor allein und jenseits des Rauschens zwischen Durchläufen | Etwa gleich wie der Executor allein | Bei 1 von 300 Aufgaben |
* **Interner Agentic-Coding-Benchmark.** Claude Opus 5.5 bei `high`, mit einem Claude Fable 5.1-Advisor.
* **GPQA Diamond.** Claude Haiku 5.5 oder Claude Sonnet 5.5 beim jeweiligen Standard des Modells (`medium` und `high`), mit einem Claude Opus 5.5-Advisor.
* **Chartography.** Claude Opus 5.5 bei `low`, mit einem Claude Fable 5.1-Advisor.
Der Advisor kann nur Fähigkeiten weitergeben, die dem Executor fehlen: Auf GPQA Diamond lag Claude Sonnet 5.5 allein mit Claude Opus 5.5 allein bei 91 % gleichauf, wobei Verweigerungen als falsch gezählt wurden, aber nur, weil Opus 5.5 pro Durchlauf sechs Biologiefragen verweigerte, verglichen mit einer bei Sonnet 5.5. Bei den Fragen, die jedes Modell beantwortete, lag Opus 5.5 um etwa 2 Punkte vorn.
Auf dem Coding-Benchmark liegt der Gewinn der Paarung am Rand des Rauschens zwischen Durchläufen, und sie landet etwa auf der eigenen Effort-Kurve von Claude Opus 5.5, sodass der Advisor etwa das erkaufte, was mehr Effort bewirkt. Das folgende Diagramm zeigt die Paarung im Vergleich zu dieser Kurve und der von Claude Fable 5.1 aus dem August:
**Was du tun solltest.**
* Miss die Konsultationsrate auf deinen eigenen Aufgaben. Die Definition des Advisor-Tools, etwa 1.000 Prompt-Token pro Anfrage, verursacht Kosten, auch wenn der Executor nie konsultiert. Mit [Prompt-Caching](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context) zahlt eine Agent-Schleife mit mehreren Turns nach der ersten Anfrage den Cache-Lesepreis für die Definition, sodass dieser Overhead vor allem bei kurzen Aufgaben mit einer einzigen Anfrage ins Gewicht fällt.
* Wenn der Executor selten konsultiert, siehe [Prompting für Coding- und Agent-Aufgaben](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#prompting-for-coding-and-agent-tasks) für System-Prompts, die Konsultationen anfordern, und miss erneut, nachdem du einen hinzugefügt hast. Bei 20 SWE-bench Pro[3](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs)-Problemen machte der vorgeschlagene Prompt für Claude Sonnet 5.5 keinen klaren Unterschied.
* Stelle den Effort des Executors wieder her, wenn die Konsultationsrate einbricht. In Messungen mit früheren Modellen konsultierte eine Paarung, die beim Standard-Effort bei den meisten Aufgaben konsultierte, bei gesenktem Effort nur bei wenigen und erzielte dann ein schlechteres Ergebnis als der Executor allein (SWE-bench Pro[3](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs)).
* Überprüfe dies bei jedem Modell-Release erneut, denn Releases verschieben sowohl die Fähigkeitslücke als auch das Preisverhältnis.
### Orchestrator-Strategie: Massenarbeit delegieren
Delegation sparte in Messungen mit Workern auf Claude Sonnet 5, einem früheren Modell, nur in zwei Situationen Geld:
* Routinearbeit mit einem langen Kostenausläufer (ein einfacher Ausschnitt von BrowseComp[4](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs))
* Arbeit, die größer als ein Kontextfenster ist (ein interner Benchmark zur Fehlersuche[8](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs))
Wenn die Arbeit eine einzige abhängige Kette ist oder ohne langen Kostenausläufer in einen einzigen Kontext passt, schnitt das Modell des Orchestrators allein bei niedrigerem Effort in jedem gemessenen Fall besser ab, auch bei früheren Modellen (das schwierigere BrowseComp-Set und DeepWideSearch[6](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs)); unabhängige externe Arbeiten berichten dasselbe Muster[5](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs).
Um einen Orchestrator zu bauen, verwende [Multiagenten-Orchestrierung](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration) in Claude Managed Agents: Konfiguriere einen Orchestrator-Agenten und Worker-Agenten, die er aufrufen kann, jeweils mit einem eigenen Modell.
Die [Modellauswahlmatrix](https://platform.claude.com/docs/de/about-claude/models/choosing-a-model#model-selection-matrix) führt Claude Haiku 5.5 für Sub-Agent-Aufgaben auf; bevor du es als Worker verwendest, [miss es auf deinem eigenen Workload](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#measure-on-your-own-workload).
Das folgende Diagramm zeigt die Konfigurationen des Fehlersuche-Benchmarks nach Kosten und Ergebnis:
**Was du tun solltest.**
* **Routinearbeit mit einem langen Kostenausläufer:** Miss diesen Fall zuerst, sowohl auf Genauigkeit als auch auf Kosten. Die zugrunde liegende Messung umfasst nur Probleme, die die delegierte Konfiguration in jedem Durchlauf korrekt beantwortet hat (Referenz 4).
* **Arbeit, die größer als ein Kontextfenster ist:** Delegiere Partitionen an Worker. Ein niedrigerer Effort kann nicht helfen, weil die Rechnung das Lesen selbst ist: Auf dem Fehlersuche-Benchmark[8](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) kostete Claude Fable 5.1 allein über seine drei Effort-Einstellungen hinweg 468 $ bis 552 $ pro Durchlauf und benötigte 15 bis 20 Stunden. Mit Workern auf früheren Modellen kostete die Delegation weniger und war schneller fertig, bei einem niedrigeren Ergebnis.
## Auf deinem eigenen Workload messen
Miss auf deinem eigenen Workload: Die Zahlen auf dieser Seite spiegeln die Listenpreise zum Zeitpunkt der Messung wider und werden sich verschieben, wenn sich Modelle und Preise ändern. Auch deine „escalation rate“ (Eskalationsrate), wie sauber sich Aufgaben aufteilen lassen, und die Länge der Transkripte beeinflussen sie. Die Methode bleibt dieselbe:
1. Ziehe einige Aufgaben aus den Produktionslogs, gewichtet wie der echte Traffic, und [schreibe Ergebnisprüfungen](https://platform.claude.com/docs/de/test-and-evaluate/develop-tests) für jede: Tests bestehen, Ticket geschlossen, Zeilenanzahl korrekt. Erfasse die Kosten pro Aufgabe neben der Punktzahl.
2. Erstelle Baselines für die Modellstufen über alle Effort-Stufen hinweg, nicht nur für die Standardeinstellung, und trage die Punktzahl gegen die Ausgaben auf. Eine Multi-Modell-Konfiguration muss die gesamte Kurve des Einzelmodells schlagen.
3. Wenn die Kurve eine Lücke zeigt, die sich mit Effort nicht schließen lässt, füge die passende Multi-Modell-Strategie hinzu und führe die Suite erneut aus.
4. Betreibe den Gewinner vor der Umstellung im Schattenbetrieb auf einem Teil des Traffics und lass die Suite danach weiterlaufen.
**So berechnest du den Preis einer Aufgabe.** Das `usage` jeder Antwort enthält fünf bepreiste Token-Zählungen. Berechne jede zu ihrem eigenen Tarif: nicht gecachter Input, 5-Minuten- und 1-Stunden-Cache-Schreibvorgänge zum 1,25-Fachen bzw. 2-Fachen des Input-Preises, Cache-Lesevorgänge und Output. Summiere sie über die Anfragen der Aufgabe (die [Usage and Cost API](https://platform.claude.com/docs/de/manage-claude/usage-cost-api) meldet die Gesamtsumme). Bei Claude Haiku 5.5 berechnest du jede Anfrage zu den Tarifen für ihre Prompt-Länge, einschließlich Cache-Lese- und -Schreibvorgängen (siehe [Preise für langen Kontext](https://platform.claude.com/docs/de/about-claude/pricing#long-context-pricing)).
Das folgende Beispiel berechnet die Kosten einer Anfrage zu den Listenpreisen von Claude Opus 5.5. Ändere die drei Preise für ein anderes Modell:
```bash cURL
INPUT_PER_MTOK=4.00 # Claude Opus 5.5
CACHE_READ_PER_MTOK=0.20 # 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
OUTPUT_PER_MTOK=20.00
response=$(curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 1024,
"messages": [{"role": "user", "content": "Hello, Claude"}]
}')
cost=$(jq -r --argjson in_price "$INPUT_PER_MTOK" --argjson read_price "$CACHE_READ_PER_MTOK" --argjson out_price "$OUTPUT_PER_MTOK" '
.usage
| (.input_tokens * $in_price
+ (.cache_creation.ephemeral_1h_input_tokens // 0) * $in_price * 2.00 # 1-hour cache write
+ (.cache_creation.ephemeral_5m_input_tokens // 0) * $in_price * 1.25 # 5-minute cache write
+ (.cache_read_input_tokens // 0) * $read_price # cache read
+ .output_tokens * $out_price) / 1e6
' <<<"$response")
printf 'Request cost: $%.6f\n' "$cost"
```
```bash CLI
INPUT_PER_MTOK=4.00 # Claude Opus 5.5
CACHE_READ_PER_MTOK=0.20 # 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
OUTPUT_PER_MTOK=20.00
USAGE=$(ant messages create \
--model claude-opus-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello, Claude"}' \
--transform usage)
COST=$(jq -r --argjson in_price "$INPUT_PER_MTOK" --argjson read_price "$CACHE_READ_PER_MTOK" --argjson out_price "$OUTPUT_PER_MTOK" '
(.input_tokens * $in_price
+ (.cache_creation.ephemeral_1h_input_tokens // 0) * $in_price * 2.00 # 1-hour cache write
+ (.cache_creation.ephemeral_5m_input_tokens // 0) * $in_price * 1.25 # 5-minute cache write
+ (.cache_read_input_tokens // 0) * $read_price # cache read
+ .output_tokens * $out_price) / 1e6
' <<<"$USAGE")
printf 'Request cost: $%.6f\n' "$COST"
```
```python Python
INPUT_PER_MTOK = 4.00 # Claude Opus 5.5
# 0,05x des Input-Preises bei Claude Opus 5.5; der Multiplikator variiert je nach Modell
CACHE_READ_PER_MTOK = 0.20
OUTPUT_PER_MTOK = 20.00
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello, Claude"}],
)
usage = response.usage
cache_writes = usage.cache_creation
writes_1h = cache_writes.ephemeral_1h_input_tokens if cache_writes else 0
writes_5m = cache_writes.ephemeral_5m_input_tokens if cache_writes else 0
cost = (
usage.input_tokens * INPUT_PER_MTOK
# 1-Stunden-Cache-Writes kosten 2x den Input-Preis, 5-Minuten-Writes 1,25x; Reads den Cache-Read-Preis.
+ writes_1h * INPUT_PER_MTOK * 2.0
+ writes_5m * INPUT_PER_MTOK * 1.25
+ (usage.cache_read_input_tokens or 0) * CACHE_READ_PER_MTOK
+ usage.output_tokens * OUTPUT_PER_MTOK
) / 1_000_000
print(f"Request cost: ${cost:.6f}")
```
```typescript TypeScript
const INPUT_PER_MTOK = 4.0; // Claude Opus 5.5
const CACHE_READ_PER_MTOK = 0.2; // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
const OUTPUT_PER_MTOK = 20.0;
const client = new Anthropic();
const response = await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello, Claude" }]
});
const usage = response.usage;
const cost =
(usage.input_tokens * INPUT_PER_MTOK +
(usage.cache_creation?.ephemeral_1h_input_tokens ?? 0) * INPUT_PER_MTOK * 2 + // 1-hour cache write
(usage.cache_creation?.ephemeral_5m_input_tokens ?? 0) * INPUT_PER_MTOK * 1.25 + // 5-minute cache write
(usage.cache_read_input_tokens ?? 0) * CACHE_READ_PER_MTOK + // cache read
usage.output_tokens * OUTPUT_PER_MTOK) /
1_000_000;
console.log(`Request cost: $${cost.toFixed(6)}`);
```
```csharp C#
const double InputPerMtok = 4.00; // Claude Opus 5.5
const double CacheReadPerMtok = 0.20; // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
const double OutputPerMtok = 20.00;
AnthropicClient client = new();
var response = await client.Messages.Create(
new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 1024,
Messages = [new() { Role = Role.User, Content = "Hello, Claude" }],
}
);
var usage = response.Usage;
double cost =
(
usage.InputTokens * InputPerMtok
+ (usage.CacheCreation?.Ephemeral1hInputTokens ?? 0) * InputPerMtok * 2.00 // 1-hour cache write
+ (usage.CacheCreation?.Ephemeral5mInputTokens ?? 0) * InputPerMtok * 1.25 // 5-minute cache write
+ (usage.CacheReadInputTokens ?? 0) * CacheReadPerMtok // cache read
+ usage.OutputTokens * OutputPerMtok
) / 1_000_000;
Console.WriteLine($"Request cost: ${cost:F6}");
```
```go Go
const (
inputPerMTok = 4.00 // Claude Opus 5.5
cacheReadPerMTok = 0.20 // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
outputPerMTok = 20.00
)
// ...
client := anthropic.NewClient()
response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
},
})
if err != nil {
log.Fatal(err)
}
usage := response.Usage
cost := (float64(usage.InputTokens)*inputPerMTok +
float64(usage.CacheCreation.Ephemeral1hInputTokens)*inputPerMTok*2.00 + // 1-hour cache write
float64(usage.CacheCreation.Ephemeral5mInputTokens)*inputPerMTok*1.25 + // 5-minute cache write
float64(usage.CacheReadInputTokens)*cacheReadPerMTok + // cache read
float64(usage.OutputTokens)*outputPerMTok) / 1_000_000
fmt.Printf("Request cost: $%.6f\n", cost)
```
```java Java
static final double INPUT_PER_MTOK = 4.00; // Claude Opus 5.5
static final double CACHE_READ_PER_MTOK = 0.20; // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
static final double OUTPUT_PER_MTOK = 20.00;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
Message response = client.messages().create(MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(1024)
.addUserMessage("Hello, Claude")
.build());
Usage usage = response.usage();
long writes1h = usage.cacheCreation().map(CacheCreation::ephemeral1hInputTokens).orElse(0L);
long writes5m = usage.cacheCreation().map(CacheCreation::ephemeral5mInputTokens).orElse(0L);
double cost = (usage.inputTokens() * INPUT_PER_MTOK
+ writes1h * INPUT_PER_MTOK * 2.00 // 1-hour cache write
+ writes5m * INPUT_PER_MTOK * 1.25 // 5-minute cache write
+ usage.cacheReadInputTokens().orElse(0L) * CACHE_READ_PER_MTOK // cache read
+ usage.outputTokens() * OUTPUT_PER_MTOK) / 1_000_000;
IO.println("Request cost: $%.6f".formatted(cost));
}
```
```php PHP
const INPUT_PER_MTOK = 4.00; // Claude Opus 5.5
const CACHE_READ_PER_MTOK = 0.20; // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
const OUTPUT_PER_MTOK = 20.00;
$client = new Client();
$response = $client->messages->create(
model: 'claude-opus-5-5',
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello, Claude']],
);
$usage = $response->usage;
$cost = (
$usage->inputTokens * INPUT_PER_MTOK
+ ($usage->cacheCreation?->ephemeral1hInputTokens ?? 0) * INPUT_PER_MTOK * 2.00 // 1-hour cache write
+ ($usage->cacheCreation?->ephemeral5mInputTokens ?? 0) * INPUT_PER_MTOK * 1.25 // 5-minute cache write
+ ($usage->cacheReadInputTokens ?? 0) * CACHE_READ_PER_MTOK // cache read
+ $usage->outputTokens * OUTPUT_PER_MTOK
) / 1_000_000;
printf("Request cost: \$%.6f\n", $cost);
```
```ruby Ruby
INPUT_PER_MTOK = 4.00 # Claude Opus 5.5
CACHE_READ_PER_MTOK = 0.20 # 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
OUTPUT_PER_MTOK = 20.00
client = Anthropic::Client.new
response = client.messages.create(
model: "claude-opus-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello, Claude" }]
)
usage = response.usage
cost = (
usage.input_tokens * INPUT_PER_MTOK +
usage.cache_creation&.ephemeral_1h_input_tokens.to_i * INPUT_PER_MTOK * 2.00 + # 1-hour cache write
usage.cache_creation&.ephemeral_5m_input_tokens.to_i * INPUT_PER_MTOK * 1.25 + # 5-minute cache write
usage.cache_read_input_tokens.to_i * CACHE_READ_PER_MTOK + # cache read
usage.output_tokens * OUTPUT_PER_MTOK
) / 1_000_000
puts format("Request cost: $%.6f", cost)
```
**Was du prüfen solltest.**
* **Anteil der Cache-Lesevorgänge.** In Agent-Schleifen sollten die meisten Input-Token Cache-Lesevorgänge sein. Wenn `cache_read_input_tokens` im Vergleich zu `input_tokens` plus `cache_creation_input_tokens` klein ist, prüfe, ob das Caching aktiv ist und ob das Präfix zwischen den Anfragen gleich bleibt.
* **Advisor-Tool und Compaction.** Wenn das [Advisor-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#usage-and-billing) oder [Compaction](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold#understanding-usage) aktiviert ist, werden einige Token nur in `usage.iterations` und nicht in den Gesamtsummen der obersten Ebene gemeldet. Summiere stattdessen über `usage.iterations` und berechne `advisor_message`-Einträge zu den Tarifen des Advisor-Modells.
Die folgende Tabelle listet die Hebel in der Reihenfolge auf, in der du sie ausprobieren solltest. Die Zahlen stammen aus Anthropics eigenen Tests; jeder verlinkte Abschnitt und seine Referenzen nennen das Modell und die Methode:
| Hebel | Einsparung in Anthropics Tests | Qualitätskosten | Latenz | Wo |
| ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Prompt-Caching | Kosten um den Faktor 2,7 bis 5,5 bei einem Recherche-Agenten gesenkt und um 83 % bis 86 % bei einem kleinen Triage-Agenten | Keine | Schneller | [Wiederholten Kontext cachen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context) |
| 1-Stunden-Cache-Dauer | Bei 1 von 10 Turns nach einer Pause kostete der 5-Minuten-Standard 54 % mehr; bei 1 von 20 etwa gleich viel | Keine | Blieb nach einer Pause warm[16](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) | [Cache-Dauer wählen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#pick-the-cache-duration) |
| Input kürzen | Weitere 21 % bis 26 % weniger auf der Rechnung eines kleinen Triage-Agenten | Keine | Neutral | [Input- und Kontext-Token kürzen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
| Veraltete Tool-Ergebnisse an Aufgabengrenzen entfernen | 39 % bei einer langen Agent-Aufgabe; nichts bei kurzen. Verwende bei den im verlinkten Abschnitt genannten Modellen stattdessen Compaction | Keine gemessen | Neutral | [Den Kontext-Lebenszyklus verwalten](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#manage-the-context-lifecycle) |
| Tool-Suche | 45 % bei 500 angehängten Tool-Definitionen; 20 % durch das verzögerte Laden des Toolsets eines GitHub-MCP-Servers | Keine | Neutral | [Input- und Kontext-Token kürzen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
| Datendateien über Codeausführung | 92 % bei einer Datenaufgabe mit 25 Fragen | Ein Gewinn: 25 von 25 richtig statt 7 | Schneller | [Input- und Kontext-Token kürzen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
| Batch API | 50 % | Keine | Ergebnisse innerhalb von 24 Stunden | [Arbeit batchen, die warten kann](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#batch-work-that-can-wait) |
| Prompt-Audit gegen das aktuelle Modell | 14 % bei beiden getesteten Modell-Upgrades | Keine; bei einer ein Gewinn | Schneller (weniger Tool-Runden) | [Prompts gegen das aktuelle Modell auditieren](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#audit-prompts-against-the-current-model) |
| Das Modell upgraden | Meist weniger pro gelöster Aufgabe: bis zu 87 % weniger bei einem Coding-Benchmark | Keine; bei den meisten ein Gewinn | Neutral | [Modell upgraden](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#upgrade-the-model) |
| Niedrigerer Effort | Bei langen Coding-Aufgaben kostete `medium` etwa 30 % bis 52 % weniger als `high` und `low` etwa zwei Drittel weniger | Je nach Aufgabe bis zu 15 Punkte niedriger; bei einem Recherche-Agenten keine | Schneller | [Effort abstimmen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort) |
| Fehlschläge erneut ausführen | Etwa 40 % weniger, als alles mit `high` auszuführen, bei gleicher oder leicht besserer Erfolgsquote | Keine | Ein zweiter Versuch bei den fehlgeschlagenen Aufgaben | [Fehlschläge mit höherem Effort erneut ausführen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#re-run-failures-at-higher-effort) |
| Um kürzere Antworten bitten | Etwa 13 % weniger, durch 39 % weniger Output-Token | Keine | Schneller | [Budgets und Ausgabelimits festlegen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps) |
| `max_tokens` erhöhen | Keine: Die Kosten pro gelöster Aufgabe blieben ungefähr gleich | Ein Gewinn: bis zu 22 Punkte mehr gelöste Aufgaben bei einem Coding-Benchmark; bei einem anderen keiner | Neutral | [Budgets und Ausgabelimits festlegen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps) |
| Advisor | Keine: etwa das 2,1-Fache der Kosten des Modells allein, bei einem Coding-Benchmark | Beim Coding ein kleiner Gewinn, der Zufall sein kann; beim Lesen von Diagrammen ein Verlust | Etwa 1,4 zusätzliche Aufrufe pro Versuch, beim Coding | [Advisor-Strategie](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions) |
| Orchestrator | Etwa die Hälfte der Kosten des Orchestrator-Modells allein, bei Arbeit, die größer als ein Kontextfenster ist; bei Routinearbeit zuerst messen | 10 bis 12 Punkte niedriger bei dieser Arbeit | Viel schneller bei dieser Arbeit | [Orchestrator-Strategie](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#orchestrator-strategy-delegate-bulk-work) |
### Die Suche mit dem Claude API Skill automatisieren
Führe den Befehl `cost-optimize` des [Claude API Skills](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/claude-api-skill) aus, bevor du nach Einsparungen suchst. Er analysiert, wohin deine Token gehen, und wendet die Hebel der Reihe nach an, beginnend mit dem Caching. Führe dann `/claude-api hillclimb` in dem Verzeichnis aus, das deine Evaluierung enthält.
Anthropic hat den ersten Hebel von `cost-optimize` und zwei Suchläufe auf tau2-bench retail[24](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#refs) gemessen, alle mit früheren Modellen. Die von `cost-optimize` erzeugten Cache-Breakpoints senkten die Kosten pro Aufgabe, und die Erfolgsquote sank um weniger als die Streuung identischer Durchläufe.
Ein Suchlauf fand eine günstigere Konfiguration, indem er den Effort senkte und eine Modellstufe nach unten wechselte. Seine Erfolgsquote blieb um den Bruchteil einer Aufgabe innerhalb des vor der Suche festgelegten Bandes und endete unterhalb der strengeren Untergrenze, die die Suche für ihre eigenen Urteile verwendete. Ein zweiter Suchlauf, gestartet vom kostengünstigeren Modell mit dessen Standard-Effort, behielt nichts bei. Referenz 24 enthält die Zahlen und die Kosten, die jeder Suchlauf verursacht hat.
Das folgende Diagramm zeigt jeden Schritt des ersten Suchlaufs:
Zwei Einstellungen bestimmen, ob du der Antwort der Suche vertrauen kannst:
* **Halte einen Split zurück, den die Suche nie liest.** Die Suche entscheidet dort über die Übernahme, sodass die Bestätigung eine Änderung erkennt, die nur zu den Aufgaben passt, die die Suche gesehen hat, wie es bei den Prompt-Änderungen der Fall war (Referenz 24).
* **Wiederhole die Baseline vor der ersten Änderung.** Identische Durchläufe einer Ausgangskonfiguration unterschieden sich in diesen Messungen um mehrere Aufgaben (Referenz 24). Die Wiederholungen geben dem Übernahme-Gate der Suche eine Rauschschwelle.
## Referenzierte Benchmarks
Sofern eine Referenz nichts anderes angibt, handelt es sich bei den Messungen um Anthropic-interne Durchläufe dieser Benchmarks. Sofern nicht anders angegeben, sind Kosten in USD zu den Listenpreisen angegeben, die zum Zeitpunkt des jeweiligen Benchmark-Durchlaufs galten; Zahlen für Claude Sonnet 5 verwenden 2 $ bzw. 10 $ pro Million Eingabe- und Ausgabe-Token. Zahlen für Claude Sonnet 5.5 aus den Durchläufen vom 24. September 2026 verwenden dieselben Eingabe- und Ausgabepreise und seinen aktuellen Cache-Lesepreis, 0,10 $ pro Million Token, statt seines Einführungspreises von 0,20 $, angewendet auf die aufgezeichneten Token-Zahlen jedes Durchlaufs. Diese Durchläufe verwendeten einen Vorabversions-Build von Claude Sonnet 5.5, und kein Versuch darin wurde von einem Fallback-Modell beantwortet. Diagramme mit der Beschriftung „notional USD“ bepreisen die Token-Zahlen jeder Anfrage zu diesen Sätzen, statt Rechnungen wiederzugeben.
1. **WideSearch:** Wong et al., "WideSearch: Benchmarking Agentic Broad Info-Seeking," arXiv:2508.07999, 2025. Breit angelegte Web-Rechercheaufgaben, bewertet nach Vollständigkeit und Genauigkeit einer Tabelle mit vielen Zeilen; 200 Probleme, 3 Durchläufe pro Konfiguration, durchgeführt vom 1. bis 2. August 2026. Mit Claude Fable 5 gab bei diesem Benchmark, DeepWideSearch (Referenz 6), BrowseComp (Referenz 4) und GDPval (Referenz 2) `low`-Effort 1 bis 3 Punkte für ein Drittel bis die Hälfte weniger Kosten pro Aufgabe ab, `medium` erreichte die Genauigkeit des Standards bei etwa 70 % bis 87 % seiner Kosten, und der Standard brachte bei keinem der vier einen messbaren Vorteil gegenüber `medium`. Das Diagramm zur Kostenkonzentration ist ein separater Durchlauf mit 20 Problemen, 3 Durchläufe pro Problem, durchgeführt vom 3. bis 4. August 2026, mit Kosten aus Abrechnungsdaten pro Anfrage. Es umfasst 59 der 60 Durchläufe. Der sechzigste, mit 10,91 $ der Gesamtsumme von 432,31 $ abgerechnet, hat keine mit seinem Ergebnis erfassten Kosten und ist nicht enthalten.
2. **GDPval:** OpenAI, "GDPval: Evaluating AI Model Performance on Real-World Economically Valuable Tasks," 2025. Arbeitsergebnisse aus der Wissensarbeit, bewertet anhand von Aufgaben-Rubriken; ein Durchlauf mit 210 Aufgaben des veröffentlichten Gold-Sets, ein Versuch pro Aufgabe, durchgeführt am 2. August 2026. Ein Claude-Modell bewertet, daher können absolute Werte von veröffentlichten Ergebnissen abweichen.
3. **SWE-bench Pro:** Scale AI, "SWE-Bench Pro: Can AI Agents Solve Long-Horizon Software Engineering Tasks?", 2025.
* **Was gemessen wurde:** Eine Teilmenge von 482 Problemen, ausgewählt nach Kompatibilität mit Anthropics Evaluations-Harness; die Werte sind nicht mit dem öffentlichen Leaderboard vergleichbar. Sie sind auch nicht mit den SWE-bench-Pro-Ergebnissen in der System Card von Claude Opus 5.5 vergleichbar, die aus Durchläufen mit `max`-Effort auf einem anderen Problemsatz stammen.
* **Wie bepreist:** Die Kosten auf dieser Teilmenge werden so bepreist, wie die Organisation eines Kunden abgerechnet wird: der vorherige Prompt jeder Anfrage als Cache-Lesevorgang und ihre neuen Token als 5-Minuten-Cache-Schreibvorgang, aus den eigenen Nutzungsdaten der Durchläufe, abgeglichen mit einem Kundenkonto.
* **Durchläufe mit Claude Opus 5.5:** Die Zahlen für Claude Opus 5.5 mitteln zwei Durchläufe bei `low`, `medium` (seinem Standard) und `high` und verwenden einen Durchlauf bei `xhigh`, alle durchgeführt vom 19. bis 20. September 2026, mit derselben Obergrenze von 16.384 Token pro Turn wie die Claude-Opus-5-Durchläufe im August; die Obergrenze brach 2 `xhigh`-Versuche ab und keinen bei anderen Einstellungen. Gemessen an `high` erzielte Claude Opus 5.5 bei seinem Standard, `medium`, etwa 2,5 Punkte weniger für etwa 70 % der Kosten pro Aufgabe und bei `low` etwa 8 Punkte weniger für etwa ein Drittel der Kosten; `xhigh` erzielte etwa 1,4 Punkte mehr für das 2,5-Fache der Kosten von `high`. Die Verhältnisse stammen aus ungerundeten Kosten.
* **Die 478 Probleme:** Die Opus-5.5-Durchläufe verwendeten eine Version des Benchmarks, deren Bewertungscontainer nur interne Paket-Mirrors erreichen können. Diese Version lässt ein Problem weg, dessen Test eine Live-Website benötigt, und bei drei weiteren schlägt die Referenzlösung dort fehl, daher verwenden Opus-5.5-Vergleiche und die daneben gestellten Zahlen für Claude Fable 5.1 die verbleibenden 478 Probleme.
* **Durchläufe mit Claude Sonnet 5.5:** Claude Sonnet 5.5 lief auf derselben Version des Benchmarks: zwei Durchläufe bei seinem Standard, `high`, und zwei bei `medium`, alle am 24. September 2026, mit derselben Obergrenze von 16.384 Token pro Turn, die keinen seiner Versuche abbrach. Seine Zahlen verwenden die 478 Probleme, ebenso die daneben gestellten Zahlen für Claude Sonnet 5, gezählt über diese Probleme aus ihren August-Durchläufen.
* **Durchläufe mit Claude Opus 5:** Die SWE-bench-Pro-Zahlen für Claude Opus 5 in [Modell upgraden](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#upgrade-the-model) und in dieser Referenz mitteln zwei Durchläufe bei seinem Standard-Effort und verwenden einen Durchlauf bei `low`, alle durchgeführt am 4. August 2026.
* **Advisor, Paarungen mit Claude Sonnet 5:** Die Paarungen von Claude Sonnet 5 als Executor mit Claude Opus 5 als Advisor hinter den Beispielen zur Konsultationsrate in [Advisor-Strategie](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions) stammen aus derselben Messreihe auf dieser Teilmenge: die Paarung beim Standard-Effort lief zweimal (7. und 8. August 2026, ein Durchlauf und eine exakte Replikation), die Paarung mit niedrigem Effort einmal (8. August 2026) und Claude Sonnet 5 allein zweimal (77,4 %, die Baseline für beide Paarungen).
* **Advisor, Konsultationsprüfung mit Claude Sonnet 5.5:** Die in [Advisor-Strategie](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions) zitierte Konsultationsprüfung mit Claude Sonnet 5.5 führte am 24. September 2026 einen Versuch für jedes von 20 der 478 Probleme durch, mit einem Claude-Opus-5.5-Advisor über das Advisor-Tool. Vier Konfigurationen liefen: `high` und `xhigh`, jeweils mit und ohne den in der Dokumentation des Advisor-Tools vorgeschlagenen System-Prompt für Coding-Aufgaben. Bei seinem Standard-Effort, `high`, konsultierte Claude Sonnet 5.5 den Advisor bei keinem der 20 Probleme, mit oder ohne den Prompt. Bei `xhigh` konsultierte es ihn bei 3 der 20 Probleme ohne den Prompt und bei 4 mit ihm, jedes Mal bei seinen Versuchen mit den meisten Turns.
* **Eskalationszahlen:** Die Eskalationszahlen stammen Aufgabe für Aufgabe aus den Opus-5.5-Durchläufen: zuerst `low`, dann `high` bei dessen Fehlschlägen, löste über die Durchlaufpaarungen hinweg 96,4 % bis 97,5 % für etwa 0,17 $; zuerst `medium`, 96,0 % bis 97,1 % für etwa 0,24 $; `high` erneut auf seinen eigenen Fehlschlägen ausgeführt, 96,9 % für 0,31 $; alles bei `high`, 94,8 % bis 95,8 % für 0,29 $.
* **Modelle vergleichen:** Die Zahl für Claude Fable 5.1 in [Modelle vergleichen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) stammt aus einem Durchlauf auf derselben Teilmenge beim Standard-Effort, durchgeführt am 26. August 2026: gezählt über die 478 Probleme löste es 92,3 % für 1,19 $ pro gelöster Aufgabe. Das Diagramm dieses Abschnitts und seine Zahlen für Claude Opus 5.5 und Claude Sonnet 5.5 fassen die zwei Durchläufe bei jeder dargestellten Einstellung zusammen, alle gezählt über die 478 Probleme: Claude Opus 5.5 bei `low`, `medium` und `high` und Claude Sonnet 5.5 bei `medium` und `high`.
* **Modelle vergleichen, Arbeit pro Aufgabe:** In diesen Zahlen leistete Claude Opus 5.5 bei `low` bei jeder Aufgabe weniger Arbeit als Claude Sonnet 5.5 bei seinem Standard: etwas mehr als die Hälfte der Ausgabe-Token von Sonnet 5.5 und etwas mehr als ein Drittel seiner Cache-Lesevorgänge. Bei ihren Standards löste Opus 5.5 bei `medium` etwa 5 Prozentpunkte mehr als Sonnet 5.5 für etwa die doppelten Kosten. Bei dieser Einstellung leistete es pro Aufgabe etwas mehr Arbeit als Sonnet 5.5.
* **Modell upgraden, Durchläufe:** Der Punkt für Claude Fable 5 in „Modell upgraden“ fasst drei Durchläufe beim Standard-Effort zusammen, durchgeführt am 26. August 2026, bepreist so, wie die Organisation eines Kunden abgerechnet wird. Die Upgrade-Leiter zählt jedes Modell über die 478 Probleme, jeweils mit seinen ausgelieferten Standardeinstellungen. Sie verwendet einen Durchlauf pro Modell außer bei Opus 5, Opus 5.5, Sonnet 5 und Sonnet 5.5 (je zwei Durchläufe) und Fable 5 (die drei oben beschriebenen Durchläufe). Die Durchläufe mit Opus 4.7, Opus 4.8, Sonnet 4.6 und Sonnet 5 liefen vom 17. bis 19. August 2026 und die Opus-5-Durchläufe am 4. August, alle in einem Harness und einer Organisation; die Durchläufe mit Opus 5.5 und Sonnet 5.5 sind die weiter oben in dieser Referenz beschriebenen.
* **Modell upgraden, Kosten pro gelöster Aufgabe:** Claude Opus 5 kostet pro gelöster Aufgabe 21 % mehr als Claude Opus 4.8, wenn diese Claude-Opus-5-Durchläufe mit einem Claude-Opus-4.8-Durchlauf mit seinen ausgelieferten Standardeinstellungen aus der Reihe vom 17. bis 19. August verglichen werden, gezählt über dieselben 478 Probleme; das SWE-bench-Pro-Feld des Diagramms zeigt weder Claude Opus 4.7 noch Claude Opus 4.8. In denselben Messungen, bepreist so, wie ein Kunde abgerechnet wird, löst Claude Opus 5 12 Punkte mehr Aufgaben als Claude Opus 4.8 bei diesen 21 % mehr pro gelöster Aufgabe, Claude Opus 4.8 löst denselben Anteil an Aufgaben wie Claude Opus 4.7 für 14 % weniger pro gelöster Aufgabe, und Claude Opus 5 mit `low`-Effort schlägt auf diesem Benchmark den Standard von Claude Opus 4.8 für etwa 30 % von dessen Kosten pro gelöster Aufgabe.
* **Modell upgraden, Preise:** Die Ersparnis von Claude Sonnet 5 gegenüber Claude Sonnet 4.6 in „Modell upgraden“ ergibt sich aus seinem niedrigeren Preis pro Token, der die zusätzlichen Token, die es pro Aufgabe verwendet, mehr als ausgleicht. Claude Sonnet 5.5 berechnet für alles dasselbe wie Claude Sonnet 5 außer für Cache-Lesevorgänge, die halb so viel kosten. Die Token-Preise von Claude Opus 5.5 sind niedriger als die von Claude Opus 5, am stärksten bei Cache-Lesevorgängen. Wie Claude Sonnet 5 hat die Frontier-Stufe über den Preis gewonnen: Der Großteil der Ersparnis von Claude Fable 5.1 ist der niedrigere Preis für Cache-Lesevorgänge.
* **Kosten ohne Caching, bepreist aus aufgezeichneten Token-Zahlen:** Anthropic hat außerdem die aufgezeichneten Token-Zahlen der weiter oben in dieser Referenz beschriebenen Durchläufe mit Claude Opus 5.5 und Claude Sonnet 5.5 über die 478 Probleme für die Caching-Faktoren in [Warum Caching an erster Stelle steht](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first) neu bepreist; es wurde kein Durchlauf mit deaktiviertem Caching durchgeführt.
* **Die Faktoren, nach Modell:** Jeder Faktor sind die Token-Kosten mit jedem Eingabe-Token zum Eingabepreis, Ausgabe-Token unverändert, geteilt durch die Kosten, bepreist so, wie die Organisation eines Kunden abgerechnet wird: für Claude Opus 5.5 3,3 bei `medium`, 2,4 bei `low`, 3,8 bei `high` und 5,4 bei `xhigh` (ein Durchlauf); für Claude Sonnet 5.5, mit Cache-Lesevorgängen zu 0,10 $ pro Million Token, 3,1 bei `high` und 2,4 bei `medium`, oder 2,8 bei `high` zum Einführungspreis von 0,20 $. Anders als bei den Durchläufen des Caching-Diagramms fielen hier keine Websuchgebühren an, und die erste Anfrage einer Aufgabe wird als Cache-Schreibvorgang bepreist.
4. **BrowseComp:** Wei et al., "BrowseComp: A Simple Yet Challenging Benchmark for Browsing Agents," OpenAI, 2025. Die Effort-Zahlen verwenden einen Ausschnitt von 500 Problemen, ein bis drei Durchläufe pro Einstellung, durchgeführt am 3. August 2026, wobei der Standardpunkt zwei Durchläufe vom 26. bis 27. Juli 2026 zusammenfasst. Die Messung von Routinearbeit mit einem langen Kostenausläufer in [Orchestrator-Strategie](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#orchestrator-strategy-delegate-bulk-work) verwendet 10 Probleme, die das Modell allein zuverlässig löste, als das Protokoll festgelegt wurde, aus einem Ausschnitt von 26 Problemen, 50 delegierte Durchläufe (5 pro Problem; 1. bis 2. August 2026) und 70 Durchläufe des Modells allein (50 vom 2. bis 3. August 2026; 20 archiviert vom 12. bis 13. Juli und 1. August 2026), 6,45 $ gegenüber 11,99 $ pro Durchlauf im Erwartungswert; delegierte Zahlen haben ein Messband von etwa 20 %. Die 10 Probleme sind diejenigen, bei denen die delegierte Konfiguration, ein Claude-Fable-5-Orchestrator mit einem Claude-Sonnet-5-Worker, in allen 5 Durchläufen richtig lag und Claude Fable 5 allein in beiden archivierten Durchläufen; die delegierten Durchläufe sind genau diese Durchläufe, und nur Claude Fable 5 allein wurde auf den zehn erneut ausgeführt. Über seine 70 Durchläufe, archivierte und neue, lag Claude Fable 5 allein in 68 richtig. Bei diesen Problemen kostete die delegierte Konfiguration im Durchschnitt etwa halb so viel wie Claude Fable 5 allein (die zuvor genannten 6,45 $ und 11,99 $) und beim 90. Perzentil etwa ein Drittel so viel (12 $ gegenüber 33 $ pro Durchlauf), und ihr teuerster Durchlauf kostete 42 $ gegenüber 84 $; dieser 84-$-Durchlauf war zudem falsch. Auf dem vollständigen, schwierigeren BrowseComp-Satz erreichte Claude Fable 5 allein die Genauigkeit der auf diesem Satz gemessenen Orchestrator-Konfiguration bei 22 % bis 30 % niedrigeren Kosten.
5. **Skalierung von Agentenarchitekturen:** Kim et al., "Towards a Science of Scaling Agent Systems," arXiv:2512.08296, 2025. Unabhängige externe Studie, nur für die Richtung des Befunds zitiert, wann sich Delegation nicht lohnt, nicht für irgendeine Zahl.
6. **DeepWideSearch:** "DeepWideSearch: Benchmarking Depth and Width in Agentic Information Seeking," arXiv:2510.20168, 2025. Die 220 Fragen umfassen 15 Domänen, die jeweils das Sammeln vieler Zeilen mit Multi-Hop-Retrieval kombinieren; gemessen auf dem festen Zeilensatz des Benchmarks, 3 Durchläufe pro Konfiguration, durchgeführt am 2. August 2026 (der Team-Punkt mit einem einzelnen Worker lief vom 26. bis 27. Juli 2026). Mit Claude Fable 5 erreichte `low`-Effort einen Orchestrator mit einem Claude-Sonnet-5-Worker bei 29 % niedrigeren Kosten und benötigte 4,5 Minuten pro Problem gegenüber 7,9 Minuten beim Standard.
7. **DeepResearch Bench II:** Li et al., "DeepResearch Bench II: Diagnosing Deep Research Agents via Rubrics from Expert Report," arXiv:2601.08536, 2026.
* **Was gemessen wurde:** Seine 132 Rechercheaufgaben über 22 Domänen werden anhand binärer, von Experten abgeleiteter Rubriken bewertet. Gemessen auf einer über alle Themen stratifizierten Teilmenge von 50 Aufgaben, ein Versuch pro Aufgabe, 3 Durchläufe pro Einstellung, auf [Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview) mit den plattformeigenen Tools für Websuche und Abruf (26. bis 27. August 2026).
* **Wie bewertet:** Bewertet auf den 33 Aufgaben, die keine Konfiguration verweigerte, wobei Versuche entfernt wurden, die von den Produktions-Sicherheitsklassifikatoren vorzeitig beendet wurden. Claude Opus 4.6 bewertet nach dem Rubrik-Protokoll des Benchmarks; das Original verwendet einen anderen Bewerter, und ein Anthropic-Bewerter könnte den hauseigenen Stil bevorzugen.
* **Werte:** Die Werte sind der Mittelwert jedes Modells auf der 33-Aufgaben-Basis, wobei seine eigenen vorzeitig beendeten Aufgaben entfernt wurden; bei den 21 der 33 Aufgaben, bei denen keine Konfiguration einen vorzeitig beendeten Versuch hatte, hält Claude Fable 5.1 auf jeder Effort-Stufe einen Vorsprung von 2 bis 3 Punkten vor Claude Fable 5, und beide Modelle sind über den Effort hinweg flach.
* **Wie bepreist:** Die Kosten werden so bepreist, wie die Organisation eines Kunden abgerechnet wird: der vorherige Prompt jeder Anfrage als Cache-Lesevorgang und ihre neuen Token als 5-Minuten-Cache-Schreibvorgang, wobei die erste Anfrage einer Sitzung den erhaltenen Cache-Lesevorgang behält, aus den eigenen Nutzungsdaten der Durchläufe, zuzüglich der Websuchgebühren der Plattform. Die Kosten pro Aufgabe sind jeweils die Kosten eines 50-Aufgaben-Durchlaufs geteilt durch 50, einschließlich der vorzeitig beendeten Versuche, gemittelt über die drei Durchläufe.
* **Ergebnisse, Claude Fable 5:** Claude Fable 5 kostete 2,30 $ pro Aufgabe bei `low` und 4,71 $ bei `high`, auf dieselbe Weise bepreist; die Prozentsätze in [Modell upgraden](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#upgrade-the-model) stammen aus ungerundeten Kosten.
* **Ergebnisse, Claude Opus 5:** Claude Opus 5 lief bei seinem Standard-Effort auf derselben Oberfläche und Teilmenge, drei Durchläufe, am 28. August 2026: 68,8 % auf den rohen 50 Aufgaben, 70,8 % auf der 33-Aufgaben-Basis und 71,1 % auf dem 21-Aufgaben-Satz, bei 6,28 $ pro Aufgabe (23,72 $ ohne Caching); keiner seiner Versuche wurde von den Sicherheitsklassifikatoren vorzeitig beendet, unter einem neueren Safeguards-Deployment als dem, unter dem die anderen Modelle liefen.
* **Modelle vergleichen:** Der Recherchevergleich in [Modelle vergleichen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) stützt sich auf diese Zahlen: Claude Fable 5.1 bei `low` erzielte auf der 33-Aufgaben-Basis 10 Punkte mehr als Claude Sonnet 5 (66 % gegenüber 56 %) bei etwa den vierfachen Kosten pro Aufgabe über alle 50 Aufgaben (4,48 $ gegenüber 1,18 $); Claude Opus 5 bei seinem Standard, dessen Werte und Kosten weiter oben in dieser Referenz angegeben sind, erzielte mehr als Claude Fable 5.1 bei seinem Standard, das auf der 33-Aufgaben-Basis 65 % erzielte und über alle 50 Aufgaben 6,89 $ pro Aufgabe kostete, sodass Claude Fable 5.1 bei Recherche seinen Preis nur bei `low` rechtfertigt.
* **Caching-Diagramm:** Das Caching-Diagramm bepreist dieselben Anfragen neu, mit jedem Eingabe-Token zum ungecachten Satz.
* **Nicht gemessen:** Claude Sonnet 5.5 wurde auf diesem Benchmark nicht gemessen.
8. **Korpus-Fehlersuche:** Anthropic-intern, für Arbeit, die größer als ein Kontextfenster ist: ein Korpus mit 21,6 Millionen Token aus 14 öffentlichen Python-Paketquellen mit 130 eingebauten Defekten und deterministischer Bewertung; Protokoll vor den Durchläufen festgelegt und intern geprüft; drei Durchläufe pro Konfiguration. Jede Konfiguration lief auf Claude Managed Agents. Die im Diagramm dargestellte Team-Konfiguration ist eine, in der der Claude-Fable-5.1-Orchestrator die gesamte Suche innerhalb der Plattform an ihrem dokumentierten Limit von 25 gleichzeitigen Claude-Sonnet-5-Workern ausführte, durchgeführt am 30. August 2026; ihre drei Durchläufe erzielten nach der Prüfung der Zusatzfunde F1 0,764, 0,825 und 0,791 (roh 0,751, 0,821 und 0,781) für 225 $, 234 $ und 283 $. Die Team-Konfiguration kostete etwa halb so viel wie Claude Fable 5.1 allein bei `low`, `medium` oder `high` (47 % bis 55 % weniger), erzielte 10 bis 12 Punkte weniger und benötigte etwa 2,3 Stunden pro Durchlauf gegenüber 15 bis 20 Stunden. Die Team-Konfiguration las etwa 560 Millionen gecachte Token pro Durchlauf, fast alle zum Cache-Lesesatz von Claude Sonnet 5. Das ist etwa das Anderthalbfache der rund 365 Millionen, die Claude Fable 5.1 allein las. Claude Fable 5.1 allein mit `high`-Effort hält weiterhin die Spitzengenauigkeit, bei etwa dem 2,2-Fachen der Kosten der Team-Konfiguration, sodass Delegation hier den Großteil der Genauigkeit erkauft, nicht alles. Die Konfiguration mit Claude Sonnet 5 allein lief vom 3. bis 4. August 2026; die Konfigurationen mit Claude Fable 5.1 allein liefen vom 24. bis 25. August 2026 unter den Serving-Einstellungen der Plattform zum Launch, drei Seeds pro Effort-Einstellung, auf demselben Korpus-Build. Das Sandbox-Image enthielt installierte Kopien eines Teils des Korpus, und der abschließende Zusammenstellungsschritt von Claude Fable 5.1 verglich in 7 von 9 Durchläufen mit ihnen; eine Neubewertung ohne diese Ergänzungen verschob die betroffenen Seeds um bis zu 3 Punkte. Der absolute F1-Wert ist spezifisch für diesen Korpus-Build und nicht über Benchmarks hinweg vergleichbar; Konfigurationsvergleiche sind gleichartig.
9. **GPQA Diamond:** Rein et al., "GPQA: A Graduate-Level Google-Proof Q\&A Benchmark," 2023. Die Diamond-Teilmenge mit 198 Fragen, modellbewertet anhand von Referenzantworten, Advisor-Token pro Anfrage erfasst. Claude Haiku 5.5 und Claude Sonnet 5.5, jeweils allein und mit einem Claude-Opus-5.5-Advisor, sowie Claude Opus 5.5 allein liefen am 7. Oktober 2026 mit zwei Durchläufen pro Konfiguration, alle mit deaktiviertem [serverseitigem Fallback](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#server-side-fallback), beim Standard-Effort jedes Modells und mit Verweigerungen als falsch gezählt. Eine Sicherheitsprüfung der Plattform verweigerte pro Durchlauf eine Biologiefrage bei Claude Haiku 5.5 und Claude Sonnet 5.5 allein, eine in zwei Durchläufen bei Haiku 5.5 mit dem Advisor, keine bei Sonnet 5.5 mit dem Advisor und sechs pro Durchlauf bei Opus 5.5, das 91 % erzielte, wenn diese als falsch gezählt werden, und 93,5 % auf den Fragen, die es beantwortete. Claude Haiku 5.5 allein erzielte 85 %, 6 Punkte unter Opus 5.5. Die Advisor-Konfigurationen fügten das Tool ohne einen Prompt hinzu, der um Konsultationen bat, und keiner der Executors rief den Advisor bei irgendeiner Frage auf. Die Paarungen erzielten 0,5 Punkte (Claude Haiku 5.5) und 1,0 Punkte (Claude Sonnet 5.5) mehr als der Executor allein, beides innerhalb des Rauschens zwischen Durchläufen.
10. **DeepSWE:** Datacurve, "DeepSWE: Measuring Frontier Coding Agents on Original, Long-Horizon Engineering Tasks," arXiv:2607.07946, 2026. Der Satz umfasst 113 originale Aufgaben in fünf Sprachen mit programmbasierten Verifizierern. Paarungen sind je zwei Durchläufe, durchgeführt am 7. August 2026, mit pro Anfrage erfassten Advisor-Token, und verwendeten eine clientseitige Advisor-Schleife statt des Advisor-Tools, mit identischer Abrechnung. Effort-Sweeps mit einem einzelnen Modell sind einzelne Durchläufe, bepreist aus Token-Zahlen, eine cache-bewusste Näherung. Die Kosten pro Aufgabe sind Durchlaufsummen geteilt durch 113. Auf diesem Benchmark erzielte ein Claude-Sonnet-5-Executor mit niedrigem Effort und einem Advisor 23 Punkte mehr als derselbe Executor allein.
11. **Interner Agentic-Coding-Benchmark:**
* **Was gemessen wurde:** Anthropic-intern: 370 Repository-Aufgaben, bewertet durch die eigenen Tests der Repositories. Die API-Zahlen wurden mit einem einfachen API-Agenten und einem Ausgabelimit von 128.000 Token gemessen, ein Durchlauf pro Konfiguration: Opus 5 allein beim Standard-Effort vom 9. bis 10. August 2026 und bei `low` und `medium` am 10. August 2026; Claude Fable 5.1 allein bei fünf explizit gesetzten Effort-Werten am 20. August 2026 (das Diagramm zeigt drei davon); und die Paarung vom 24. bis 25. August 2026.
* **August-Durchläufe:** Die August-Durchläufe hatten fünf Versuche pro Aufgabe für die Paarung und die Claude-Opus-5-Kontrolle und einen für die anderen Punkte.
* **Wie bepreist:** Die Kosten gelten pro Versuch. Die Kosten werden so bepreist, wie die Organisation eines Kunden abgerechnet wird: der vorherige Prompt jeder Anfrage der Agent-Schleife als Cache-Lesevorgang und ihre neuen Token als 5-Minuten-Cache-Schreibvorgang, aus den eigenen Nutzungsdaten der Durchläufe, und jeder Advisor-Aufruf, der keinen Cache verwendet, aus seinen aufgezeichneten Token, alles zu Listenpreisen.
* **Claude Opus 5.5 allein:** Claude Opus 5.5 allein lief auf allen 370 Aufgaben, 19. bis 20. September 2026: bei seinem Standard-Effort (`medium`) und bei `high` mit fünf Versuchen pro Aufgabe und bei `low` und `xhigh` mit einem (jeweils 369 von 370 bewertet, nach einem Fehlschlag der Setup-Prüfung). Claude Opus 5.5 allein löste 74,8 % der Versuche bei `low` für 0,35 $ pro Versuch, 86,6 % bei `medium` für 0,84 $, 88,4 % bei `high` für 1,38 $ und 91,1 % bei `xhigh` für 4,11 $.
* **Claude Opus 5.5 mit einem Claude-Fable-5.1-Advisor, Durchläufe:** Der Claude-Opus-5.5-Executor bei `high` mit dem veröffentlichten Claude Fable 5.1 als Advisor (die August-Durchläufe verwendeten einen Vorabversions-Snapshot) lief an denselben Tagen mit fünf Versuchen pro Aufgabe; eine Aufgabe bestand ihre Setup-Prüfung nicht, daher wurden 1.845 Versuche bewertet. Die 279 Versuche, bei denen der Advisor unter Last abgewiesen wurde, wurden erneut ausgeführt, und Versuche, deren Konsultationen ein Timeout hatten, wurden beibehalten, wie im August.
* **Claude Fable 5.1 allein:** Zum Vergleich erzielte das veröffentlichte Claude Fable 5.1 allein bei `high`, seinem Standard, 85,7 % (317 von 370 Aufgaben), ein Versuch pro Aufgabe am 7. Oktober 2026.
* **Konsultationen:** Die August-Paarung hatte im Durchschnitt etwa zwei Advisor-Konsultationen pro Versuch; die Claude-Opus-5.5-Paarung forderte 1,39 an und erhielt 1,35.
* **Claude Opus 5.5 mit einem Claude-Fable-5.1-Advisor, Ergebnisse:** Die Claude-Opus-5.5-Paarung erzielte 90,1 % bei 2,92 $ pro Versuch: verglichen mit Claude Opus 5.5 bei seinem Standard, `medium`, sind das 3,5 Punkte für etwa das 3,5-Fache des Geldes. Die Latenzkosten sind die Konsultationen selbst: etwa ein oder zwei zusätzliche Aufrufe eines Frontier-Modells pro Aufgabe, jeweils auf dem kritischen Pfad der Aufgabe. Mit dem Claude-Opus-5.5-Executor sparte der Rat fast keine Executor-Kosten: 1,36 $ pro Versuch gegenüber 1,38 $ für Claude Opus 5.5 allein bei `high`, während die Konsultationen 1,55 $ kosteten.
* **August-Paarung:** Im August, mit einem Claude-Opus-5-Executor und einem Claude-Fable-5.1-Advisor, gab der Executor pro Versuch 1,26 $ weniger aus als Claude Opus 5 allein bei seinem Standard, und die Konsultationen kosteten 2,47 $, sodass diese Ersparnis etwa die Hälfte des Rats bezahlte. Diese August-Paarung war zu dem Zeitpunkt die genaueste gemessene Konfiguration, bei 6,21 $ pro Versuch.
* **Claude Sonnet 5.5 allein, Durchläufe:** Claude Sonnet 5.5 allein lief am 24. September 2026 auf allen 370 Aufgaben, bei seinem Standard-Effort (`high`) und bei `medium`, ein Versuch pro Aufgabe, mit demselben Ausgabelimit von 128.000 Token, das keinen seiner Versuche abbrach. Alle 370 wurden bei `medium` bewertet und 369 von 370 bei `high`, nach einem Fehlschlag der Setup-Prüfung. Seine Kosten werden so bepreist, wie die Organisation eines Kunden abgerechnet wird.
* **Claude Sonnet 5.5 allein, Ergebnisse:** Ohne Advisor erzielte Claude Sonnet 5.5 bei seinem Standard, `high`, 77,8 % für 0,33 $ pro Versuch, etwa 9 Punkte unter Claude Opus 5.5 bei seinem Standard für etwa zwei Fünftel der Kosten; bei `medium` erzielte es 62,7 % für 0,16 $. Bei `medium` erzielte Claude Sonnet 5.5 etwa 15 Punkte weniger als bei seinem Standard, `high`, für etwa 48 % der Kosten pro Versuch.
* **Modelle vergleichen:** In [Modelle vergleichen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) kostete Claude Opus 5.5 bei seinem Standard pro Versuch weniger als ein Drittel so viel wie Claude Fable 5.1 bei `medium`, was ein einzelner Durchlauf ist.
12. **Interner Repository-Aufgaben-Benchmark (Messung der Obergrenze):**
* **Was gemessen wurde:** Ein separater Anthropic-interner Satz von etwa 130 Repository-Aufgaben, durchgeführt am 20. August 2026 (Claude Fable 5.1) und am 19. September 2026 (Claude Opus 5.5, bei seinem Standard-Effort, `medium`), mit einer einfachen API-Agent-Schleife, ein Versuch pro Aufgabe.
* **Wie bepreist:** Die Kosten pro gelöster Aufgabe werden für Claude Fable 5.1 so bepreist, wie ein Kunde abgerechnet wird, mit einem 5-Minuten-Prompt-Cache, und für Claude Opus 5.5 zu Listenpreisen aus den Token-Zahlen, die seine Durchläufe aufgezeichnet haben.
* **Durchläufe mit Claude Fable 5.1:** Die Durchläufe mit Claude Fable 5.1 umfassen 135 Aufgaben pro Obergrenze beim explizit gesetzten Standard-Effort: die Zahl für 16.384 Token mittelt zwei Durchläufe (36,3 % bei beiden); die Zahlen für 64.000 und 128.000 sind einzelne Durchläufe (58,5 % und 60,0 %). Fünf Probleme lösten in allen vier Durchläufen eine Sicherheitsverweigerung aus und zählen als Fehlschläge.
* **Durchläufe mit Claude Opus 5.5:** Die Zahl für Claude Opus 5.5 bei 16.384 Token mittelt zwei Durchläufe (134 und 135 bewertete Aufgaben), und seine Zahlen für 64.000 und 128.000 sind einzelne Durchläufe (je 135 Aufgaben); zwei Versuche in jedem 16.384-Token-Durchlauf und einer in jedem der Durchläufe mit 64.000 und 128.000 Token endeten mit einer Sicherheitsverweigerung und zählen als Fehlschläge. Claude Opus 5.5 löste 57,6 % bei 16.384 (58,2 % und 57,0 %), 75,6 % bei 64.000 und 68,9 % bei 128.000. Keiner seiner Versuche wurde bei 64.000 oder 128.000 abgebrochen, daher erklärt die Obergrenze den Unterschied zwischen diesen beiden Durchläufen nicht.
* **Von der Obergrenze beendete Versuche:** Nur 1 der 66 Claude-Opus-5.5-Versuche, die die Obergrenze von 16.384 Token beendete, und 9 der 117 Claude-Fable-5.1-Versuche bestanden dennoch.
* **Kosten pro Versuch:** Die Kosten pro Versuch betrugen für Claude Opus 5.5 3 $ bei 16.384 und 4 $ bei 64.000, zu Listenpreisen, und für Claude Fable 5.1 8 $ und 13 $, so wie ein Kunde abgerechnet wird.
* **Obergrenzen-Zahlen für SWE-bench Pro:** Die Obergrenzen-Zahlen für SWE-bench Pro sind ein Claude-Fable-5.1-Durchlauf pro Obergrenze beim Standard-Effort, durchgeführt am 26. August 2026, auf einer Teilmenge von 100 Problemen, stratifiziert aus dem 482-Probleme-Satz von Referenz 3, nicht mit dessen Werten vergleichbar; beim Standard-Effort lösten die Durchläufe bei 16.384 und bei 64.000 jeweils 94 der 100 Probleme.
* **Turn-Länge:** Die Verteilungen pro Turn im Punktdiagramm des Abschnitts stammen aus den Durchläufen mit Claude Opus 5.5 und Claude Fable 5.1 bei 128.000: kein Opus-5.5-Turn erreichte die Obergrenze (der längste hatte etwa 61.000 Token, und 0,56 % seiner Turns überschritten 16.384), und ein Fable-5.1-Turn erreichte 128.000 (0,46 % seiner Turns überschritten 16.384). Mit der Obergrenze bei 128.000 waren 2 der 14.331 Turns von Claude Fable 5.1 länger als 64.000 Token, und kein Turn von Claude Opus 5.5.
13. **Chartography:** Surge AI, "Chartography," 2026.
* **Was gemessen wurde:** Der vollständige veröffentlichte Satz mit 100 Fragen, gemessen am 6. und 9. August 2026 (Claude Opus 5 allein) und am 20. September 2026 (Claude Opus 5.5), mit Anthropics Implementierung auf Claude Managed Agents (Standard-Cloud-Sandbox; Advisor-Konfigurationen verwenden den Managed-Agents-Advisor).
* **Wie bewertet:** Claude Sonnet 4.6 bewertet anstelle des Referenzbewerters, und der Benchmark läuft mit Tools, daher sind die Werte hier über Konfigurationen hinweg vergleichbar, aber nicht mit dem veröffentlichten Leaderboard. Sie sind auch nicht mit den Chartography-Ergebnissen in der System Card von Claude Opus 5.5 vergleichbar, die einen anderen Bewerter verwenden und mit `max`-Effort laufen. Zwei Durchläufe pro Konfiguration (drei für Claude Opus 5.5), zusammengefasst; die Streuung zwischen Durchläufen betrug bis zu 10 Punkte.
* **Wie bepreist:** Die Kosten sind das, was einem Kunden, der den Agenten routinemäßig ausführt, in Rechnung gestellt wird: die erste Anfrage jedes Diagramms liest den gemeinsamen System-Prompt und die Tools des Agenten aus dem Cache, wie es der Fall ist, wenn in den vorangegangenen 5 Minuten eine andere Sitzung desselben Agenten lief. Ein für sich allein ausgeführtes Diagramm kostet mit Claude Opus 5 oder Claude Opus 5.5 etwa 0,03 $ mehr und mit Claude Fable 5.1 etwa 0,12 $ mehr. Die August-Zahlen werden auf diese Weise aus den Nutzungsdaten der Durchläufe neu bepreist. Die Kosten schließen Sandbox-Zeit aus, die den August-Durchläufen weniger als 1 % hinzufügte.
* **Claude Fable 5.1 allein, August-Durchläufe:** Die Durchläufe von Claude Fable 5.1 allein stammen vom 24. August 2026, unter den Serving-Einstellungen der Plattform zum Launch, zwei Durchläufe pro Einstellung; sechs Versuche erreichten die Sitzungsobergrenze von 15 Minuten und erhalten 0 Punkte, und zwei Diagramme pro Durchlauf wurden nach einer Sicherheitsverweigerung von Claude Opus 5 beantwortet.
* **Claude Opus 5 mit einem Claude-Fable-5.1-Advisor:** Der Claude-Opus-5-Executor mit niedrigem Effort und einem Claude-Fable-5.1-Advisor lief am 30. August 2026 zweimal unter denselben Einstellungen (63,0 und 67,0, Mittelwert 65,0, bei 0,47 $ pro Diagramm; der Advisor wurde in jedem Durchlauf bei 88 % der Aufgaben konsultiert, und 4 seiner 219 Antworten kamen stattdessen von Claude Opus 5, jeweils nachdem ein Produktions-Sicherheitsfilter die eigene Antwort des Advisors gestoppt hatte). Diese Paarung erreichte Claude Fable 5.1 allein bei `medium` innerhalb des Rauschens zwischen Durchläufen (65,0 gegenüber 67,5) bei etwa dem 1,8-Fachen der Kosten pro Aufgabe: eine Konsultation, die bei den meisten Aufgaben ausgelöst wird, kostet mehr, als das stärkere Modell selbst auszuführen.
* **Durchläufe mit Claude Opus 5.5:** Claude Opus 5.5 lief bei `low`, mit deaktiviertem serverseitigem Fallback und einem Sicherheitsklassifikator, der jeden Tool-Aufruf beurteilte: drei Durchläufe allein (70, 68 und 68) und drei mit einem konfigurierten Claude-Fable-5.1-Advisor (59, 63 und 63), in denen es den Advisor bei 1 von 300 Aufgaben konsultierte.
* **Ergebnisse bei `low`-Effort:** Auf diesem Benchmark zum Lesen von Diagrammen erzielte Claude Opus 5.5 bei `low` 68,7 für etwa 0,03 $ pro Diagramm, gegenüber 62,5 für 0,15 $ von Claude Fable 5.1 bei `low` und 49 für 0,16 $ von Claude Opus 5 bei `low`.
* **Claude Fable 5.1 allein, Oktober-Durchläufe:** Zum Vergleich mit der Claude-Opus-5.5-Paarung wurde Claude Fable 5.1 allein bei `high`, seinem Standard, am 7. Oktober 2026 dreimal ausgeführt, mit derselben Implementierung und denselben Plattformeinstellungen wie die Claude-Opus-5.5-Durchläufe: 82, 79 und 79, ein Mittelwert von 80,0.
* **Konsultationsrate:** Der Vergleich der Konsultationsrate für die früheren Paarungen stammt aus der erneuten Ausführung derselben Konfigurationen auf der Messages API mit einem Container-Toolset, 10. bis 11. August 2026.
14. **Evaluation des Prompt-Audits für einen Support-Desk:**
* **Was gemessen wurde:** Ein von Anthropic erstellter Satz von 44 Support-Tickets mit deterministischer Bewertung, durchgeführt Anfang August 2026 und berichtet am 8. August 2026, unter sechs System-Prompts, von denen jeder demselben sauberen Prompt ein Muster hinzufügt, das in für Claude Opus 4.8 und Claude Sonnet 4.6 geschriebenen Prompts häufig vorkommt.
* **Das Diagramm:** Jeder Diagrammpunkt ist einer von drei Fällen (älteres Modell, neueres Modell mit demselben Prompt, neueres Modell nach dem Audit), gemittelt über die sechs Prompts und 44 Tickets.
* **Ergebnisse, Claude Opus 5:** Auf Claude Opus 5 kosteten die für Claude Opus 4.8 geschriebenen Prompts pro Ticket 36 % mehr als auf Claude Opus 4.8, ohne Änderung der Genauigkeit. Nach dem Audit kosteten sie auf Claude Opus 5 14 % weniger als davor (aus den ungerundeten Mittelwerten; die gerundeten Kosten des Diagramms, 3,43 und 2,93 US-Cent pro Ticket, ergeben 14,6 %), und Claude Opus 5 löste 97 % der Tickets korrekt, gegenüber 92 % zuvor. Nach Muster, auf Claude Opus 5: das Entfernen von „zweimal überprüfen“ senkte die Kosten pro Ticket um ein Drittel, und das Entfernen von „maximal gründlich sein“ senkte sie fast ebenso stark; das Entfernen der eingestellten Thinking-Einstellung, der widersprüchlichen Regeln und des selbstgebauten Scratchpads stellte jeweils 7 bis 11 Punkte Genauigkeit wieder her.
* **Ergebnisse, Claude Sonnet 5:** Bei der Migration von Claude Sonnet 4.6 zu Claude Sonnet 5 senkte das Audit die Kosten pro Ticket um 14 % bei gleicher Genauigkeit.
* **Einschränkungen:** Der Genauigkeitsgewinn bei Opus 5 hat ein 95-%-Konfidenzintervall von 3 bis 8 Punkten; die Genauigkeitsunterschiede bei Sonnet liegen innerhalb des Rauschens.
15. **Fragensatz zu Datendateien:** Ein von Anthropic erstellter Satz von 25 Aggregatfragen über einen Ausschnitt von 1.862 Zeilen einer öffentlichen CSV-Datei zu Spirituosenverkäufen, mit durch pandas berechneter Ground Truth und Bewertung nach exakter Übereinstimmung, ausgeführt auf Claude Sonnet 5 und Claude Opus 5 mit deaktiviertem Nachdenken (der In-Context-Zweig kann beim Standard nicht abschließen), einem Ausgabelimit von 4.000 Token und ohne Prompt-Caching, drei Durchläufe pro Konfiguration, durchgeführt am 19. August 2026. Der Datei-Zweig lädt die CSV über die Files API hoch und verwendet das Tool `code_execution_20260120`. Die drei Claude-Sonnet-5-Durchläufe des In-Context-Zweigs beantworteten 6, 7 und 7 der 25 Fragen korrekt; die Beschriftung des Diagramms und der Text geben ihren Mittelwert, 6,67, auf die nächste Frage gerundet an, und der Punkt des Diagramms ist beim Mittelwert, 26,7 %, eingezeichnet.
16. **Messung der Cache-Dauer:**
* **Was gemessen wurde:** Der Triage-Job mit 20 Issues aus [Input- und Kontext-Token kürzen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), ausgeführt auf Claude Sonnet 5 am 23. August 2026 und auf Claude Opus 5.5 am 19. und 20. September 2026, bei seinem Standard-Effort (`medium`) und bei `high`, auf der Messages API mit demselben Harness (für Claude Opus 5.5 eine Portierung davon, die dieselben Request-Bodies sendet), die Claude-Opus-5.5-Zellen mit auf 4.096 erhöhtem `max_tokens`, mit Pausen, die vor einem zufällig gewählten Anteil der Turns eingefügt wurden (keine, 5 %, 10 % und jeder Turn bei 6 Minuten auf allen 20 Issues bei beiden Modellen, plus jeder Turn bei 2 Minuten auf Claude Sonnet 5; Pausen von 20 und 45 Minuten auf einer Teilmenge von 5 Issues bei beiden Modellen). Die Zahlen für Claude Opus 5.5 auf dieser Seite decken beide Effort-Stufen ab.
* **Andere Modelle und Daten:** Die Keep-alive-Zahlen für Claude Opus 5 unten stammen aus demselben Job am 23. August 2026, mit auf 4.096 erhöhtem `max_tokens`, mit denselben Zeitplänen außer den Pausen von 2 und 45 Minuten. Claude Sonnet 5.5 führte dieselbe Messung wie Claude Sonnet 5 durch (dieselben Pausenzeitpläne und drei Cache-Einstellungen, drei Durchläufe pro Zelle), mit dem für Claude Opus 5.5 verwendeten portierten Harness, bei seinem Standard-Effort, `high`, am 24. September 2026.
* **Wie bewertet und bepreist:** Drei Durchläufe pro Zelle, Kosten berechnet aus den `usage`-Feldern jeder Antwort zu Listenpreisen (für Claude Opus 5.5 4 $ Eingabe, 5 $ 5-Minuten-Schreibvorgang, 8 $ 1-Stunden-Schreibvorgang, 0,20 $ Cache-Lesevorgang und 20 $ Ausgabe pro Million Token; Claude Sonnet 5 lief in einer Anthropic-internen Organisation, deren Nutzung auf dieselbe Weise abgerechnet wird wie die einer Kundenorganisation), Genauigkeit gegenüber denselben Gold-Labels.
* **Wie ausgeführt und bepreist, Claude Sonnet 5.5:** Claude Sonnet 5.5 setzte `max_tokens` bei Sitzungsanfragen auf 4.096 und bei Keep-alive-Anfragen auf 1, lief in einer Anthropic-internen Organisation, deren Nutzung auf dieselbe Weise abgerechnet wird wie die einer Kundenorganisation, und wird zu seinen aktuellen Listenpreisen bepreist (2 $ Eingabe, 2,50 $ 5-Minuten-Schreibvorgang, 4 $ 1-Stunden-Schreibvorgang, 0,10 $ Cache-Lesevorgang und 10 $ Ausgabe pro Million Token). Abgesehen vom höheren `max_tokens`, das kein Turn erreichte, unterscheidet sich eine Eingabe von den Claude-Sonnet-5-Durchläufen: das eine animierte GIF des Jobs wurde als PNG seines ersten Frames gesendet, des einzigen Frames, den die API verwendet ([Vision](https://platform.claude.com/docs/de/build-with-claude/vision)), und beide zählen als dieselbe Anzahl an Eingabe-Token.
* **Break-even:** Der Break-even liegt bei etwa 3,3 % der Turns auf Claude Sonnet 5 und bei 3,1 % bis 3,2 % auf Claude Opus 5.5: der Median des Break-even-Anteils jeder Sitzung, vom Kostenmodell aus den Turn-für-Turn-Kontextgrößen dieser Sitzung berechnet, über alle 45 Claude-Sonnet-5-Sitzungen mit zwanzig Issues und die 36 Claude-Opus-5.5-Sitzungen mit zwanzig Issues auf jeder Effort-Stufe (jeder Pausenzeitplan auf dem vollständigen Job ausgeführt, unter allen drei Cache-Einstellungen, je drei Durchläufe; die 5-Issue-Zellen sind nicht enthalten). Der Break-even auf Claude Sonnet 5.5 liegt bei etwa 3,1 % der Turns, der Median über seine 45 Sitzungen mit zwanzig Issues. Das Diagramm zur Cache-Dauer stellt diese Claude-Sonnet-5.5-Sitzungen dar, drei pro Punkt.
* **5-Minuten- und 1-Stunden-Einstellung, Claude Sonnet 5 und Claude Opus 5.5:** In der 5-%-Zelle lagen die 5-Minuten- und die 1-Stunden-Einstellung auf Claude Sonnet 5 gleichauf, weil die Pausen dieser Ziehung auf kleine Präfixe fielen; auf Claude Opus 5.5 lagen sie nahezu gleichauf. Auf Claude Sonnet 5, bei seinem Cache-Lesepreis von 0,20 $ pro Million Token, kostete eine Sitzung mit der 5-Minuten-Einstellung 0,60 $, 0,69 $ und 0,99 $ ohne Pausen, mit 5 % und mit 10 % pausierten Turns, und mit der 1-Stunden-Einstellung 0,70 $, 0,70 $ und 0,71 $.
* **Keep-alive-Anfragen, Claude Sonnet 5 und Claude Opus 5:** Anthropic hat Keep-alive-Anfragen, die den 5-Minuten-Cache auffrischen, auf Claude Sonnet 5 und Claude Opus 5 am 23. August 2026 und auf Claude Opus 5.5 in den obigen Durchläufen gemessen, stets mit `max_tokens: 1` gesendet. Auf Claude Sonnet 5 kosteten sie 7,7 % weniger als die 1-Stunden-Einstellung mit 5 % pausierten Turns und etwa gleich viel mit 10 %; auf Claude Opus 5 war bei keinem der beiden Anteile ein Unterschied messbar; auf beiden kosteten sie mehr mit einer Pause von 6 Minuten oder mehr vor jedem Turn. Auf diesen beiden Modellen ist daher die 1-Stunden-Dauer die zu verwendende Einstellung, nicht Keep-alive-Anfragen.
* **Keep-alive-Anfragen, Claude Opus 5.5:** Auf Claude Opus 5.5 kosteten Keep-alive-Anfragen 8 % bis 18 % weniger als die 1-Stunden-Einstellung mit 5 % und 10 % pausierten Turns (8 % bis 13 % weniger bei seinem Standard-Effort, `medium`, und 10 % bis 18 % weniger bei `high`; etwa 10 % bis 15 %, sobald das Rauschen zwischen Sitzungen entfernt wird, indem die eigenen Token jeder Keep-alive-Sitzung zu 1-Stunden-Cache-Preisen neu abgerechnet werden), und mehr mit einer Pause vor jedem Turn: 4 % bis 6 % mehr bei 6 Minuten, 9 % bis 10 % bei 20 Minuten und 56 % bis 58 % bei 45 Minuten.
* **Anfragen mit `max_tokens: 0`, Claude Opus 5.5:** Anthropics API-Tests vor dem Launch auf Claude Opus 5.5 zeigen, dass eine Anfrage mit `max_tokens: 0` den Cache schreibt und dass die nächste Anfrage ihn liest; ob eine solche Anfrage einen bestehenden Eintrag auffrischt, wurde auf Opus 5.5 nicht gemessen.
* **5-Minuten- und 1-Stunden-Einstellung, Claude Sonnet 5.5:** Mit 5 % pausierten Turns kostete die 5-Minuten-Einstellung im Durchschnitt 5 % mehr als die 1-Stunden-Einstellung (2 % weniger bis 12 % mehr über die drei Durchläufe), was innerhalb der Schwankung zwischen Durchläufen liegt: die Pausen dieser Ziehung fielen auf kleine Präfixe, wie auf Claude Sonnet 5, und die Neuabrechnung der eigenen Token jeder 5-Minuten-Sitzung zu 1-Stunden-Cache-Preisen ergibt etwa 1 % mehr. Mit 10 % pausierten Turns kostete sie 54 % mehr (36 % bis 73 % mehr). Ohne Pausen kostete die 5-Minuten-Einstellung im Durchschnitt 19 % weniger als die 1-Stunden-Einstellung (3 % bis 32 % weniger über die drei Durchläufe; der höhere Schreibpreis der 1-Stunden-Einstellung sagt etwa 20 % voraus) und in jedem Durchlauf mit 2-Minuten-Pausen 21 % bis 24 % weniger.
* **Keep-alive-Anfragen, Claude Sonnet 5.5:** Keep-alive-Anfragen kosteten im Durchschnitt 16 % weniger als die 1-Stunden-Einstellung mit 5 % pausierten Turns (13 % bis 20 % weniger über die drei Durchläufe) und 8 % weniger mit 10 % (3 % bis 10 % weniger), und kosteten mehr mit einer Pause von 6 Minuten oder mehr vor jedem Turn. Mit 5 % und 10 % pausierten Turns dauerten die Pausen auf Claude Sonnet 5.5 und auf Claude Opus 5.5 6 bis 32 Minuten. Die Neuabrechnung der eigenen Token jeder Keep-alive-Sitzung zu 1-Stunden-Cache-Preisen, wie oben für Claude Opus 5.5, ergibt 15 % bis 16 % weniger bei 5 % pausiert und etwa 10 % weniger bei 10 %, und mit einer Pause vor jedem Turn 7 % mehr bei 6 Minuten, 9 % bis 10 % mehr bei 20 Minuten und 66 % bis 73 % mehr bei 45 Minuten. Die 6-Minuten-Zahlen lassen Durchlauf 3 weg, in dem 2 der 39 Keep-alive-Anfragen dieser Sitzung ein Timeout hatten: der Cache lief vor diesen beiden Turns ab, die Sitzung schrieb 214.000 Token in den Cache gegenüber 80.000 bis 85.000 in den Durchläufen 1 und 2, und sie kostete 38 % mehr als die 1-Stunden-Sitzung von Durchlauf 3.
* **Keep-alive-Anfragen, Claude Sonnet 5.5, nach Durchlauf:** Vergleicht man stattdessen die Keep-alive-Sitzung jedes Durchlaufs mit der 1-Stunden-Sitzung desselben Durchlaufs, kostete Keep-alive bei 6 Minuten etwa gleich viel bis 10 % mehr (Durchläufe 1 und 2; im Durchschnitt 4 % mehr), bei 20 Minuten etwa gleich viel bis 16 % mehr und bei 45 Minuten 64 % bis 80 % mehr.
* **Keep-alive-Anfragen, Claude Sonnet 5.5, Stichprobengröße:** Die 6-Minuten-Punkte des Keep-alive-Diagramms mitteln die Durchläufe 1 und 2 für alle drei Einstellungen. Jede Zelle umfasst drei Sitzungen (zwei für die obigen 6-Minuten-Zahlen). Ohne Pausen sendet Keep-alive keine zusätzlichen Anfragen und entspricht daher der 5-Minuten-Einstellung, dennoch unterschieden sich die beiden innerhalb eines einzelnen Durchlaufs um bis zu 23 %, sodass ein Unterschied von wenigen Prozent in einem Mittelwert über drei Durchläufe kein klarer Effekt ist.
* **Caching aus und an, Claude Sonnet 5:** Auf Claude Sonnet 5 wurde derselbe Job mit deaktiviertem und mit aktiviertem Caching ausgeführt, je drei Durchläufe am 19. August 2026, mit `max_tokens` bei 700: 3,36 $ gegenüber 0,57 $ pro Sitzung im Durchschnitt, eine Ersparnis von 83 %.
* **Bepreist aus aufgezeichneten Token-Zahlen, Claude Sonnet 5.5:** Anthropic hat außerdem die aufgezeichneten Token-Zahlen der drei Claude-Sonnet-5.5-Sitzungen mit dem 5-Minuten-Cache und ohne Pausen für die Caching-Zahl in [Warum Caching an erster Stelle steht](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first) neu bepreist; auf Claude Sonnet 5.5 wurde kein Durchlauf mit deaktiviertem Caching durchgeführt. Jede dieser drei Sitzungen ist eine Konversation mit 40 Anfragen über die 20 Issues des Jobs. Zu Listenpreisen mit Stand 12. Oktober 2026 kosteten die Sitzungen im Durchschnitt je 0,51 $, aus den Nutzungsfeldern, gegenüber 3,70 $ mit jedem Eingabe-Token zum Eingabepreis und unveränderten Ausgabe-Token: eine Ersparnis von 86 % (86 % bis 87 % über die drei Sitzungen), oder ein Faktor von 7,3. Zum Einführungspreis für Cache-Lesevorgänge von 0,20 $ beträgt die Ersparnis 82 %, sodass der Anstieg gegenüber der Zahl für Claude Sonnet 5 vom niedrigeren Cache-Lesepreis herrührt.
* **Bepreist aus aufgezeichneten Token-Zahlen, Claude Opus 5.5:** Auf dieselbe Weise neu bepreist, kosteten die drei Claude-Opus-5.5-Sitzungen bei seinem Standard-Effort, `medium`, mit dem 5-Minuten-Cache und ohne Pausen im Durchschnitt je 1,02 $ gegenüber 6,93 $, eine Ersparnis von 85 %, oder ein Faktor von 6,8; Anthropic hat auf Claude Opus 5.5 keinen Durchlauf mit deaktiviertem Caching durchgeführt, und das Modell verwendete Nachdenken in 79 % der Anfragen.
* **Wie Nachdenken eingestellt war, nur zwei Gruppen von Durchläufen:** Die Anfragen der drei Claude-Sonnet-5.5-Sitzungen mit dem 5-Minuten-Cache und ohne Pausen setzten keine Thinking-Option, daher blieb Nachdenken beim Standard des Modells, und das Modell verwendete es in 38 % der Anfragen. Die Anfragen der Claude-Sonnet-5-Durchläufe mit deaktiviertem und mit aktiviertem Caching setzten ebenfalls keine Thinking-Option, daher blieb Nachdenken beim Standard des Modells, und das Modell verwendete es in 41 von 121 Anfragen mit deaktiviertem Caching und in 40 von 120 mit aktiviertem Caching.
* **Latenz nach einer Pause:** Auf Claude Sonnet 5 und Claude Opus 5 behielt der Turn nach einer Pause mit der 1-Stunden-Einstellung seine Latenz bei warmem Cache. Die Zeit bis zum ersten Token nach einer Pause wurde für Claude Opus 5.5 nicht gemessen. Die Zeit bis zum ersten Token nach einer Pause wurde für Claude Sonnet 5.5 nicht gemessen.
17. **Anteil der Cache-Lesevorgänge in der Produktion:** Aggregierte First-Party-Nutzung der Claude API für die 14 Tage bis zum 23. August 2026, nur das direkte API-Produkt, Anthropic-interne Organisationen ausgeschlossen, keine Organisation identifiziert. Ein Organisationstag zählt als Agent-Schleife, wenn seine Anfragen Tool-Definitionen und Tool-Ergebnisse enthalten, seine Prompts im Durchschnitt 9 oder mehr vorherige Tool-Aufrufe enthalten, Caching verwendet wurde und er mindestens 10 solcher Anfragen stellte (die API hat keine Konversationskennung, daher steht dies stellvertretend für die Konversationslänge): 303.003 Organisationstage über 106.487 Organisationen, medianer Anteil der Cache-Lesevorgänge 84,2 % aller Eingabe-Token, oberes Quartil 91,7 %. Anwendungsfall-Labels (der angegebene Anwendungsfall der Organisation oder andernfalls ihr klassifizierter) decken 74 % dieser Organisationstage und 99 % ihrer Token ab; etwa 72 % der Coding-Organisationstage lesen 80 % oder mehr. Das oberste Dezil der Organisationstage liest 95,9 % oder mehr bei Coding und 94,2 % bis 94,8 % bei Support-, Recherche-, Daten- und anderen Agenten. Die Aufteilung auf Anfrageebene bei 25 oder mehr vorherigen Tool-Aufrufen stammt aus einer sechsstündigen Stichprobe: Coding 92 % gelesen, 7 % geschrieben, unter 1 % ungecacht.
18. **Messungen zum Compaction-Zeitpunkt und zur Statuszeile:**
* **Was gemessen wurde:** Die lange Variante des Triage-Agenten aus [Input- und Kontext-Token kürzen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), ausgeführt am 24. August 2026 auf Claude Sonnet 5 mit dem 5-Minuten-Cache, Kosten aus den Nutzungsfeldern zu Listenpreisen, fünf Sitzungen pro Zweig: ein Zweig ohne Änderung durchgehend beim Standard-Effort (0,81 $ pro Sitzung) und zwei Zweige, die mit niedrigem Effort beginnen und dieselben zwei cache-brechenden Änderungen vornehmen, einen Wechsel zum Standard-Effort und ein hinzugefügtes Tool, entweder mitten in der Sitzung bei den Anfragen 12 und 17 (0,95 $) oder zusammen bei der ersten Anfrage nach der ersten Compaction (0,75 $).
* **Vierter Zweig:** Ein vierter Zweig mit sechs Sitzungen, ausgeführt am 25. August 2026, nahm dieselben zwei Änderungen bei der Anfrage vor, die die erste Compaction auslöste (0,92 $ pro Sitzung): der Zusammenfassungsdurchgang dieser Anfrage schrieb den Kontext von 81.000 Token in den Cache, statt ihn zu lesen, sodass dieser Durchgang 0,21 $ kostete gegenüber 0,04 $ für denselben Durchgang im Grenz-Zweig.
* **Compaction:** Die Sitzungen führten die erste Compaction bei Anfrage 21 bis 25 durch (16 der 21 Sitzungen bei Anfrage 22), sobald der Prompt den Compaction-Auslöser von 80.000 Token überschritt, und zwei Sitzungen ohne Änderung führten gegen Ende eine zweite Compaction durch. Die niedrigere Gesamtsumme des Grenz-Zweigs gegenüber dem Zweig ohne Änderung spiegelt seine Anfragen mit niedrigem Effort vor der Änderung und diese zweiten Compactions wider, nicht das Caching: die Kosten für erneutes Schreiben der beiden Zweige unterscheiden sich um weniger als 0,01 $.
* **Zweig mitten in der Sitzung:** Der Zweig mitten in der Sitzung zahlte 0,23 $ pro Sitzung für erneutes Schreiben in den Cache; der Unterschied zwischen dem Zweig mitten in der Sitzung und dem Grenz-Zweig betrug 0,20 $ mit einem 95-%-Konfidenzintervall von 0,11 $ bis 0,29 $. Im Zweig mitten in der Sitzung schrieben die Effort-Änderung und das hinzugefügte Tool 39.000 bzw. 60.000 gecachte Token neu. Eine seiner Sitzungen lief günstig (0,82 $), nachdem ihr Modell das Such-Tool nach der Compaction falsch aufrief und leere Ergebnisse erhielt; sie ist enthalten, und ohne sie liegt der Zweig im Durchschnitt bei 0,98 $.
* **Genauigkeit und Cache-Lesevorgänge:** Die Genauigkeit lag im Durchschnitt bei 14,2 von 20 Labels in jedem Zweig vom 24. August und bei 14,7 im Zweig vom 25. August; Cache-Lesevorgänge machten 91 % der Prompt-Token ohne Änderungen aus, 85 % mitten in der Sitzung, 91 % an der Grenze und 86 % mit den Änderungen bei der auslösenden Anfrage.
* **Separate Messung, Statuszeile:** Eine separate Messung am Triage-Job mit 20 Issues aus [Input- und Kontext-Token kürzen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), ausgeführt am 18. August 2026, ebenfalls auf Claude Sonnet 5 mit dem 5-Minuten-Cache, auf dieselbe Weise bepreist, drei Durchläufe pro Zweig: mit einer Statuszeile von 25 Token am Anfang des System-Prompts kostete ein Durchlauf im Durchschnitt 4,24 $ (4,12 $ bis 4,47 $ über die drei Durchläufe) und las nichts aus dem Cache; mit derselben Zeile am Ende des neuesten User-Turns, nach dem letzten Cache-Breakpoint, kostete ein Durchlauf 0,59 $ (0,55 $ bis 0,61 $). Ersteres ist mehr, als derselbe Job mit deaktiviertem Caching kostete. Eine spätere erneute Ausführung mit derselben Konfiguration ergab 4,28 $ und 0,61 $.
19. **Messung der Cache-Dauer auf Claude Fable 5.1:** Derselbe Triage-Job mit 20 Issues und dasselbe Harness wie in Referenz 16, mit auf 4.096 erhöhtem `max_tokens`, ausgeführt am 23. und 26. August 2026 auf dem Launch-Snapshot von Claude Fable 5.1 zu seinen Einführungspreisen (10 $ Eingabe, 12,50 $ 5-Minuten-Schreibvorgang, 20 $ 1-Stunden-Schreibvorgang, 0,25 $ Cache-Lesevorgang, 50 $ Ausgabe pro Million Token), drei Einstellungen pro Zeitplan: der 5-Minuten-Cache, der 1-Stunden-Cache und der 5-Minuten-Cache, warm gehalten durch eine Anfrage mit `max_tokens: 0` auf dem unveränderten Präfix alle 4 Minuten, gemessen ab dem Start der vorherigen Anfrage (die Durchläufe vom 23. August sendeten Keep-alive-Anfragen mit `max_tokens: 1`; in den hier berichteten Zellen vom 26. August frischte jede beantwortete Keep-alive-Anfrage den Cache auf, und ihre Antwort meldete keine Ausgabe-Token). Zeitpläne: keine Pausen, 10 % der Turns und jeder Turn bei 6 Minuten auf allen 20 Issues, und 45-Minuten-Pausen auf der 5-Issue-Teilmenge; drei Durchläufe pro Zelle (sechs für die Keep-alive-Zelle vom 26. August mit 45-Minuten-Pausen), Kosten berechnet aus den `usage`-Feldern jeder Antwort zu Listenpreisen, Genauigkeit gegenüber denselben Gold-Labels (12 bis 18 exakte Labels von 20). Mittelwerte pro Sitzung am 26. August für die 5-Minuten-, 1-Stunden- und Keep-alive-Einstellung: keine Pausen 2,42 $, 3,09 $, 2,29 $; 10 % pausiert 4,50 $, 2,96 $, 2,36 $; jeder Turn 22,89 $, 3,01 $, 2,62 $; die Zellen vom 23. August stimmen innerhalb von 6 % überein. Die 45-Minuten-Zahlen (1,68 $, 0,59 $ und 0,71 $ pro 5-Issue-Sitzung) stammen aus späteren Sitzungen vom 26. August: die erste Gruppe von Sitzungen dieses Tages wurde abgebrochen, als ihre Maschine heruntergefahren wurde, und die zweite war von einem Fehler im Dienst betroffen und wird beiseitegelassen. Die dritte Gruppe liefert die 5-Minuten- und 1-Stunden-Zahlen; ihre drei Keep-alive-Sitzungen sendeten jede Keep-alive-Anfrage einmal, verloren Anfragen durch Verweigerungen aufgrund des „rate limit" (Ratenlimit) und sind nicht im Mittelwert enthalten. Die Keep-alive-Zahl ist der Mittelwert von sechs weiteren Sitzungen, die jede verweigerte Keep-alive-Anfrage innerhalb von zwei Sekunden erneut sendeten. Die Durchläufe vom 23. August ergaben 1,67 $, 0,58 $ und 0,70 $. Der Break-even zwischen der 5-Minuten- und der 1-Stunden-Einstellung liegt bei 3,1 % der Turns, dasselbe Maß wie in Referenz 16. Der Cache-Lesevorgang von Claude Fable 5.1 kostet das 0,025-Fache des Eingabepreises, während seine Cache-Schreibvorgänge die Standardmultiplikatoren behalten, sodass eine Keep-alive-Anfrage, die das Präfix erneut liest, günstig ist und der Schreibaufschlag der 1-Stunden-Dauer die größere Rechnung ist, außer bei 45-Minuten-Pausen, wo die Keep-alive-Anfragen mehr kosten als der Aufschlag.
20. **Terminal-Bench 3:** die 74 Aufgaben des öffentlichen Terminal-Agenten-Benchmarks, ausgeführt auf [Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview) mit zwei benutzerdefinierten Tools, einer Shell und einem Dateieditor, die das Evaluations-Harness im eigenen Container jeder Aufgabe ausführt, anstelle der integrierten Tools der Plattform, und ansonsten mit den Standardeinstellungen der Plattform für externe Konten, zwei Durchläufe pro Modell mit `high`-Effort, 27. bis 28. August 2026. Diese Durchläufe verwendeten Terminal-Bench Version 3.0, und ihre Werte sind nicht mit dem öffentlichen Terminal-Bench-Leaderboard oder mit den Terminal-Bench-4.0-Ergebnissen in der System Card von Claude Opus 5.5 vergleichbar, die aus Durchläufen in Claude Code mit `max`-Effort stammen. Die Zeitlimits jeder Aufgabe betragen das 2,5-Fache der eigenen Limits des Benchmarks, was dem Agenten zwischen 75 Minuten und 20 Stunden pro Aufgabe gibt (5 Stunden für die mediane Aufgabe), und jede Aufgabe erhält das Dreifache des von ihr angegebenen Speichers, von 6 GiB bis 96 GiB, mit zusätzlichem Speicher für die 12 Aufgaben, die Hilfsdienste ausführen. Der Agent hatte keinen allgemeinen Internetzugang: seine Container konnten einen internen Paket-Mirror erreichen, eine kurze Liste von Download-Seiten einschließlich GitHub und des Python Package Index sowie einige für bestimmte Aufgaben spezifische Seiten, und acht der Aufgaben hatten überhaupt keinen Netzwerkzugriff. Die Werte sind rohe Erfolgsquoten über die 148 Versuche pro Modell; einzelne Durchläufe schwanken um 5 bis 11 Punkte. Die Kosten sind das, was einem Kunden zu Listenpreisen in Rechnung gestellt würde, Anfrage für Anfrage aus den Nutzungsdaten der Durchläufe mit der 5-Minuten-Cache-Lebensdauer neu bepreist. Claude Opus 4.7, Claude Opus 4.8 und Claude Opus 5 geben jeweils 8 $ bis 15 $ pro Aufgabe aus. Claude Opus 4.7 beendete 11 seiner 148 Versuche an seinem Ausgabelimit.
21. **DRACO:** Perplexity, "DRACO: a Cross-Domain Benchmark for Deep Research Accuracy, Completeness, and Objectivity," arXiv:2602.11685, 2026.
* **Was gemessen wurde:** Seine 100 Rechercheaufgaben über 10 Domänen werden anhand von Experten geschriebener Rubriken mit jeweils etwa 40 gewichteten Kriterien bewertet, und der Wert ist der gewichtete Anteil erfüllter Kriterien, von 0 bis 100.
* **Konfigurationen:** Jede Konfiguration lief auf der Claude API mit Claude Opus 5.5, dem standardmäßigen adaptiven Nachdenken, aktivierten Produktions-Sicherheitsklassifikatoren und `max_tokens` bei 128.000 mit Streaming: ein einzelner Agent mit `medium`-Effort (dem Standard des Modells) und bei `low`, der einzelne Agent bei `medium` mit dem Satz und der Uhr, und ein Team bei `medium` mit und ohne sie. Das Team ist ein Lead-Agent, der über ein Tool Hilfsagenten desselben Modells starten kann, ohne Obergrenze für ihre Anzahl.
* **Der Satz:** Die zwei Änderungen sind ein Satz und eine Uhr. Der Satz, "Time matters here: do not spend time that can be avoided, and the earlier a correct result is obtained, the better.", steht am Ende der Aufgabe in der ersten `user`-Nachricht des Agenten, nach einer Leerzeile, und am Ende des Briefings jedes Helfers.
* **Die Uhr:** Die Uhr ist die verstrichene Zeit in ganzen Sekunden, etwa `[elapsed 252s]`, die vor jeder Anfrage, einschließlich der ersten, am Ende der neuesten `user`-Nachricht hinzugefügt wird: in einem eigenen Textblock nach der Aufgabe bei der ersten Anfrage und am Ende des Texts des letzten Tool-Ergebnisses, nach einer Leerzeile, wenn die Nachricht Tool-Ergebnisse enthält. Frühere Uhren bleiben an ihrem Platz, sodass das gecachte Präfix bei der nächsten Anfrage weiterhin übereinstimmt. Jeder Agent in einem Team liest dieselbe Uhr, und der System-Prompt ändert sich nicht.
* **In den gemessenen Durchläufen:** Die gemessenen Durchläufe verwendeten diesen Wortlaut und dieses Format. Ihre Uhr startete beim ersten Token der ersten Antwort statt beim Start der Aufgabe. In den gemessenen Team-Durchläufen erreichte der Bericht eines Helfers den Lead in einer separaten Nachricht nach der Uhr, nicht innerhalb des letzten Tool-Ergebnisses.
* **Wann:** Jede Konfiguration unternahm drei Versuche bei jeder Aufgabe, mit einem Limit von vier Stunden pro Versuch, durchgeführt am 24. September 2026, und alle Konfigurationen einer Gruppe starteten gemeinsam.
* **Tools:** Die Agenten verwendeten Such- und Abruf-Tools, die das Evaluations-Harness über einem Anthropic-Webindex hostet, sowie Python und eine Shell in einer Sandbox ohne Netzwerkzugriff. Diese Tools bestimmen einen Teil der Zeit, und deine werden mit einer anderen Geschwindigkeit laufen, daher gibt die Seite Zeit als Verhältnis zwischen Konfigurationen an, nicht in Minuten.
* **Wie gemessen:** Die Zeit ist die Wall-Clock-Zeit eines Versuchs, von seiner ersten Anfrage bis zum Ende der letzten Anfrage eines beliebigen Agenten, einschließlich Tool-Ausführungen, gemittelt über die Versuche einer Aufgabe. Eine Zahl für die typische Aufgabe ist der Median, über die Aufgaben, des Verhältnisses jeder Aufgabe zwischen zwei Konfigurationen.
* **Wie bepreist:** Die Kosten jeder Aufgabe sind ihre Anfragen, bepreist zu den öffentlichen Listenpreisen von Claude Opus 5.5, wobei Prompt-Caching so abgerechnet wird, wie es für einen Kunden der Fall wäre, der am Ende jeder Anfrage einen Cache-Breakpoint setzt und die 5-Minuten-Cache-Lebensdauer verwendet. Jede Anfrage liest den Prompt der vorherigen Anfrage aus dem Cache und schreibt den Rest. Die erste Anfrage eines Versuchs und jede Anfrage, die mehr als 5 Minuten nach der vorherigen startet, schreibt ihren gesamten Prompt. Die Kosten decken nur Modell-Token ab; die Tools des Harness verursachen keine Gebühren.
* **Wie bewertet:** Alle Intervalle sind 95-%-Bootstrap-Intervalle über Aufgaben, und Wertänderungen sind gepaarte Differenzen über Aufgaben. Claude Opus 5 bewertet die Antworten, sodass Claude Opus 5.5 seine eigene Arbeit nicht bewertet, und der Wert jeder Antwort mittelt fünf Bewertungsdurchläufe.
* **Einschränkungen:** Ein Produktions-Sicherheitsklassifikator stoppte in jeder Konfiguration drei Versuche, alle bei einer Aufgabe, und diese Versuche erhalten 0 Punkte; das Weglassen dieser Aufgabe ändert keinen Befund. Die Durchläufe leiteten außerdem die Tool-Nutzung jedes Agenten durch eine Anthropic-interne Sicherheitsprüfung, die Kundenanfragen nicht haben, was jeder Anfrage in jeder Konfiguration eine nicht gemessene Zeitspanne hinzufügt. Auf DRACO stellte der einzelne Agent ohne die Änderungen etwa doppelt so viele Anfragen und das Team etwa ein Drittel mehr, daher lässt die Prüfung die Zeitersparnisse bei DRACO wahrscheinlich etwas größer erscheinen.
* **Ergebnisse, einzelner Agent:** Ergebnisse für [Dem Modell die verstrichene Zeit zeigen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time): mit den Änderungen benötigte der einzelne Agent bei der typischen Aufgabe 47 % weniger Zeit bei 60 % niedrigeren Kosten, seine durchschnittlichen Kosten sanken von 1,13 $ auf 0,44 $ pro Aufgabe, und sein Wert lag 4,1 Punkte niedriger (95-%-Intervall 2,9 bis 5,2 niedriger).
* **Ergebnisse, niedrigerer Effort:** Das Senken des Effort des einzelnen Agenten sparte mehr Zeit und Kosten als die Änderungen und verlor mehr Punkte. Mit `low`-Effort erzielte er auf DRACO 13,3 Punkte weniger, auf HLE 3,4 und auf dem Physik-Satz 14,0 als bei `medium`, und die typische Aufgabe benötigte 84 %, 30 % und 47 % weniger Zeit. Mit den Änderungen bei `medium`-Effort erzielte er 9,2, 2,5 und 11,0 Punkte mehr als bei `low`, und die typische Aufgabe dauerte um einen Faktor von 1,2 bis 3,2 länger als bei `low`.
* **Ergebnisse, Team, Helfer:** Der Lead des Teams startete selten Helfer. Ohne die Änderungen startete er einen Helfer in nur 5 von 300 Versuchen auf DRACO, 13 von 1.479 auf HLE und keinem von 280 auf dem Physik-Satz.
* **Ergebnisse, Team:** Die Team-Ergebnisse zeigen also größtenteils den Lead-Agenten, der allein arbeitet, mit den eigenen Anweisungen und Tools des Teams, und Anthropic hat keine Messung der Änderungen an einem Team, das parallel arbeitet. Ohne die Änderungen benötigte das Team bei der typischen DRACO-Aufgabe bereits etwa die Hälfte der Zeit des einzelnen Agenten und erzielte 3,3 Punkte weniger (95-%-Intervall 2,1 bis 4,6 niedriger). Mit den Änderungen benötigte das Team bei der typischen DRACO-Aufgabe 17 % weniger Zeit bei 20 % niedrigeren Kosten und erzielte 1,6 Punkte weniger (95-%-Intervall 0,3 bis 2,8 niedriger).
* **Nicht gemessen:** Anthropic hat die Änderungen auf Claude Managed Agents nicht gemessen.
22. **HLE:** Phan et al., "Humanity's Last Exam," arXiv:2501.14249, 2025. Von Experten geschriebene Fragen mit exakten Antworten, bewertet anhand der Referenzantworten. Gemessen auf den ersten 500 Fragen der Veröffentlichung vom 10. September 2025, einschließlich Bildern, mit für die Suche gesperrten eigenen Quellen des Benchmarks und demselben Setup wie in Referenz 21. Jede Konfiguration unternahm drei Versuche bei jeder Frage, durchgeführt am 24. September 2026. Claude Opus 5 vergleicht jede Antwort mit der Referenzantwort unter Verwendung des veröffentlichten Bewerter-Prompts des Benchmarks, und die Mehrheit von drei Bewertungen zählt. Die Werte decken in jeder Konfiguration 493 Fragen ab. Bei fünf der übrigen lag die Bewertungsanfrage über dem Limit des Bewerters von 1M Token, und die anderen zwei werden weggelassen, weil der Durchlauf des einzelnen Agenten ohne die Änderungen stoppte, bevor drei seiner Versuche bei ihnen abgeschlossen waren. Zeit- und Kostenverhältnisse decken 492 Fragen für den einzelnen Agenten und 491 für das Team ab, weil für eine oder zwei Fragen keine Zeitmessung vorliegt. Ein Produktions-Sicherheitsklassifikator stoppte 3 % bis 4 % der Versuche jeder Konfiguration, und diese Versuche erhalten 0 Punkte; ihr Weglassen ändert keinen Befund. Ergebnisse für [Dem Modell die verstrichene Zeit zeigen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time): mit den Änderungen benötigte der einzelne Agent bei der typischen Frage 14 % weniger Zeit bei 9 % niedrigeren Kosten. Mit dem Claude-Opus-5-Bewerter zeigte sein Wert keine klare Änderung (0,9 Punkte niedriger, 95-%-Intervall 2,5 niedriger bis 0,7 höher). Mit einem zweiten Bewerter, Claude Opus 4.6, lag sein Wert 1,9 Punkte niedriger (95-%-Intervall 0,2 bis 3,7 niedriger). Die durchschnittliche Zeit sank stärker als die der typischen Frage: die durchschnittliche Zeit sank um 43 % und die durchschnittlichen Kosten um 37 %, weil die Änderungen einige sehr lange Fragen verkürzten. Die Zeit des Teams bei der typischen Frage änderte sich um 3 % oder weniger, und sein Wert änderte sich nicht klar.
23. **Physik-Satz:** Ein interner Satz von 70 Physikproblemen auf Forschungsniveau, adaptiert aus dem öffentlichen CritPt-Benchmark: Zhu et al., "Probing the Critical Point (CritPt) of AI Reasoning: a Frontier Physics Research Benchmark," arXiv:2509.26574, 2025. Fachgutachter korrigierten die Problemstellungen. Claude Opus 4.6 bewertet jede Antwort mit Teilpunkten unter Verwendung des Bewertungs-Prompts des Satzes anhand von nicht öffentlichen Referenzlösungen von Experten, daher können die Werte nicht mit veröffentlichten Ergebnissen verglichen werden. Der Wert ist die mittlere Bewertung über die Versuche eines Problems, gemittelt über die Probleme, in Punkten von 100. Gemessen auf allen 70 Problemen, vier Versuche pro Problem, durchgeführt am 24. September 2026. Jeder Agent hatte ein Python-Tool, eine Shell und einen Dateieditor in einem Sandbox-Container ohne Netzwerkzugriff und keine Such- oder Abruf-Tools. Kein Sicherheitsklassifikator stoppte einen Versuch auf dem Physik-Satz. Ansonsten entspricht das Setup dem von Referenz 21. Ergebnisse für [Dem Modell die verstrichene Zeit zeigen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time): mit den Änderungen benötigte der einzelne Agent beim typischen Problem 7 % weniger Zeit bei 4 % niedrigeren Kosten, und sein Wert lag 3,0 Punkte niedriger (95-%-Intervall 0,4 bis 5,6 niedriger). Die Zeit des Teams beim typischen Problem änderte sich um 3 % oder weniger, und sein Wert änderte sich nicht klar. Die durchschnittliche Zeit des einzelnen Agenten sank um 14 %. Die gesamte durchschnittliche Zeitersparnis des einzelnen Agenten stammt von einem Problem, bei dem der Agent ohne die Änderungen pro Versuch etwa eine halbe Stunde lang Code ausführte; ohne dieses Problem ist seine durchschnittliche Zeit mit und ohne die Änderungen etwa gleich.
24. **tau2-bench retail:** Barres et al., "τ²-Bench: Evaluating Conversational Agents in a Dual-Control Environment," arXiv:2506.07982, 2025.
* **Was gemessen wurde:** Die 114 Aufgaben der Retail-Domäne liefen auf dem öffentlichen Harness gegen die Claude API, mit Claude Haiku 4.5 als simuliertem Benutzer, Claude Sonnet 5 als Bewerter für natürliche Sprache und aktiviertem Prompt-Caching; die Aufgaben wurden in 57 für die Suche und 57 zurückgehaltene aufgeteilt.
* **Wann:** Die zwei Suchen liefen am 6. September 2026, gesteuert durch den Befehl `hillclimb` des Claude API Skills. Das Vorher-Nachher-Paar zum Caching lief am 8. September 2026.
* **Wie bewertet:** In den Suchen sind die Startpunkte und die bestätigte Konfiguration der Mittelwert von drei zurückgehaltenen Durchläufen, beibehaltene Schritte wurden anhand von zwei Durchläufen beurteilt, und andere Kandidaten wurden anhand von einem oder zwei Durchläufen bewertet. Das Caching-Paar: je drei Durchläufe auf allen 114 Aufgaben, wobei nur die Cache-Breakpoints des Harness umgeschaltet wurden, die Konfiguration, die der Befehl `cost-optimize` in einem früheren Durchlauf erzeugt hatte. Zurückgehaltene Zahlen beziehen sich auf 57 Aufgaben, die die Suche nie gelesen hat.
* **Wie bepreist:** Die Kosten pro Aufgabe bepreisen die Token-Zahlen des Agenten und des simulierten Benutzers zu Listenpreisen (Claude Opus 5 5 $ und 25 $, Claude Sonnet 5 2 $ und 10 $ pro Million Eingabe- und Ausgabe-Token, Cache-Lese- und -Schreibvorgänge zu ihren veröffentlichten Sätzen) und schließen den Bewerter aus; prozentuale Änderungen stammen aus ungerundeten Kosten; die monatliche Zahl sind allein die Token des Agenten, 0,135 $ und 0,047 $ pro Aufgabe, mal 10.000. Bei 10.000 Konversationen pro Monat sind das etwa 1.350 $ vor der ersten Suche und 470 $ danach.
* **Einschränkungen:** Diese Messungen liefen auf den vorherigen Claude-Opus- und Claude-Sonnet-Modellen: das Caching-Paar lief auf Claude Sonnet 5, die zweite Suche startete von Claude Sonnet 5, und die erste Suche ging von Claude Opus 5 zu Claude Sonnet 5. Claude Fable 5.1 wurde auf diesem Benchmark nicht gemessen.
* **Caching-Paar:** Das Paar lief auf Claude Sonnet 5 beim Standard-Effort. Das öffentliche Harness sendet im Auslieferungszustand bei jedem Turn die gesamte Konversation ungecacht. Die gecachte Konfiguration hat einen Breakpoint auf dem System-Prompt und einen auf der neuesten Nachricht. Beide Suchen liefen mit diesem aktivierten Caching. Die Kosten pro Aufgabe gingen von 0,223 $ ungecacht auf 0,062 $ gecacht, eine Ersparnis von 72 %, und die Erfolgsquote von 79,2 % auf 76,0 %. Identische gecachte Durchläufe dieser Konfiguration reichten über verschiedene Tage von 85 bis 93 von 114. Jeder gecachte Durchlauf erzielte höchstens so viel wie jeder ungecachte Durchlauf, aber die Lücke von weniger als 4 Aufgaben liegt innerhalb der Streuung identischer gecachter Durchläufe, daher ist die Genauigkeitsänderung bei dieser Stichprobengröße zu klein, um sie zu messen.
* **Wie die Suche ablief.** Der Befehl `hillclimb` stellt vier Fragen, legt einen Plan vor und wartet auf Zustimmung, bevor er etwas ausgibt. In der ersten Suche ließ der Plan den Benutzersimulator, den Bewerter, das Caching, die Temperatur und die Aufgaben unverändert. Die letzte der vier Fragen begann mit: `One pass over the full set is 114 cases x 1 rep on claude-opus-5, roughly 22 minutes.` In jeder Runde schlägt die Suche eine Änderung vor und führt den vollständigen Satz aus. Sie behält die Änderung nur, wenn sich die Zahl bewegt hat und der vorhergesagte Mechanismus in den Nutzungsdaten sichtbar ist. Sie stoppt, wenn drei Runden in Folge nichts bringen, und bestätigt dann den Gewinner in neuen Durchläufen.
* **Erste Suche, Ergebnis.** Die Suche senkte die Kosten pro Aufgabe um 61 %, während sie die Erfolgsquote innerhalb eines vor der Suche festgelegten Bands von 2 Punkten hielt: von Claude Opus 5 beim Standard-Effort (0,142 $ pro Aufgabe, 76,0 % bestanden) zu Claude Sonnet 5 bei `low` mit einer kostenneutralen Prompt-Änderung (0,055 $, 74,3 %). Die Suche kostete 179 $ an Evaluationsdurchläufen und 228 $ an eigenen Token.
* **Erste Suche, Start: Claude Opus 5, Standard-Effort.** 76,0 % bei 0,142 $. Drei identische Durchläufe reichten von 43 bis 44 von 57. Die Suche setzte die Untergrenze 2 Punkte darunter, bei 74,0 %, und rundete sie für ihre Urteile auf 43 von 57 (75,4 %) auf.
* **Erste Suche, Schritt 1, Effort auf `low`: beibehalten.** 77,2 % in den zwei Durchläufen, die ihn beibehielten, 77,8 % in einer Bestätigung mit drei Durchläufen nach der Suche, bei 0,119 $, 17 % günstiger. Die eigene Statuszeile der Suche lautet teilweise: `two runs held-out 42 and 46, mean 44.0 >= floor 43; cost mean $0.1187 <= gate $0.1208; mechanism confirmed (output tokens -34% with calls flat)`.
* **Erste Suche, Schritt 2, Claude Sonnet 5 bei `low`: beibehalten.** 75,4 % bei 0,055 $, 61 % günstiger.
* **Erste Suche, Schritt 3, eine Prompt-Änderung (die Bestellungen des Kunden nach dem Login nachschlagen, statt nach einer Bestellnummer zu fragen): bei der Auswahl beibehalten, dann nicht gehalten.** 79,8 % in zwei Durchläufen; 74,3 % in drei neuen Durchläufen. Die Suche ließ sie als kostenneutral drin: der freigewordene Turn wurde zu einem weiteren Nachschlage-Turn.
* **Erste Suche, Schritt 4, eine Prompt-Änderung (nur auf Anfrage an einen Menschen übergeben): abgelehnt und rückgängig gemacht.** 71,9 %. Sie behob die 3 Fälle, auf die sie abzielte, und brach 10 andere mit einer generischen Vorlage „sag, was du tun kannst und was nicht“.
* **Erste Suche, Schritt 5, eine Prompt-Änderung: nicht ausgeführt.** Ihr vorhergesagter Gewinn von 0,5 Aufgaben lag unter der Übernahmeschwelle der Suche von 2 Aufgaben.
* **Erste Suche, Bestätigung: Claude Sonnet 5 bei `low` mit dem Prompt aus Schritt 3, drei neue Durchläufe.** 74,3 % bei 0,055 $, innerhalb des 2-Punkte-Bands um 0,14 einer Aufgabe, 1 Aufgabe von 57 unter dem Start und unter der von der Suche registrierten Untergrenze von 43 von 57. Die fünf Durchläufe dieser Konfiguration reichten von 42 bis 46, breiter als die 43 bis 44 des Starts.
* **Erste Suche, was sie zeigte.** Die Hebel Effort und Modell erzeugten die Ersparnisse, und der Mechanismus jedes einzelnen bestätigte sie. Der Prompt-Hebel erzeugte echte Verhaltensänderungen, aber keinen dauerhaften Gewinn. Bei diesem Workload bestimmen die Anzahl der Turns und das gecachte Präfix, das jeder Turn erneut liest, die Kosten pro Aufgabe, nicht der Wortlaut.
* **Zweite Suche.** Sie startete von Claude Sonnet 5 beim Standard-Effort mit aktiviertem Caching: 79,5 % bei 0,062 $ auf der zurückgehaltenen Hälfte, mit drei Durchläufen von 42 bis 47 von 57, sodass die Untergrenze bei 45 von 57 (78,9 %) lag. Identische Durchläufe einer Startkonfiguration unterschieden sich hier um bis zu 5 Aufgaben von 57. Die zweite Suche behielt nichts bei. Effort bei `low`, zwei Prompt-Änderungen und beides zusammen erzielten jeweils 77,2 %, unter der Untergrenze, und sparten 10 % bis 14 %, knapp unter der Kostenschwelle der Suche von 15 %. Eine Prompt-Änderung für Genauigkeit erzielte 79,8 % in zwei Durchläufen und 73,7 % in drei neuen Durchläufen und wurde rückgängig gemacht. Die Suche benötigte etwa 19 Evaluationsdurchläufe und 120 $.
25. **Aufgabenset für Claude Managed Agents:**
* **Was gemessen wurde:** Ein Anthropic-interner Satz von 79 geskripteten Agentenaufgaben in acht Bereichen, darunter Memory-, Multiagenten- und Long-Context-Arbeit, ausgeführt als [Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview)-Sitzungen, in denen der Test jeden Tool-Aufruf beantwortet. Jede Aufgabe lief fünfmal pro Modell.
* **Durchläufe:** Die Zahlen stammen aus einem Durchlauf pro Modell am 7. Oktober 2026, am selben Tag bewertet. In drei weiteren Durchläufen derselben Aufgaben am 8. und 9. Oktober 2026 bestand Claude Haiku 5.5 91 % bis 93 % der Versuche, und in einem weiteren Durchlauf am 8. Oktober bestand Claude Haiku 4.5 63 %.
* **Wie bewertet:** Ein Versuch bestand nur, wenn der Bewerter, Claude Sonnet 4.6, bei einmaliger Bewertung jede Zeile der Checkliste der Aufgabe als erfüllt markierte, daher hängen die Erfolgsquoten vom Bewerter ab. Bei allen Aufgaben außer einer bewertete ein separater Aufruf, dem die Tool-Ergebnisse vollständig gezeigt wurden, die Zeile, die die vom Agenten über seine Tools geschriebenen Dateien und Nachrichten prüft, anhand dieser Ergebnisse.
* **Wie bepreist:** Die Kosten sind Token-Kosten zu Listenpreisen mit 5-Minuten-Prompt-Caching, Anfrage für Anfrage bepreist, und schließen die Sitzungslaufzeit aus.
* **Ergebnisse, Token-Preise und Kosten:** Claude Haiku 4.5 cachte 80 % seiner Anfragen nicht: jede hatte einen Prompt von etwa 4.100 Token oder weniger, und seine minimale cachebare Prompt-Länge beträgt 4.096 Token (512 für Claude Haiku 5.5). Von Claude Haiku 4.5 zu Claude Haiku 5.5 sanken die Token-Preise um bis zu 90 %, und die Token-Kosten der 79 Aufgaben sanken um etwa 75 %. Die Token-Kosten sanken weniger als die Preise, weil etwa 5 % der Anfragen von Claude Haiku 5.5 Prompts über 100.000 Token hatten, die höhere Preise zahlen ([Preise für langen Kontext](https://platform.claude.com/docs/de/about-claude/pricing#long-context-pricing)), und diese trugen 73 % seiner Kosten.
* **Nachdenken:** Anthropic setzte den Effort von Claude Haiku 5.5 auf `medium` und sendete für keines der beiden Modelle eine Thinking-Einstellung oder ein Ausgabelimit, daher blieb Nachdenken den eigenen Einstellungen von Claude Managed Agents für jedes Modell überlassen. Claude Haiku 5.5 verwendete Nachdenken in 59 % der Anfragen und Claude Haiku 4.5 in 22 %. Der Vergleich betrifft jedes Modell so, wie es bereitgestellt wird, nicht bei gleichen Einstellungen.
* **Kosten ohne Caching, bepreist aus aufgezeichneten Token-Zahlen:** Anthropic hat außerdem die aufgezeichneten Token-Zahlen des Durchlaufs von Claude Haiku 5.5 vom 7. Oktober für den Caching-Faktor in [Warum Caching an erster Stelle steht](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first) neu bepreist; es wurde kein Durchlauf mit deaktiviertem Caching durchgeführt, und Claude Managed Agents wendet Prompt-Caching selbst an, daher vergleicht der Faktor zwei Preise für dieselben Anfragen, nicht zwei Einstellungen.
* **Der Faktor:** Der Faktor, 1,7, sind die Token-Kosten des Durchlaufs mit jedem Eingabe-Token zum Eingabepreis, Ausgabe-Token unverändert, geteilt durch seine Token-Kosten, wobei jede Sitzung für sich bepreist wird: der vorherige Prompt jeder Anfrage als Cache-Lesevorgang und ihre neuen Token als 5-Minuten-Cache-Schreibvorgang. Jede Anfrage wird in beiden Kosten für ihre eigene Prompt-Länge bepreist, sodass die 87 Anfragen über 100.000 Token in beiden die höheren Preise zahlen. Auf den Token-Zahlen wie aufgezeichnet, die die Kosten dieses Leitfadens für den Durchlauf verwenden, beträgt der Faktor 1,9, weil die fünf Versuche einer Aufgabe nebeneinander liefen und die Cache-Einträge der jeweils anderen lasen.
* **Warum der Faktor niedrig ist:** Der Faktor ist niedrig, weil die Sitzungen kurz sind, im Median 4 Anfragen: die meisten Eingabe-Token kommen als Tool-Ergebnisse bei der zweiten oder dritten Anfrage an und werden nur ein- oder zweimal aus dem Cache gelesen. Acht Long-Context-Aufgaben machen drei Viertel der Kosten aus. Ein zweiter Durchlauf am 8. Oktober ergibt ebenfalls 1,7.
26. **Messung des Antwortformats:**
* **Was gemessen wurde:** Der Triage-Job mit 20 Issues aus [Input- und Kontext-Token kürzen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), ausgeführt auf Claude Sonnet 5 mit aktiviertem Prompt-Caching und ohne Thinking-Einstellung in der Anfrage, sodass Nachdenken beim Standard des Modells blieb, unter drei Anweisungen für die finale Antwort, drei Durchläufe pro Anweisung.
* **Zweizeilige Anweisung:** Das Original verlangte zwei Zeilen: `4. Finish with exactly two lines: LABEL: SUMMARY: `
* **Einzeilige Anweisung:** Die kürzere Variante verlangte eine: `4. Finish with exactly one line in this form: DECISION | LABEL | REASON where DECISION is one of: triage-now, needs-info, close-duplicate; LABEL is one of: bug-confirmed, needs-more-info, duplicate-candidate, feature-request, upstream-issue, perf, ui-polish; REASON is one clause under 15 words. Output nothing after that line.`
* **Memo-Anweisung:** Die längere Variante verlangte ein Memo mit sechs überschriebenen Abschnitten: Problemzusammenfassung, Belege, Duplikatprüfung, empfohlenes Label, nächste Schritte und Konfidenz.
* **Ebenfalls in den gesendeten Anweisungen:** Wie gesendet, sagte die zweizeilige Anweisung außerdem "Be concise." und die Memo-Anweisung "Be thorough and explicit."
* **Wann:** Die zweizeilige und die einzeilige Anweisung liefen am 18. August 2026 mit `max_tokens` bei 700 und die Memo-Anweisung am 19. August 2026 mit `max_tokens` bei 3.000. Keine Antwort erreichte ihr Limit.
* **Wie bewertet und bepreist:** Die Zahlen sind der Mittelwert der drei Durchläufe zu den Listenpreisen von Claude Sonnet 5, und die Genauigkeit ist exakte Übereinstimmung mit den Gold-Labels.
* **Ergebnisse:** Die einzeilige Antwort verwendete 39 % weniger Ausgabe-Token als das zweizeilige Original und kostete pro Durchlauf 14 % weniger (aus den gerundeten Kosten des Diagramms, 0,49 $ und 0,57 $; die ungerundeten Mittelwerte ergeben 13 %). Das Memo verwendete das Sechsfache der Ausgabe-Token des zweizeiligen Originals und kostete das 2,8-Fache der einzeiligen Antwort.
* **Nachdenken:** Etwa die Hälfte der Antworten enthielt Nachdenken, und dessen Token sind in den Ausgabe-Token enthalten.
27. **Messung der Tool-Suche:**
* **Was gemessen wurde:** Der Triage-Job mit 20 Issues aus [Input- und Kontext-Token kürzen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), ausgeführt auf Claude Sonnet 5 am 19. August 2026, mit aktiviertem Prompt-Caching und ohne Thinking-Einstellung in der Anfrage, sodass Nachdenken beim Standard des Modells blieb, drei Durchläufe pro Konfiguration. Der Agent hatte seine eigenen zwei Tools plus echte Tool-Definitionen von öffentlichen MCP-Servern, insgesamt 7, 17, 52, 102, 252 oder 502 Tools, wobei jede Definition geladen war oder die hinzugefügten mit `defer_loading` hinter der Tool-Suche markiert waren.
* **Wie bewertet und bepreist:** Die Zahlen sind der Mittelwert der drei Durchläufe zu den Listenpreisen von Claude Sonnet 5, und die Genauigkeit ist exakte Übereinstimmung mit den Gold-Labels.
* **Ergebnisse:** Mit jeder geladenen Definition stiegen die Kosten des Durchlaufs von 0,55 $ bei 7 Tools auf 1,02 $ bei 502 Tools, fast das Doppelte. Mit Tool-Suche lagen sie bei jeder Katalog-Größe bei 0,55 $ bis 0,56 $, 45 % weniger bei 502 Tools (aus den gerundeten Kosten des Diagramms, 0,56 $ und 1,02 $; die ungerundeten Mittelwerte ergeben 45,6 %). Jeder Durchlauf beantwortete 15 bis 18 der 20 Issues korrekt, mit oder ohne Tool-Suche.
* **Einschränkungen:** Kein Durchlauf rief ein Tool aus dem Katalog oder das Tool-Search-Tool auf: die eigenen zwei Tools des Agenten waren immer geladen, und jeder Tool-Aufruf ging an eines davon. Die Messung zeigt, was das Mitführen ungenutzter Definitionen kostet, nicht, ob die Tool-Suche ein Tool findet, wenn eines benötigt wird.
* **Separate Messung:** In einer separaten Messung auf demselben Modell und am selben Datum, mit einem öffentlichen GitHub-MCP-Server, der über den MCP-Connector angebunden war, und ohne Katalog, kosteten drei Durchläufe mit verzögert geladenem Toolset des Servers 20 % weniger als drei Durchläufe ohne (0,56 $ und 0,70 $ pro Durchlauf), und die drei Durchläufe jedes Zweigs beantworteten 17, 16 und 16 Issues korrekt. Die Anfragen in dieser separaten Messung enthielten kein Tool-Search-Tool. Mit geladenem Toolset rief jeder Durchlauf eines der Tools des Servers, `issue_read`, 3- oder 4-mal auf; mit verzögert geladenem Toolset rief kein Durchlauf eines der Tools des Servers auf.
28. **Messungen zum Input-Trimming und zum Kontext-Lebenszyklus:**
* **Was gemessen wurde:** Der Triage-Job mit 20 Issues aus [Input- und Kontext-Token kürzen](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) und seine lange Variante, ausgeführt auf Claude Sonnet 5 am 19. August 2026 (datiert in UTC), drei Durchläufe pro Einstellung, ohne Thinking-Einstellung in der Anfrage, sodass Nachdenken beim Standard des Modells blieb; etwa 3 von 10 Antworten enthielten Nachdenken.
* **Das Diagramm:** Das Diagramm in [Den Kontext-Lebenszyklus verwalten](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence#manage-the-context-lifecycle) vergleicht vier Einstellungen bei jedem Job: den Job mit aktiviertem Prompt-Caching und aktiviertem Input-Trimming (Bildgrößenanpassung und Tool-Suche) und denselben mit einem hinzugefügten Hebel, nämlich Context Editing, Compaction oder dem Pruning. Das Diagramm zählt eine Änderung von unter 10 % als keine Änderung.
* **Hebeleinstellungen:** Die Hebeleinstellungen unterschieden sich zwischen den beiden Jobs: Context Editing löschte beim 20-Issue-Job mindestens 2.000 Token, sobald der Prompt 20.000 überschritt, und beim langen Job mindestens 40.000, sobald er 50.000 überschritt, wobei die drei neuesten Tool-Nutzungen beibehalten wurden, und Compaction wurde beim 20-Issue-Job bei 50.000 Eingabe-Token und beim langen bei 80.000 ausgelöst.
* **Wie bepreist:** Jede Kostenangabe ist der Mittelwert der drei Durchläufe, aus den Nutzungsfeldern der Antworten zu den Listenpreisen von Claude Sonnet 5, mit Cache-Schreibvorgängen zu 2,50 $ und Cache-Lesevorgängen zu 0,20 $ pro Million Token.
* **Ergebnisse, Input-Trimming:** Eine fünfte Einstellung, Prompt-Caching ohne Input-Trimming, kostete 0,57 $ pro Durchlauf beim 20-Issue-Job und 1,38 $ beim langen, sodass das Input-Trimming beim ersten 26 % und beim zweiten 21 % einsparte. Gegenüber demselben 20-Issue-Job mit deaktiviertem Caching, der 3,36 $ pro Durchlauf kostete (Referenz 16), sparten Prompt-Caching und Input-Trimming zusammen 88 % (die ungerundeten Mittelwerte ergeben 87,5 %).
* **Ergebnisse, 20-Issue-Durchlauf:** Beim 20-Issue-Durchlauf, bei dem der Job ohne Hebel 0,42 $ pro Durchlauf kostete, kostete Context Editing 73 % mehr, Compaction lief einmal gegen Ende jedes Durchlaufs und kostete 7 % weniger, und das Pruning schrieb nichts um, weil kein Suchergebnis über seinem Schwellenwert von 2.000 Zeichen lag.
* **Ergebnisse, langer Durchlauf:** Beim langen Durchlauf, bei dem der Job ohne Hebel 1,09 $ pro Durchlauf kostete, kostete das Pruning 39 % weniger, Compaction 32 % weniger und Context Editing 4 % mehr.
* **Cache-Lesevorgänge, lange Durchläufe:** In den langen Durchläufen mit dem Pruning wurden bei der ersten Anfrage nach einer Aufgabengrenze 89 % der Prompt-Token aus dem Cache gelesen und bei den anderen Anfragen 81 %. Über die gesamten langen Durchläufe wurden mit dem Pruning 85 % der Prompt-Token aus dem Cache gelesen und mit Context Editing 85 %, gegenüber 95 % ohne Hebel.
## Nächste Schritte
Der größte kostenlose Gewinn auf dieser Seite: Einrichtung, Lebensdauern und Diagnose.
Tausche Intelligenz gegen Latenz und Kosten innerhalb eines einzelnen Modells.
Bewerte Fähigkeit, Geschwindigkeit und Kosten über die gesamte Claude-Modellfamilie hinweg.
Setze eine harte Dollar-Obergrenze für eine Managed Agents-Session.
Sieh dir die aktuellen Preise pro Token für jedes Claude-Modell an.
Wende diese Hebel einzeln nacheinander auf einen funktionierenden Agenten in einem ausführbaren Notebook an, mit Kosten pro Aufgabe nach jedem Schritt.
Sieh dir eine Schritt-für-Schritt-Erklärung der Advisor- und Orchestrator-Muster an.