Kosten pro Aufgabe statt Kosten pro Token: Die Unit Economics von Frontier-LLM-Workloads

Zusammenfassung

Kosten pro Token sind die falsche Messgröße für agentische und Produktions-Workloads. Die richtige Einheit sind die erwarteten Kosten pro erledigter Aufgabe – plus die Kosten für die Bereinigung fehlerhafter Outputs, die automatisierten Checks entgehen:

$$\mathbb{E}[\text{Kosten pro gelöster Aufgabe}] = \frac{C_{\text{Versuch}}}{p_{\text{Erfolg}}}$$

Bei den reinen Token-Kosten pro Aufgabe ist Mitte 2026 oft das neueste Frontier-Modell von OpenAI die günstigere Option. Artificial Analysis hat für GPT-5.6 Sol 1,04 $ pro Aufgabe im Intelligence Index gemessen, gegenüber 2,03 $ für Claude Opus 5 und 2,75 $ für Claude Fable 5. OpenAI hat die Lücke bei der Token-Effizienz geschlossen.

Anthropic gewinnt in dem Moment, in dem Zuverlässigkeit in den Nenner wandert. Auf tau-bench hielt Claude Opus 4.8 über wiederholte Läufe hinweg deutlich mehr seines Single-Attempt-Scores und verletzte Richtlinien weniger als halb so oft wie GPT-5.5. In unbeaufsichtigten Loops mit hohem Risiko senkt diese Konstanz Retries und manuelle Nachbearbeitung – und genau dort steckt das eigentliche Geld.

Zentrale Erkenntnisse

Die Listenpreise der Flaggschiff-Modelle haben sich angeglichen. Claude Opus 5 kostet 5 $ Input / 25 $ Output pro Million Tokens. GPT-5.6 Sol kostet 5 $ / 30 $. Beim Output-Listenpreis ist Anthropic inzwischen günstiger, nicht teurer. Das alte Narrativ "Claude kostet mehr pro Token" ist an der Frontier weitgehend überholt.

Token-Zahlen sind zwischen Anbietern nicht vergleichbar. Der Tokenizer von Anthropic erzeugt ab Opus 4.7 rund 30 Prozent mehr Tokens für denselben Text, und Opus 4.8 sowie Opus 5 kommen auf etwa 1,88 Tokens pro englischem Wort gegenüber rund 1,17 beim o200k-Encoding von GPT-5. Für denselben Dollar-pro-Million-Preis bekommt man also weniger Wörter Claude-Kontext. Das verzerrt naive Pro-Token-Vergleiche mit Anthropic.

Reasoning-Tokens werden auf beiden Plattformen als Output-Tokens abgerechnet – OpenAI verbirgt sie, Anthropic kann sie zurückgeben. Eine sichtbare Antwort mit 500 Tokens kann Tausende abgerechnete Reasoning-Tokens im Gepäck haben.

Der Erfolgsraten-Nenner dominiert. Ein Modell, das pro Versuch 10 Prozent teurer ist, aber deutlich konsistenter zum Ziel kommt, kann pro korrekter, richtlinienkonformer Aufgabe erheblich günstiger sein, sobald Retries und manuelle Nachbearbeitung eingerechnet werden.

Prompt-Caching verändert die Rechnung bei langen Sessions auf beiden Seiten. Cache-Reads kosten sowohl bei Anthropic als auch bei den aktuellen OpenAI-Modellen 10 Prozent des Input-Preises.

Details

Das Problem: Preise pro Token messen das Falsche

Teams wählen Modelle nach Leistungsfähigkeit, Verfügbarkeit und Anbieter-Fit aus. Beim Kostenvergleich aber überfliegen sie eine Preisliste – 5 $ gegen 10 $ pro Million Tokens – und belassen es dabei. Für alles Agentische ist dieser Vergleich nahezu wertlos.

Eine agentische Aufgabe ist kein einzelner API-Call. Sie ist ein Loop.

