Warum KI-Agenten so viele Tokens verbrauchen (ein 20-Schritte-Beispiel)

Du stellst einem Agenten eine Frage, er arbeitet ein paar Minuten, und die Nutzungsseite zeigt Hunderttausende von Tokens. Nichts ist kaputt. Ein Agent ist eine Schleife, und jede Runde der Schleife sendet alles bisher Gesagte (die Werkzeugliste, den Verlauf, was auch immer die Werkzeuge zurückgegeben haben) erneut als Eingabe-Tokens. Die Antwort, die er schreibt, ist winzig. Was er immer wieder liest, ist es nicht.

Was ein Agent ist, in einem Bild#

Ein Chat-Modell antwortet einmal. Ein Agent ist dasselbe Modell in einer Schleife mit Werkzeugen: eine Datei lesen, das Web durchsuchen, einen Befehl ausführen. Und das Modell erinnert sich zwischen Aufrufen an nichts. Stell dir einen Assistenten vor, der jedes Mal alles vergisst, wenn er auflegt: Jedes Mal, wenn er zurückruft, liest du die Notizen von oben vor und fügst dann eine Zeile hinzu. So funktioniert die API.

Anthropics Tool-Use-Dokumentation (geprüft am 26. Oktober 2026) beschreibt die Schleife so:

1. Deine App sendet die Benutzernachricht und die Liste der Werkzeuge.
2. Das Modell antwortet mit stop_reason: "tool_use" und einem tool_use-Block: welches Werkzeug, mit welchen Argumenten.
3. Deine App führt das Werkzeug aus und sendet eine zweite Anfrage. Sie enthält die früheren Nachrichten, den Werkzeugaufruf des Modells, einen tool_result-Block und dieselbe Werkzeugliste.
4. Das Modell antwortet oder fordert ein weiteres Werkzeug an, und die Schleife dreht sich erneut.

Dieselbe Seite besagt, dass Tool-Use-Anfragen auf der gesamten gesendeten Eingabe abgerechnet werden, einschließlich des tools-Parameters, plus der Ausgabe. Schritt 3 ist also nie „nur der neue Teil“: Es ist die gesamte Konversation erneut.

Request 1  tools + system + task
Request 2  tools + system + task + call 1 + result 1
Request 3  tools + system + task + call 1 + result 1 + call 2 + result 2
...

Es ist derselbe Mechanismus wie in warum ein langer Chat mehr kostet, nur schneller. Ein Chat wächst um eine Nachricht, wenn du tippst. Ein Agent wächst bei jedem Schritt um zwei Blöcke, und niemand tippt etwas.

Drei Dinge fahren bei jedem Schritt mit#

Die Werkzeugliste. Namen, Beschreibungen und Parameterschemata jedes Werkzeugs gehen in jede Anfrage ein, selbst wenn das Modell in dieser Runde keines davon verwendet. Die Dokumentation fügt eine kleine Extranote hinzu: Bei aktivierten Werkzeugen fügt die API ihren eigenen Tool-Use-Prompt hinzu, 286 Tokens bei Claude Sonnet 5.5, Opus 5.5 und Haiku 5.5, und andere Modelle haben andere Zahlen.

Der Verlauf. Deine Aufgabe, die früheren Werkzeugaufrufe des Modells, seine Notizen.

Werkzeugausgabe. Das ist die heimtückische. Eine Datei, die der Agent gelesen hat, eine Seite mit Suchergebnissen, ein Testprotokoll: Sobald es im Verlauf landet, wird es bei jedem späteren Schritt erneut bezahlt.

Ein Token ist ein kleines Stück Text, ungefähr ein kurzes Wort oder ein Teil davon, und jedes dieser drei wird darin gezählt.

Ein 20-Schritte-Lauf, gezählt#

Angenommen, du betreibst einen kleinen Coding-Agenten mit drei Werkzeugen (eine Datei lesen, suchen, Tests ausführen) und gibst ihm eine Aufgabe, die 20 Schritte dauert. Nimm diese Annahmen:

• Werkzeugdefinitionen: 1.500 Tokens, System-Prompt: 500, deine Aufgabe: 200, also startet jede Anfrage bei 2.200 Tokens;
• bei jedem Schritt schreibt das Modell einen Werkzeugaufruf von 150 Tokens, und das Werkzeug gibt 800 Tokens zurück;
• beide gehen in den Verlauf ein, also fügt jeder Schritt der nächsten Anfrage 950 Tokens hinzu.

