Ein Coding-Agent zahlt nicht pro Aufgabe. Er zahlt pro Schritt, und jeder Schritt sendet die gesamte bisherige Unterhaltung erneut. Die Kosten eines Laufs hängen daher weit mehr davon ab, wie viele Schritte er braucht und wie viel vom Kontext gecacht ist, als vom Preis pro Token. Dieser Beitrag setzt die Kosten eines Laufs aus diesen Teilen zusammen, mit Zahlen, und zeigt, wann eine Flatrate-Session die Abrechnung pro Token schlägt.
Woher die Tokens in jedem einzelnen Aufruf kommen (Tool-Schemas, gelesene Dateien, Verlauf), zeigt Wohin die Tokens einer Agenten-Schleife gehen. In diesem Beitrag geht es um die Rechnung für einen ganzen Lauf.
Wie wächst der Kontext während eines Agenten-Laufs?
Jeder Aufruf enthält:
- einen Basiskontext, der bei jedem Aufruf mitgeht: System-Prompt, Tool-Definitionen, Regeldateien, eine Repo-Map;
- alles, was frühere Schritte hinzugefügt haben: die Antworten und Tool-Aufrufe des Modells, Dateiinhalte und Befehlsausgaben;
- die neue Anweisung oder das neue Tool-Ergebnis.
Nennen wir den Basiskontext B und die Tokens, die jeder Schritt hinzufügt, g. Schritt 1 sendet B. Schritt 2 sendet B + g. Schritt n sendet B + (n − 1) × g. Summiert sendet ein Lauf mit n Schritten:
Gesamter Input = n × B + g × n × (n − 1) ÷ 2
Der zweite Term wächst mit dem Quadrat der Schrittzahl. Deshalb überraschen lange Läufe: Der letzte Schritt eines Laufs mit 60 Schritten ist weit größer als der erste, und jeder Schritt dazwischen bezahlt noch einmal für alle vorherigen.
Wie sieht ein durchgerechneter Lauf aus?
Nehmen Sie einen Agenten mit 15.000 Tokens Basiskontext (System-Prompt, ein Dutzend Tools und eine Repo-Map). Jeder Schritt fügt 3.000 Tokens hinzu: eine Datei oder ein Test-Log plus die eigene Antwort des Modells. Jeder Schritt schreibt 800 Output-Tokens, Reasoning eingeschlossen.
| Schritte | Gesamter Input | Output | Größter einzelner Aufruf |
|---|---|---|---|
| 10 | 285.000 | 8.000 | 42.000 |
| 30 | 1.755.000 | 24.000 | 102.000 |
| 60 | 6.210.000 | 48.000 | 192.000 |
Von 30 auf 60 Schritte verdoppelt sich die Arbeit, der Input steigt aber etwa um das 3,5-Fache. Der Output verdoppelt sich nur. Der Input ist in diesen Läufen 36- bis 130-mal so groß wie der Output. Deshalb zählen bei Agenten der Input-Preis und der Preis für gecachten Input am meisten.
Der größte Aufruf muss außerdem ins Kontextfenster passen. 192.000 Tokens passen bei DeepSeek V4.1 Flash und GLM 5.3 (je 1.048.576 Tokens) und bei Qwen3.8 27B (262.144). Bei Gemma 4 VL 26B (32.768) passen sie nicht: In diesem Beispiel ist schon der siebte Aufruf zu groß.
Wie stark ändert Caching die Rechnung?
Anbieter rechnen ein wiederholtes Prompt-Präfix zum niedrigeren Preis für gecachten Input ab. Ein Agent, der seinen Verlauf nur ergänzt, sendet jedes Mal dasselbe Präfix plus etwas mehr. Im besten Fall sind daher nur die seit dem letzten Aufruf hinzugekommenen Tokens neu:
Neuer Input (bester Fall) = B + (n − 1) × g
Alles andere ist ein Cache-Treffer. Der gecachte Anteil steigt, je länger der Lauf wird:
| Schritte | Neuer Input, bester Fall | Gecachter Anteil |
|---|---|---|
| 10 | 42.000 | 85 % |
| 30 | 102.000 | 94 % |
| 60 | 192.000 | 97 % |
Echte Agenten erreichen den besten Fall selten, daher hilft es, drei Fälle zu bepreisen. Zu den Preisen von BroadNet für DeepSeek V4.1 Flash ($0.175 Input, $0.0055 gecacht, $0.52 Output pro 1 Mio. Tokens, veröffentlicht am 2026-11-14) ergeben sich folgende Kosten pro Lauf, relativ zum besten Fall mit 30 Schritten:
| Schritte | Cache im besten Fall | 80 % gecacht | Kein Cache |
|---|---|---|---|
| 10 | 0,33× | 0,39× | 1,37× |
| 30 | 1× | 2,07× | 8,11× |
| 60 | 2,33× | 6,84× | 28,2× |
Zwei Dinge fallen auf. Ohne Cache kostet ein Lauf mit 60 Schritten 28-mal so viel wie ein gut gecachter Lauf mit 30 Schritten. Und Caching wird umso wichtiger, je länger der Lauf wird. Im besten Fall mit 30 Schritten macht Output etwa ein Drittel der Kosten aus, neuer Input weniger als die Hälfte und gecachter Input weniger als ein Viertel. Nach dem Caching liegt die nächste Ersparnis also beim Output.
Caching lässt sich nicht einfach einschalten. Es hängt davon ab, dass der Anbieter das Präfix vorhält und Ihr Agent es nicht verändert. Der Leitfaden von OpenAI beschreibt einen exakten Präfix-Abgleich mit einer minimalen cachebaren Länge. Die eigene API von DeepSeek speichert Cache-Einheiten am Ende von Input und Output jeder Anfrage, sodass eine Folgeanfrage, die die vorherige verlängert, einen Treffer erzielen kann. Die Preisseite von BroadNet sagt, dass gecachter Input keine Einrichtung braucht, und laut Doku werden Treffer in usage.prompt_tokens_details.cached_tokens gemeldet, wenn das Modell sie liefert. Der Modellkatalog von BroadNet führt DeepSeek V4.1 Flash unter „models we never ran on our hardware“ (Übersetzung: Modelle, die wir nie auf unserer Hardware betrieben haben), und die Nutzungsbedingungen (§7.3) erfassen das Modell „when partner-hosted“ (Übersetzung: wenn es bei einem Partner gehostet wird). Bei BroadNet wird es also über einen Partner bereitgestellt. Messen Sie Ihre Trefferquote, statt die Zahlen von DeepSeek selbst anzunehmen. Schreiben Sie das Präfix so, dass es gecacht werden kann: Prompt-Struktur für Caching.
Wie schätzen Sie Ihren eigenen Lauf?
Dieses Skript liest die aktuellen Preise aus der öffentlichen pricing.json von BroadNet, veraltet also nie, und gibt für jeden Cache-Fall die Token-Summen und die Kosten pro Lauf aus:
import json, urllib.request
PRICES = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
m = next(x for x in PRICES["models"] if x["id"] == "broadnet/deepseek-v4.1-flash")
p_in, p_cached, p_out = m["input_per_m"], m["cached_input_per_m"], m["output_per_m"]
def run_tokens(steps, base=15_000, growth=3_000, out_per_step=800, cache_rate=None):
total_in = steps * base + growth * steps * (steps - 1) // 2
if cache_rate is None: # best case: only new tokens miss
new_in = base + (steps - 1) * growth
else:
new_in = round(total_in * (1 - cache_rate))
return total_in, new_in, steps * out_per_step
def run_cost(total_in, new_in, out):
return ((new_in * p_in) + (total_in - new_in) * p_cached + out * p_out) / 1e6
for steps in (10, 30, 60):
for label, rate in (("best", None), ("80%", 0.8), ("none", 0.0)):
t, n, o = run_tokens(steps, cache_rate=rate)
print(f"{steps:>3} steps cache {label:>4} input {t:>9,} new {n:>9,} "
f"output {o:>6,} cost/run {run_cost(t, n, o):.4f} USD")
Ersetzen Sie die Standardwerte durch Ihre eigenen Zahlen. Raten Sie sie nicht, sondern lesen Sie sie aus einem echten Lauf ab:
- Loggen Sie
prompt_tokens,prompt_tokens_details.cached_tokensundcompletion_tokensfür jeden Aufruf, wie im Beitrag zum Token-Budget von Agenten. - B ist der Wert
prompt_tokensdes ersten Aufrufs. g ist der durchschnittliche Anstieg vonprompt_tokensvon einem Aufruf zum nächsten. - Der Output pro Schritt ist der Durchschnitt von
completion_tokens. Er enthält Reasoning-Tokens, die als Output abgerechnet werden. - Ihre echte Cache-Quote ist die Summe von
cached_tokensgeteilt durch die Summe vonprompt_tokens.
Der kostenlose Kostenschätzer für Agenten-Läufe führt dieselbe Rechnung in Ihrem Browser aus. So können Sie ohne Code andere Schrittzahlen, Zuwachsraten und Cache-Quoten ausprobieren.
Was macht einen Lauf teurer als geschätzt?
- Retries. Ein fehlgeschlagener Tool-Aufruf oder ein Retry nach 429 ist ein weiterer Aufruf mit vollem Kontext. Zählen Sie sie als Schritte.
- Ein verändertes Präfix. Ein Zeitstempel im System-Prompt, Tools in anderer Reihenfolge oder eine während des Laufs geänderte Regeldatei machen gecachten Input ab der Änderung wieder zu neuem Input.
- Komprimierung. Ein zusammengefasster Verlauf verkleinert den Kontext und senkt späteren Input. Der neue Verlauf war aber nie gecacht, also zahlt der nächste Aufruf den vollen Input-Preis. Komprimieren Sie selten und in großen Schritten; wann, zeigt Kontextmanagement für lange laufende Agenten.
- Großer Tool-Output. Ein Test-Log mit 20.000 Zeilen, das in Schritt 5 hinzukommt, fährt in jedem späteren Schritt mit. In der Formel fügt es 20.000 × (verbleibende Schritte) Input-Tokens hinzu.
- Reasoning-Aufwand. Hoher Aufwand kann den Output pro Schritt vervielfachen. Setzen Sie
reasoning_effortfür Routineänderungen auflow. - Umherirren. Ein Agent, der für eine Aufgabe mit 30 Schritten 60 braucht, zahlt das Quadrat, nicht das Doppelte. Ein Schrittlimit ist ein Kostenlimit. Zehn Wege, die Kosten von Coding-Agenten zu senken beschreibt die Hebel.
Wann schlägt eine Flatrate-Session die Abrechnung pro Token?
Rechnen Sie die Kosten pro Lauf in einen Monatswert um: Monatskosten = Kosten pro Lauf × Läufe pro Monat. Vergleichen Sie das dann mit einem Pauschalplan. Bei BroadNet decken die Pläne DeepSeek V4.1 Flash ohne Token-Zähler ab: Full Moon kostet $60 im Monat, Orbit $15 pro Woche und Meteor $1 pro Stunde, jeweils pro Session.
Läufe pro Monat bis zum Break-even = Planpreis ÷ Kosten pro Lauf.
Zwei Dinge machen diesen Vergleich weniger einfach, als er aussieht:
- Ihre Cache-Quote bestimmt die Seite pro Token. Bei hoher Cache-Quote ist die Abrechnung pro Token bei Flash günstig, und Sie brauchen viele Läufe, um $60 zu überschreiten. Bei schlechter Quote überschreiten Sie den Wert schnell. Der Flatrate-Beitrag zeigt den Break-even als Monatsvolumen: etwa 917 Millionen Input- und 46 Millionen Output-Tokens bei 80 % Cache-Anteil (die Break-even-Rechnung).
- Die Zeit bestimmt die Obergrenze der Flatrate-Seite. Eine Session verarbeitet eine Anfrage gleichzeitig. Dauert ein Aufruf im Schnitt 20 Sekunden (Prefill, etwa 800 Output-Tokens bei etwa 100 Tokens pro Sekunde, plus Tool-Zeit), braucht ein Lauf mit 30 Schritten etwa 10 Minuten. Eine Session schafft dann höchstens etwa sechs Läufe pro Stunde. Mehr parallele Agenten brauchen mehr Sessions.
Für kurze Einsätze funktioniert Meteor genauso, nur im kleineren Maßstab: Passen sechs Läufe in eine Stunde, kostet jeder $1 ÷ 6. Vergleichen Sie das mit den Kosten pro Token, die das Skript für einen Lauf ausgibt. Ihre eigenen Volumen probieren Sie im Rechner Flatrate vs. pro Token aus.
| Ihr Nutzungsmuster | Meist günstiger |
|---|---|
| Einige kurze Läufe am Tag | Pro Token |
| Lange Läufe mit schlechtem Caching | Flatrate-Session |
| Agenten, die den größten Teil des Arbeitstags laufen | Flatrate-Session |
| Mehrere Agenten parallel, den ganzen Tag | Eine Flatrate-Session pro Agent |
| Natives Tool Calling bei BroadNet nötig | Pro Token mit GLM 5.3 oder Qwen3.8 27B |
Wo BroadNet Inference passt
BroadNet meldet gecachte und Reasoning-Tokens im Usage-Block, sodass Sie jede Zahl oben an Ihren eigenen Läufen messen können. DeepSeek V4.1 Flash hat einen niedrigen Preis für gecachten Input und einen Kontext von 1.048.576 Tokens, und die unbegrenzten Pläne entfernen den Token-Zähler; so funktionieren Sessions.
Prüfen Sie vorher eine Einschränkung. Die Doku von BroadNet weist Tool Calling nur für GLM 5.3 und Qwen3.8 27B aus, und keines der beiden ist in einem Pauschalplan enthalten. Agenten, die über Text editieren, etwa Aider, brauchen keine nativen Tool Calls. Braucht Ihr Agent sie, testen Sie DeepSeek V4.1 Flash mit Ihrem Agenten, bevor Sie einen Plan kaufen, oder planen Sie GLM oder Qwen mit Abrechnung pro Token ein. Und läuft Ihr Agent nur ab und zu, kostet die Abrechnung pro Token in der Regel weniger als jeder Pauschalplan.