Planen, Tool aufrufen, Ergebnis lesen, entscheiden, editieren, verifizieren, wiederholen. Die Analyse agentischer Coding-Sessions von Vantage modelliert eine repräsentative Coding-Session mit 50 Turns bei rund 1 Million Input-Tokens und 40.000 Output-Tokens – ein Input-zu-Output-Verhältnis von fast 25 zu 1, bei dem der Input etwa 85 Prozent der Gesamtkosten ausmacht, weil das Modell in jedem Turn einen wachsenden Kontext neu einliest. Gartners Analyse vom März 2026 ergab, dass agentische Workflows pro Aufgabe 5- bis 30-mal mehr Tokens verbrennen als eine einfache Chatbot-Anfrage, und Senior Director Analyst Will Sommer brachte das Risiko auf den Punkt: Chief Product Officers "sollten die Deflation von Commodity-Tokens nicht mit der Demokratisierung von Frontier-Reasoning verwechseln." Bai et al. (arXiv:2604.22750), ein Preprint, das acht Frontier-LLM-Trajektorien auf SWE-bench Verified analysiert und an dem unter anderem Erik Brynjolfsson (Stanford) und Alex Pentland (MIT) mitgewirkt haben, stellte fest, dass agentische Coding-Aufgaben bis zu 1.000-mal mehr Tokens verbrauchen als Code-Reasoning und Code-Chat – mit bis zu 30-facher Varianz zwischen einzelnen Läufen und Input-Tokens als dominierendem Kostenfaktor.

Die meisten Engineers haben nie gesehen, was eine Agenten-Trajektorie tatsächlich kostet. Das Team um Bai et al. hat seine Rohdaten unter longjubai.github.io/agent_token_consumption veröffentlicht – inklusive eines Ratespiels: Sie lesen eine echte Coding-Aufgabe, schätzen die Token-Rechnung und sehen dann, was acht Frontier-Modelle tatsächlich verbraucht haben. Spielen Sie drei Runden, bevor Sie irgendeiner Kostenschätzung trauen – auch Ihrer eigenen. Schon die Modelle selbst unterschätzen ihren Verbrauch, und Ihnen wird es genauso gehen. Genau diese Lücke zwischen prognostizierten und tatsächlichen Ausgaben ist das ganze Argument dafür, Kosten pro Aufgabe zu messen, statt sie vorherzusagen.

Daraus folgen zwei Fakten. Erstens: Die Zahl der Tokens pro Aufgabe schwankt je nach Modell enorm, derselbe Listenpreis führt also zu sehr unterschiedlichen Rechnungen. Zweitens: Ein Teil der Aufgaben scheitert, und eine gescheiterte Trajektorie kostet trotzdem den vollen Preis. Die Messgröße, die beide Fakten übersteht, sind die Kosten pro erledigter Aufgabe.

Eine formale Definition

Definieren Sie die Kosten eines einzelnen Versuchs als Summe der abgerechneten Tokens mal ihrer Preise über alle Schritte der Trajektorie:

$$C_{\text{Versuch}} = \sum_{s=1}^{S} \left( \text{in}_s \cdot p_{\text{in}} + \text{cache}_s \cdot p_{\text{cache}} + \text{out}_s \cdot p_{\text{out}} \right)$$

Erfolgt jeder Versuch unabhängig mit Wahrscheinlichkeit $p$ und wird bis zum Erfolg wiederholt, liegt die erwartete Zahl der Versuche bei $1/p$, also:

$$\mathbb{E}[\text{Kosten pro gelöster Aufgabe}] = \frac{C_{\text{Versuch}}}{p_{\text{Erfolg}}}$$

Begrenzen Sie die Retries auf $N$ Versuche, beträgt die Wahrscheinlichkeit eines letztlichen Erfolgs $1 - (1-p)^N$, und die erwarteten Modellkosten pro gelöster Aufgabe steigen entsprechend. Das sind die Modellkosten. Es sind nicht die Gesamtkosten.

Die Gesamtkosten schließen fehlerhafte Outputs ein, die automatisierte Checks passieren und einen Menschen oder die Produktion erreichen:

$$\mathbb{E}[\text{Gesamtkosten pro korrekter Aufgabe}] = \frac{C_{\text{Versuch}}}{p_{\text{Erfolg}}} + L \cdot K_{\text{Bereinigung}}$$