Um die Gesamtsumme des Laufs zu erhalten, addiere alle 20 Anfragen. Die Basis von 2.200 wird 20-mal gesendet, und die Runden werden von späteren Schritten mitgetragen: Schritt 1 trägt keine, Schritt 2 eine, und so weiter bis 19, was insgesamt 190 Runden ergibt.

20 × 2.200 = 44.000

950 × 190 = 180.500

44.000 + 180.500 = 224.500 Eingabe-Tokens und 20 × 150 = 3.000 Ausgabe-Tokens.

Der Agent schrieb 3.000 Tokens und las 224.500. Ausgabe-Tokens kosten jeweils mehr als Eingabe-Tokens (siehe Eingabe- vs. Ausgabe-Tokens), aber es gibt so wenige davon, dass die Eingabeseite immer noch die Rechnung entscheidet. Hier ist dieser Lauf zu aktuellen Preisen:

Bei DeepSeek-V4-Flash kostet ein solcher Lauf $0.0037, bei GLM-5.3-Flash $0.0046. Hundert Läufe sind 22.450.000 Eingabe- und 300.000 Ausgabe-Tokens: $0.367 bei DeepSeek-V4-Flash. Die Tabelle oben zählt Eingabe und Ausgabe zusammen, und insgesamt sind die Modelle dort günstiger als OpenRouter.

Die Schrittzahl ist wichtiger, als es aussieht. Ein 5-Schritte-Lauf mit denselben Annahmen:

5 × 2.200 = 11.000

950 × 10 = 9.500

11.000 + 9.500 = 20.500 Eingabe-Tokens. Viermal so viele Schritte ergaben etwa elfmal so viel Eingabe, weil jeder neue Schritt auch alle alten erneut liest.

Wo man kürzen kann: vier Gewohnheiten#

Ein Werkzeugergebnis ist die einfachste Stelle zum Sparen. Angenommen, ein Testlauf in Schritt 3 gibt ein 4.000-Token-Protokoll zurück. Es wird dann von den 17 folgenden Anfragen erneut gesendet:

• vorher: 4.000 × 17 = 68.000 Eingabe-Tokens, die von diesem einen Protokoll mitgetragen werden;
• nachher, wenn das Werkzeug nur die 40 relevanten Zeilen zurückgibt (etwa 400 Tokens): 400 × 17 = 6.800.

Gleiche Aufgabe, gleiche Antwort, ein Zehntel der Eingabe aus diesem einen Ergebnis. Das ergibt vier Gewohnheiten:

• Gib weniger von Werkzeugen zurück. Zeilen um den Fehler herum, nicht das ganze Protokoll; die Funktion, nicht die ganze Datei. Eine längere Betrachtung gibt es in Werkzeugausgabe aus dem Kontext heraushalten.
• Gib dem Agenten weniger Werkzeuge. Jede Definition fährt bei jeder Anfrage mit.
• Begrenze die Schritte und starte eine frische Aufgabe, wenn der alte Verlauf keine Rolle mehr spielt.
• Addiere die Nutzung jedes Schritts und stoppe den Lauf bei einem Budget, das du vorher gewählt hast. Für die Schätzseite siehe wie man die Kosten eines KI-Agenten schätzt.

Zähle deinen eigenen Lauf#

Jede Antwort meldet, wie viele Tokens sie aufgenommen und ausgegeben hat, in ihrem usage-Feld. Summiere sie über alle Schritte, und du hast die echten Zahlen für deinen Agenten statt meiner Annahmen. Ein Entwurf mit dem OpenAI Python SDK, das auf CheapTokens zeigt (messages und tools gehören deinem Agenten):

from openai import OpenAI

client = OpenAI(base_url="https://api.cheaptokens.dev/v1", api_key="YOUR_API_KEY")

total_in = total_out = 0
for step in range(20):  # your agent loop
    resp = client.chat.completions.create(
        model="deepseek-ai/DeepSeek-V4-Flash-0731",
        messages=messages,
        tools=tools,
    )
    total_in += resp.usage.prompt_tokens
    total_out += resp.usage.completion_tokens
    # ...run the tool, append the result to messages

print(total_in, total_out)

Die beiden Summen passen direkt in die Kostentabelle oben. Für so lange Verläufe bietet DeepSeek-V4-Flash ein Kontextfenster von 380K und bis zu 32.768 Ausgabe-Tokens pro Antwort, zu einem Preis zu jeder Stunde; GLM-5.3-Flash hat einen Kontext von 390K und bis zu 8.192 Ausgabe-Tokens. Die Einrichtung steht in der Dokumentation, der aktuelle Preis jedes Modells auf der Preisseite, und das Modell hat seine eigene Seite, günstiges DeepSeek.