Dabei ist $L$ die Leak-Rate – die Wahrscheinlichkeit, dass ein falscher oder nicht richtlinienkonformer Output unentdeckt bleibt – und $K_{\text{Bereinigung}}$ sind die Kosten, ihn zu beheben. Dieser Term taucht auf der API-Rechnung in der Regel nicht auf und ist häufig größer als die Rechnung selbst.

Aktuelle Preise (August 2026)

Anthropic, Standard-API, pro Million Tokens:

Modell	Input	Output	Cache-Read	Batch (In/Out)
Claude Fable 5	10 $	50 $	1,00 $	5 $ / 25 $
Claude Opus 5 (Flaggschiff, Standard)	5 $	25 $	0,50 $	2,50 $ / 12,50 $
Claude Opus 4.8	5 $	25 $	0,50 $	2,50 $ / 12,50 $
Claude Sonnet 5	2 $ (Einführungspreis) / 3 $	10 $ (Einführungspreis) / 15 $	0,30 $	1,50 $ / 7,50 $
Claude Haiku 4.5	1 $	5 $	0,10 $	0,50 $ / 2,50 $

Cache-Writes kosten bei Anthropic das 1,25-Fache des Input-Preises bei 5 Minuten TTL und das 2-Fache bei 1 Stunde TTL. Der Einführungspreis von 2 $ / 10 $ für Sonnet 5 gilt bis zum 31. August 2026.

OpenAI, Standard-API, pro Million Tokens:

Modell	Input	Output	Cache-Read	Batch (In/Out)
GPT-5.6 Sol (Flaggschiff)	5 $	30 $	0,50 $	2,50 $ / 15 $
GPT-5.6 Terra	2 $	12 $	0,20 $	1 $ / 6 $
GPT-5.6 Luna	0,20 $	1,20 $	0,02 $	0,10 $ / 0,60 $
GPT-5.5	5 $	30 $	0,50 $	2,50 $ / 15 $
GPT-5.4	2,50 $	15 $	0,25 $	1,25 $ / 7,50 $

Die Batch-API von OpenAI gewährt 50 Prozent Rabatt auf Input und Output bei einem 24-Stunden-Fenster. Flex bietet dieselben 50 Prozent bei variabler Latenz. Priority kostet für niedrigere Latenz etwa das 2,5-Fache. GPT-5.6 hat Cache-Write-Preise zum 1,25-Fachen des Input-Preises mit 30 Minuten Mindestdauer eingeführt und folgt damit dem Modell von Anthropic. Beachten Sie den Long-Context-Aufschlag: Bei GPT-5.5 und GPT-5.6 wird jede Anfrage über etwa 272.000 Input-Tokens für die gesamte Session mit dem 2-Fachen beim Input und dem 1,5-Fachen beim Output abgerechnet. Anthropic bietet den vollen 1M-Kontext bei Opus 5, Opus 4.8 und Sonnet 5 zu einheitlichen Preisen.

Kosten pro Aufgabe, gemessen

Artificial Analysis veröffentlicht für seinen Intelligence Index absolute Dollar-Kosten pro Aufgabe. Bei maximalem Reasoning-Aufwand, Stand August 2026: GPT-5.6 Sol kostet 1,04 $, Claude Opus 4.8 kostet 1,80 $, Claude Opus 5 kostet 2,03 $, Claude Sonnet 5 kostet 2,29 $ zu Standardpreisen (1,53 $ zum Einführungspreis, der am 31. August 2026 ausläuft) und Claude Fable 5 kostet 2,75 $.

In dieser Suite liefert das Frontier-Modell von OpenAI nahezu Spitzenintelligenz zu rund einem Drittel der Kosten des leistungsstärksten Anthropic-Modells. Das ist das ehrliche Fazit – und es widerspricht der naiven These.

Das Ranking ist zudem genau auf die Weise instabil, die dieser Beitrag vorhersagt. Als Artificial Analysis im Mai 2026 seine Analyse zum Coding Agent Index veröffentlichte, kostete Claude Opus 4.7 (max) in Claude Code 4,10 $ pro Aufgabe gegenüber 4,82 $ für GPT-5.5 (xhigh) in Codex – ein Sieg für Claude. Der Live-Index zeigt dasselbe Paar mit Stand 10. August bei rund 5,63 $ und 5,05 $, in umgekehrter Reihenfolge, weil die Kosten pro Aufgabe aus aktuellen Token-Preisen und aufgefrischten Läufen neu berechnet werden. Dieselben Modelle, derselbe Benchmark, gegenteiliges Fazit innerhalb eines Quartals. In der aktuellen Generation führt GPT-5.6 Sol in Codex den Index an und ist pro Aufgabe etwa 10 Prozent günstiger als Opus 4.8 in Claude Code. Das Ranking ist workload-, generations- und datumsspezifisch – und genau das ist der Punkt.

Rechenbeispiel 1: Eine Coding-Aufgabe, bei der OpenAI gewinnt

Nehmen Sie einen Bugfix im SWE-bench-Stil. Modellieren Sie die Session mit Caching auf System-Prompt und Tools.

Claude Opus 4.8 zu 5 $ / 25 $, Cache-Read 0,50 $. Effektiver Input 1.000.000 Tokens, 80 Prozent Cache-Reads, Output 40.000 Tokens.

• Input: 200k frisch zu 5 $/M = 1,00 $, plus 800k Cache-Reads zu 0,50 $/M = 0,40 $.
• Output: 40k zu 25 $/M = 1,00 $.
• Cache-Write einmalig, 50k zu 6,25 $/M = 0,31 $.
• $C_{\text{Versuch}} \approx \$2.71$.

GPT-5.6 Sol zu 5 $ / 30 $, Cache-Read 0,50 $. Sol arbeitet Output-sparsamer, also modellieren wir 700.000 effektive Input-Tokens und 15.000 Output-Tokens.

• Input: 140k frisch zu 5 $/M = 0,70 $, plus 560k Cache-Reads zu 0,50 $/M = 0,28 $.
• Output: 15k zu 30 $/M = 0,45 $.
• Cache-Write einmalig, etwa 0,07 $.
• $C_{\text{Versuch}} \approx \$1.50$.

Teilen Sie nun durch die unabhängig gemessene SWE-bench-Verified-Erfolgsrate im Vals-AI-Harness: GPT-5.6 Sol 96,2 Prozent, Claude Opus 4.8 88,6 Prozent. Wir verwenden hier Opus 4.8, weil dafür ein unabhängig gemessener Vals-AI-Wert vorliegt; die veröffentlichten Zahlen zu Opus 5 mischen verschiedene Harnesses.

$$\text{Sol: } \frac{\$1.50}{0.962} \approx \$1.56 \text{ pro gelöstem Issue}$$ $$\text{Opus 4.8: } \frac{\$2.71}{0.886} \approx \$3.06 \text{ pro gelöstem Issue}$$

OpenAI gewinnt hier sowohl bei den Kosten pro Versuch als auch bei der Erfolgsrate. Für rein autonomes Coding auf dem öffentlichen SWE-bench Verified ist Mitte 2026 das token-effiziente Frontier-Modell von OpenAI pro gelöstem Issue die günstigere Wahl. Jede ehrliche Cost-per-Task-Analyse muss das einräumen.

Rechenbeispiel 2: Eine Tool-Use-Aufgabe, bei der Anthropic gewinnt

Nehmen Sie nun einen unbeaufsichtigt laufenden Support-Agenten einer Airline, der Erstattungen und Umbuchungen vornimmt. Falsche Aktionen sind teuer, weil sie echtes Geld und Richtlinien betreffen.

Aus dem tau-bench-Test von Contra Collective, Airline-Domäne: Claude Opus 4.8 pass@1 = 0,64 mit 4 Richtlinienverstößen pro 100 Aufgaben. GPT-5.5 pass@1 = 0,58 mit 9 Richtlinienverstößen pro 100 Aufgaben. Es handelt sich um kürzere Dialoge, also nehmen wir Kosten pro Versuch von rund 0,30 $ für Opus und 0,22 $ für das token-effizientere GPT-5.5 an. Nehmen wir außerdem an, dass jeder durchgerutschte Richtlinienverstoß 25 $ Bereinigungskosten verursacht – im Einklang mit den Service-Desk-Resolution-Benchmarks von 2026.

Dieser Test stammt aus der Zeit vor GPT-5.6 Sol, die OpenAI-Seite liegt also eine Generation zurück; ein vergleichbarer Sol-Lauf auf tau-bench Airline wurde bislang nicht veröffentlicht, und dieser Vergleich sollte wiederholt werden, sobald einer existiert.

Pro 100 Aufgaben, Retry bis zum Erfolg plus Bereinigung:

$$\text{Opus 4.8: } 100 \cdot \frac{\$0.30}{0.64} + 4 \cdot \$25 = \$46.9 + \$100 = \$146.9 \;\Rightarrow\; \$1.47 \text{ pro korrekter Aufgabe}$$ $$\text{GPT-5.5: } 100 \cdot \frac{\$0.22}{0.58} + 9 \cdot \$25 = \$37.9 + \$225 = \$262.9 \;\Rightarrow\; \$2.63 \text{ pro korrekter Aufgabe}$$

Der Preis pro Token sprach für OpenAI. Die Kosten pro Versuch sprachen für OpenAI. Die um Erfolgsrate und Zuverlässigkeit bereinigten Kosten pro korrekter Aufgabe fielen um fast Faktor 2 zugunsten von Anthropic aus – allein getrieben vom Bereinigungsterm. Der Hebel sind die Kosten eines falschen Outputs. Sind diese Kosten hoch, macht sich Claudes Konstanz bezahlt. tau-bench macht diese Konstanz greifbar: Opus 4.8 hielt im Retail-Bereich 56 Prozent der Aufgaben über 8 aufeinanderfolgende Läufe gegenüber 41 Prozent bei GPT-5.5, und 34 Prozent gegenüber 22 Prozent im Airline-Bereich. Konstanz ist genau das, wofür man im unbeaufsichtigten Betrieb bezahlt.

Verzerrungen durch Tokenizer und Verbosity

Zwei Effekte wirken in entgegengesetzte Richtungen. Erstens bläht der Tokenizer von Anthropic die Token-Zahlen auf, gleiche Preise pro Token unterschätzen also Claudes effektive Kosten pro Wort. Zweitens variiert die Output-Verbosity je nach Modell und Workload – und hier hat sich das Bild 2026 gedreht. Unabhängige Tester stellten fest, dass GPT-5.5 bei gleichwertigen Coding-Aufgaben rund 72 Prozent weniger Output-Tokens verbrauchte als Claude Opus 4.7, und Artificial Analysis maß, dass GPT-5.6 Sol weniger Tokens verbraucht als Opus 4.8 und dabei bei der Intelligenz höher abschneidet. Die alte Annahme, Claude sei das wortkarge Modell, gilt an der Frontier nicht mehr.

Verbosity ist nicht dasselbe wie Leistungsfähigkeit. Das Terminal-Bench-2.0-Paper (arXiv:2601.11868, ICLR 2026) fand keinen statistisch signifikanten Zusammenhang zwischen Output-Tokens und Erfolg (r = −0,170, p = 0,515) und merkte an, dass Claude Sonnet 4.5 und Claude Opus 4.1 Spitzen-Erfolgsraten (43 Prozent und 38 Prozent) bei vergleichsweise moderatem Token-Verbrauch erreichten. Es gibt keinen Beleg dafür, dass ein höherer Token-Verbrauch mehr Korrektheit bringt. Aber mehr Tokens bedeuten immer eine höhere Rechnung – messen Sie also Output-Tokens pro Aufgabe und Modell, statt Annahmen zu treffen.

Abrechnung von Reasoning-Tokens

Beide Anbieter rechnen versteckte oder halbversteckte Thinking-Tokens zum Output-Preis ab. Die Reasoning-Tokens von OpenAI sind in der Antwort unsichtbar. Anthropic kann zusammengefasstes Thinking zurückgeben. Opus 5 nutzt inzwischen standardmäßig adaptives Thinking, und jeder Thinking-Token wird mit 25 $ pro Million abgerechnet – deshalb berichten Tests mit gleichem Effort-Level, dass Opus 5 bei derselben Aufgabe rund doppelt so viele Output-Tokens ausgibt wie Opus 4.8. Die praktische Konsequenz: Oft bewegt die Effort-Einstellung die Rechnung stärker als die Modellwahl. Instrumentieren Sie Reasoning-Tokens getrennt vom sichtbaren Output.

Caching

Prompt-Caching ist der wirkungsvollste Hebel bei langen agentischen Sessions. Beide Plattformen berechnen für Cache-Reads 10 Prozent des Input-Preises. Anthropic arbeitet mit expliziten cache_control-Breakpoints und berechnet das 1,25-Fache für einen 5-Minuten-Write oder das 2-Fache für einen 1-Stunden-Write. OpenAI cacht automatisch ab etwa 1.024 Tokens stabilem Präfix. In einem Agenten-Loop wiederholen sich System-Prompt, Tool-Schemas und ein wachsendes Konversationspräfix in jedem Turn – exakt das Muster, für das Caching gebaut wurde. Die Token-Akkumulation in einem Loop verläuft quadratisch. Cache-Reads flachen sie in Richtung linear ab.

ProjectDiscovery steigerte seine Cache-Hit-Rate von 7 auf 84 Prozent, lieferte dabei 9,8 Milliarden Tokens aus dem Cache und senkte die realen LLM-Ausgaben um 59 Prozent; nach der Optimierung erreichten Läufe 66 Prozent, in den letzten 10 Tagen 70 Prozent. Ein Loop, der mindestens alle 5 Minuten feuert, hält seinen Anthropic-Cache dauerhaft warm und zahlt den Write-Aufschlag nur einmal. Platzieren Sie stabile Inhalte zuerst. Alles, was nach einem variablen Element kommt, wird nicht gecacht.

Versteckte Kosten

Die API-Rechnung ist der sichtbare Kostenblock. Der versteckte ist die menschliche Zeit, die auf fehlerhafte Outputs entfällt. Eine von LogRocket zitierte Studie aus dem Jahr 2025 ergab, dass Senior Engineers im Schnitt 4,3 Minuten mit dem Review eines KI-generierten Vorschlags verbringen, gegenüber 1,2 Minuten bei von Menschen geschriebenem Code. Und die Analyse von Faros AI über mehr als 10.000 Entwickler zeigte einen Anstieg des Pull-Request-Volumens um 98 Prozent bei gleichzeitig 91 Prozent mehr Review-Zeit.

Faros stellte über 211 reale Engineering-Aufgaben hinweg außerdem fest, dass ein günstigeres Modell mit dem richtigen Repository-Kontext und einem Verifikations-Loop ein stärkeres Modell schlagen kann, das blind arbeitet. Das heißt: Kontext- und Harness-Engineering verschieben die Qualitäts-Kosten-Grenze selbst – manchmal stärker als die Modellwahl. Diese Kosten landen bei den teuersten und am stärksten ausgelasteten Leuten im Team.

So instrumentieren Sie die Kosten pro Aufgabe

Loggen Sie Tokens pro Trajektorie, nicht pro Call. Taggen Sie jede Anfrage mit einer Task-ID. Summieren Sie Input-, Cache-Read-, Cache-Write-, Reasoning- und sichtbare Output-Tokens über den gesamten Loop.

Erfassen Sie das Ergebnis. Markieren Sie jede Aufgabe per automatisiertem Check als gelöst oder gescheitert und protokollieren Sie Retries.

Berechnen Sie erfolgsraten-bereinigte Kosten: Gesamtausgaben der Trajektorie geteilt durch gelöste Aufgaben. Das ist Ihre echte Messgröße.

Verfolgen Sie eine Leak-Rate. Ziehen Sie Stichproben aus abgeschlossenen Aufgaben, die automatisierte Checks bestanden haben, und lassen Sie einen Menschen Korrektheit oder Richtlinienkonformität bewerten. Multiplizieren Sie die Leak-Rate mit Ihren vollen Bereinigungskosten.

Berichten Sie Kosten pro Einheit. Pro gelöstem Ticket, pro gemergtem PR oder pro korrekter Aktion – aufgeschlüsselt nach Modell und Effort-Einstellung. Machen Sie das für das Team sichtbar, das diese Kosten verursacht.

Trennen Sie interaktive von batchfähiger Arbeit schon im Design. Leiten Sie die batchfähige Hälfte für 50 Prozent Rabatt auf Batch oder Flex.