So senkst du den Tokenverbrauch von KI-Coding-Agents: 4 Tools, die helfen

Wenn du schon einmal nach wenigen Anfragen an die Token-Grenze deines KI-Coding-Tarifs gestoßen bist, fragst du dich wahrscheinlich, wohin all die Tokens verschwunden sind. 

Du bittest den Agenten, einen Bug zu beheben, ein Feature zu refaktorisieren oder ein Repository zu untersuchen – und plötzlich ist ein großer Teil deines Coding-Kontingents weg.

Das muss nicht an deinem Anbieter oder Abo liegen. 

KI-Coding-Agents sind schlicht deutlich tokenintensiver als normale Chatbots. Sie beantworten nicht nur deinen Prompt. Sie lesen Dateien, durchsuchen den Code, prüfen Logs, führen Tests aus, rufen Tools auf, generieren Code, reviewen ihre Änderungen und wiederholen das mehrmals, bevor die Aufgabe erledigt ist.

Die gute Nachricht: Viel unnötiger Tokenverbrauch lässt sich reduzieren.

Es gibt Tools, die Agents weniger ausschweifend machen, sie vor Überengineering bewahren, lautes Terminal-Output komprimieren und verhindern, dass große Toolantworten das Kontextfenster fluten.

In diesem Guide schauen wir uns vier Tools an, die den Tokenverbrauch bei KI-Coding-Agents reduzieren: Caveman, Ponytail, RTK und Context Mode. 

Wir sehen, was jedes Tool macht, wie du es einrichtest und wie du sie kombinierst, um mit Abos wie Claude Code und Codex mehr zu coden, bevor du an Limits stößt.

Warum verbrauchen agentische Workflows so viele Tokens?

Ein normaler Chatbot nimmt einen Prompt und gibt eine Antwort. Ein Agent macht meist deutlich mehr.

Er liest Dateien, ruft Tools auf, prüft Logs, holt Dokumente, schreibt Code – und wiederholt das mehrfach, bevor er fertig ist. 

Jeder Schritt fügt Kontext hinzu, und viel davon wird in späteren Aufrufen wieder an das Modell geschickt.

Ein vereinfachter Agent-Loop sieht so aus:

Die Anfrage geht ans Modell, das Modell ruft ein Tool auf, das Tool liefert Output, und dieser Output wandert zurück in den Kontext vor den nächsten Schritt. Der Rückkopplungspfeil kostet: Jeder Durchlauf trägt die bisherigen Ergebnisse weiter. Eine Aufgabe mit sechs Toolaufrufen schickt den Großteil dieser Historie sechsmal ans Modell.

So entstehen typische Quellen für Tokenverschwendung:

• Ausschweifende Antworten: Der Agent erklärt zu viel, wo eine kurze Antwort reicht.
• Überengineerter Code: Aus einer kleinen Aufgabe werden zusätzliche Dateien, Abstraktionen und Abhängigkeiten.
• Große Tool-Outputs: Logs, Tests, Git-Diffs und Terminalausgaben liefern schnell tausende Tokens.
• Zu viel Kontext: Abgerufene Dokumente, Tool-Definitionen und frühere Ergebnisse füllen das Kontextfenster im Nu.
• Lange Sitzungen: Je länger der Agent arbeitet, desto mehr Historie und Zwischenergebnisse trägt er mit.

Die eigentliche Herausforderung ist also nicht nur, wie viele Tokens ein Agent generiert, sondern wie viele er liest, weiterträgt und erneut verarbeitet, während der Workflow läuft.

Genau hier setzen Tools wie Caveman, Ponytail, RTK und Context Mode an – jeweils mit einem anderen Fokus auf Tokenverschwendung.

1. Caveman: Lass deinen Agenten weniger sagen

Caveman ist ein einfacher Weg, Coding-Agents knapper zu machen. 

Statt jeden Schritt zu kommentieren, Offensichtliches zu wiederholen oder Fülltexte zu liefern, lenkt es Antworten auf das, was wirklich zählt.

Besonders nützlich ist das in langen Codingsitzungen, in denen ausschweifende Antworten nicht nur mehr Output-Tokens erzeugen. 

Diese Antworten werden Teil der Historie und landen in späteren Turns erneut im Kontext.

So funktioniert Caveman

Caveman besteht aus zwei Teilen.

Die Caveman-Skill verändert, wie der Agent schreibt. 

Sie entfernt Füllwörter, Floskeln, Absicherungen und unnötige Erklärtexte, lässt aber wichtige Details wie Codeblöcke, Befehle, API-Namen und exakte Fehlermeldungen unangetastet. 

Wo es der Klarheit dient – etwa bei Sicherheitshinweisen oder irreversiblen Aktionen – wird der knappe Stil gelockert. 

Außerdem gibt es optional einen lokalen Proxy, der die andere Seite adressiert: das, was der Agent liest. 

Er sitzt zwischen Coding-Agent und Modellanbieter und komprimiert geeigneten Kontext, bevor die Anfrage gesendet wird. 

Skill und Proxy funktionieren unabhängig. Du kannst mit der leichten Skill starten und bei Bedarf später den Proxy für stärkere Kontextreduktion hinzufügen. 

Anschaulich erklärt das folgende Diagramm:

Links packt der Agent seinen Code in eine Einleitung und erklärt ihn danach erneut. Rechts bekommst du die nützliche Antwort und den Code – sonst nichts. Gleiche Arbeit, deutlich weniger Tokens fürs Erzählen.

Erste Schritte mit Caveman

Die Skill installierst du am einfachsten so:

npx skills add JuliusBrussee/caveman

Dann aktivierst du sie in deinem Coding-Agenten mit:

/caveman

Zurück zur normalen Ausgabe schaltest du mit:

/caveman off

Caveman bietet auch native Installationsoptionen für Tools wie Claude Code, Codex, Gemini CLI, Cursor und OpenCode.

Wenn du zusätzlich den gesendeten Kontext reduzieren willst, installiere die CLI:

npm install -g @caveman-ai/cli
caveman setup --install

Und starte einen unterstützten Agenten darüber, zum Beispiel:

caveman claude

Damit startest du den lokalen Caveman-Proxy und leitest den Agenten durch die Kontextkomprimierung. 

Für die meisten Nutzer würde ich mit der Skill starten. 

Sie ist schnell hinzugefügt, ändert deinen Workflow nicht und eliminiert eine der simpelsten Quellen für Tokenverschwendung: ein Agent, der viel mehr sagt als nötig.

2. Ponytail: Verhindere Überengineering

Ponytail zielt auf eine andere Art von Tokenverschwendung: Agents schreiben mehr Code, als die Aufgabe erfordert.

Eine einfache Bitte wird schnell zu neuen Dependencies, Helper-Klassen, Wrapper-Komponenten und extra Konfiguration. 

Ponytail bremst das, indem es den Agenten zuerst zur kleinstmöglichen sinnvollen Lösung lenkt.

So funktioniert Ponytail

Bevor Code geschrieben wird, führt Ponytail den Agenten eine einfache Entscheidungstreppe hinunter:

Jede Stufe gibt dem Agenten die Chance, zu stoppen, bevor er neuen Code schreibt. Erst wenn Standardbibliothek, native Plattformfunktionen und bestehende Abhängigkeiten ausschieden, landet er unten: beim Minimum an neuem Code, das funktioniert.

Statt etwa eine Date-Picker-Library zu installieren und eine Wrapper-Komponente zu bauen, entscheidet Ponytail zum Beispiel, dass der Browser bereits hat:

<input type="date">

Ziel ist nicht, alles blind zu kürzen. 

Ponytail lässt Punkte wie Validierung, Sicherheit, Barrierefreiheit und Schutz vor Datenverlust bewusst unangetastet. 

Es soll bei der Implementierung bequem, aber nicht fahrlässig sein.

Im eigenen agentischen Benchmark erzeugte Ponytail über 54% weniger Code und 22% weniger Tokens über 12 Coding-Aufgaben im Vergleich zum gleichen Agenten ohne Skill. 

Ein unabhängiger Benchmark fand ebenfalls deutlich kleinere Implementierungen, weist aber darauf hin, dass sehr aggressive Einstellungen in seltenen Randfällen Robustheit kosten können.

Erste Schritte mit Ponytail

Für Claude Code, füge den Marketplace hinzu:

/plugin marketplace add DietrichGebert/ponytail

Dann installiere Ponytail:

/plugin install ponytail@ponytail

Sende das als zwei separate Befehle.

Nach der Installation steuerst du, wie aggressiv Ponytail vereinfacht:

/ponytail lite
/ponytail full
/ponytail ultra
/ponytail off

full ist Standard und ein guter Start. lite baut weiterhin, was du verlangst, zeigt aber einfachere Alternativen auf, während ultra YAGNI sehr viel konsequenter anwendet. 

Du kannst auch eine bestehende Änderung auf unnötige Komplexität prüfen:

/ponytail-review

Oder einen größeren Codebestand scannen:

/ponytail-audit

Ponytail wirkt bei Coding-Agents besonders gut, weil weniger unnötiger Code Ketteneffekte hat: Der Agent schreibt jetzt weniger Tokens, erzeugt kleinere Diffs und lässt später weniger Code zum erneuten Lesen übrig.

3. RTK: Terminalrauschen einkürzen

RTK, kurz für Rust Token Killer, fokussiert eine andere Quelle der Tokenverschwendung: alles, was dein Agent vom Terminal zurückbekommt.

Befehle wie git status, Testruns, Logs, Suchen und Package-Manager-Ausgaben liefern Hunderte bis Tausende Zeilen. 

Vieles davon ist für Menschen im Terminal hilfreich, ein Agent braucht meist nur die wichtigen Teile.

RTK sitzt zwischen Befehl und Agent und komprimiert die Ausgabe, bevor das Modell sie sieht. 

So funktioniert RTK

RTK filtert, gruppiert, kürzt und dedupliziert befehlsspezifisch, um Rauschen zu entfernen und dennoch nützliche Infos wie Errors, Fehlschläge, geänderte Dateien und Zusammenfassungen zu behalten. 

Zum Beispiel:

Im Normalfall liest der Agent bei pytest jede Zeile – auch die vielen bestandenen Tests, die er nicht braucht. Mit RTK kommen nur die Fehlschläge plus eine Summary zurück: einige Dutzend Zeilen statt mehrere Hundert.

Mit unterstützten Coding-Agents kann RTK Shell-Aufrufe automatisch einhaken. Ein Befehl wie:

git status

wird im Hintergrund zu:

rtk git status

Der Agent erhält dann automatisch die kleinere Ausgabe, ohne RTK explizit anfordern zu müssen. 

RTK berichtet von 60–90% weniger Tokens durch Kommando-Outputs bei gängigen Dev-Befehlen. Das heißt nicht, dass deine gesamte LLM-Rechnung um 60–90% fällt; es betrifft nur das von RTK komprimierte Terminal-Output. 

Erste Schritte mit RTK

Unter macOS oder Linux installierst du es mit Homebrew:

brew install rtk-ai/tap/rtk

Oder per Installationsskript:

curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/master/install.sh | sh

Prüfe anschließend, ob du das richtige RTK installiert hast:

rtk --versionrtk gain

Der Befehl rtk gain zeigt das Token-Savings-Dashboard. Dieser Check ist sinnvoll, weil es noch ein anderes, nicht verwandtes Projekt mit dem Namen rtk gibt. 

Für Claude Code initialisierst du RTK global mit:

rtk init -g

Für Codex:

rtk init -g --codex

Und für Gemini CLI:

rtk init -g --gemini

RTK unterstützt außerdem Cursor, OpenCode, Copilot, Cline, Windsurf und weitere Coding-Agents. 

Einmal konfiguriert, benutzt du einfach weiter deine gewohnten Terminalbefehle. 

RTK übernimmt die Komprimierung im Hintergrund – ideal für Agents, die viel Zeit mit Tests, Codesuche, Git-Änderungen und Log-Analyse verbringen.

4. Context Mode: Große Tool-Outputs aus dem Kontext heraushalten

Context Mode konzentriert sich auf das, was passiert, sobald ein Agent Tools verwendet.

Ein Browser-Snapshot, eine GitHub-Issue-Liste, eine Dateisuche oder große Kommandausgaben können Unmengen an Informationen direkt ins Kontextfenster kippen. 

Schlimmer noch: Diese Informationen werden dann in spätere Turns mitgeschleppt.

Context Mode verhindert das, indem es wuchtige Rohdaten außerhalb des aktiven LLM-Kontexts hält und nur die Teile zurückbringt, die der Agent wirklich braucht.

So funktioniert Context Mode

Context Mode läuft als MCP-Server und stellt gekapselte Tools für Operationen bereit, die normalerweise große Outputs erzeugen.

Die Rohinformationen können lokal in einem FTS5-gestützten Suchindex gespeichert werden. So kann der Agent später erneut suchen, ohne das gesamte Ergebnis in die Unterhaltung zu kippen. 

In einem Projektbeispiel wurden 315 KB Roh-Output auf 5,4 KB Kontext reduziert – laut Angabe eine 98%ige Reduktion. 

Das ist ein projektspezifisches Beispiel, keine Garantie für jeden Toolaufruf. 

Erste Schritte mit Context Mode

Für Claude Code richtest du es am einfachsten über den Plugin-Marketplace ein:

/plugin marketplace add mksglu/context-mode
/plugin install context-mode@context-mode

Starte Claude Code neu und prüfe die Einrichtung mit:

/context-mode:ctx-doctor

Der Doctor prüft, ob Plugin, Hooks, Runtimes und lokale Suche korrekt funktionieren. 

Du kannst Context Mode auch global installieren:

npm install -g context-mode

und es als MCP-Server in unterstützten Clients wie Cursor, Gemini CLI, GitHub Copilot CLI, JetBrains und weiteren registrieren. 

Sobald es läuft, kannst du mit seinen Stats-Tools sehen, wie viel Kontext du einsparst.

Context Mode ist besonders nützlich für langlaufende, toolintensive Agents, bei denen Browserergebnisse, Logs, Dateizugriffe, MCP-Responses und andere Zwischendaten sonst ständig das Kontextfenster füllen würden.

Vergleich der vier Token-Spar-Tools

Die vier Tools setzen an unterschiedlichen Stellen des Coding-Agent-Workflows an – von dem, was der Agent schreibt, bis zu dem, wie viel Tool-Output im Kontext verbleibt.

Am einfachsten merkst du dir den Unterschied: 

• Caveman reduziert, was der Agent sagt
• Ponytail reduziert, was er baut
• RTK reduziert, was das Terminal zurückschickt
• Context Mode reduziert, was an Tool-Ergebnissen im Kontext bleibt.

Kannst du diese Tools kombinieren?

Ja, aber ich würde nicht alles von Anfang an stapeln.

Besser ist es, mit Ponytail zu starten. 

Es ist leicht in Coding-Agents einzubinden und reicht für viele Workflows bereits aus. Ich nutze es mit Tools wie Zcode, Claude Code und Codex und bin mit der Reduktion zufrieden.

Wenn du weitergehen willst, probiere Ponytail + Caveman. Ponytail reduziert unnötigen Code, Caveman überflüssige Erklärungen – eine gute Ergänzung.

Wenn in deinem Workflow weiterhin viele tokenintensive Outputs aus Tests, Logs, Git oder Terminalbefehlen entstehen, probiere Ponytail + Caveman + RTK.

Passt RTK nicht, vor allem wenn du viele MCP-Tools, Browser-Tools, APIs oder andere große Tool-Outputs nutzt, probiere stattdessen Ponytail + Caveman + Context Mode.

Es gibt keine perfekte Kombination für alle. 

Ziel ist, zu experimentieren und das Setup zu finden, das dir weniger Tokenverbrauch ohne Einbußen bei der Performance deines Coding-Agenten bringt. Für manche reicht Ponytail allein. Für andere ist die Kombination aus zwei oder drei Tools besser.

Weitere Wege, Tokenverbrauch und Kosten zu senken

Du brauchst nicht immer ein weiteres Tool. 

Claude Code bringt bereits Features mit, die Kontext klein halten und unnötige Ausgaben vermeiden helfen.

Deaktiviere Memory, wenn du es nicht brauchst

Claude Code kann Erinnerungen aus früheren Sitzungen automatisch speichern und laden. Für kurze oder isolierte Aufgaben bläht das den Kontext unnötig auf.

Führe aus:

/memory

Dort kannst du die Auto-Memory deaktivieren oder veraltete Infos entfernen.

Lange Sitzungen komprimieren

Wenn eine Sitzung wächst, trägt Claude Gesprächshistorie, Dateiinhalte und Tool-Outputs mit. Claude Code komprimiert automatisch, aber du kannst es früher anstoßen:

/compact

Du kannst auch festlegen, was wichtig ist:

/compact keep the implementation plan and latest test results

Besonders hilfreich, wenn ein Teil der Aufgabe erledigt ist, du aber in derselben Sitzung weiterarbeiten willst. 

Neu starten, wenn sich die Aufgabe ändert

Manchmal lohnt Komprimieren nicht. Wechselst du zu einer ganz anderen Aufgabe, nutze:

/clear

Das startet mit leerem Gesprächskontext statt irrelevante Historie mitzuschleppen. Anthropic weist auch darauf hin, dass ein frischer Start teils besser ist, als eine lange Sitzung immer wieder zu komprimieren.

Nicht genutzte MCP-Server deaktivieren

Auch MCP-Tools verbrauchen Kontext. Claude Code verzögert inzwischen volle MCP-Tool-Schemata standardmäßig, aber ungenutzte Server erzeugen dennoch Overhead.

Nutze: /mcp, um verbundene Server zu prüfen und aktuell unnötige zu deaktivieren. 

Mit /context siehst du außerdem, wie viel Platz die einzelnen Teile der Sitzung belegen.

CLAUDE.md klein halten

CLAUDE.md wird in Claudes Kontext geladen – mach daraus kein riesiges Projekt-Handbuch. 

Behalte nur Anweisungen, die Claude wirklich über Aufgaben hinweg braucht, etwa wichtige Konventionen, Befehle und Projektregeln.

Nutze /context, um zu prüfen, wie viel Platz deine Memories und Instruktionsdateien belegen. Für Ordner-spezifische Instruktionen unterstützt Claude Code gezieltere Regeln, statt alles in CLAUDE.md zu packen. 

Für einfache Aufgaben ein günstigeres Modell nutzen

Du brauchst nicht für jeden Edit das teuerste Modell. 

Die Doku von Claude Code empfiehlt Sonnet für die meisten Coding-Aufgaben und Opus für schwierigere, architektonische oder reasoning-lastige Arbeiten.

Umschalten kannst du mit:

/model

Für einfache Subagent-Aufgaben kannst du außerdem Haiku konfigurieren. 

Fazit

Das Beste an diesen Tools: Sind sie einmal eingerichtet, erfordern sie kaum Aufwand. 

Je nach Tool musst du dir keinen Slash-Befehl merken oder es für jede Aufgabe manuell aktivieren. 

Ponytail lenkt zu schlankeren Implementierungen, Caveman hält Antworten knapp, RTK komprimiert Terminal-Output, und Context Mode verhindert, dass große Tool-Ergebnisse den aktiven Kontext fluten. 

Nach der Konfiguration passiert vieles davon einfach im Rahmen deines normalen Coding-Workflows.

Du siehst den Effekt oft in der Run-Summary, im generierten Code, in der Terminalausgabe oder in den Kontext-Statistiken. 

Der Agent erledigt die gleiche Arbeit – nur mit weniger unnötigem Code, weniger Erzähltext, kleineren Toolantworten oder weniger mitgeschleppten Infos zwischen den Schritten.

Das Beste: Du kannst diese Tools auch kombinieren. 

Aber alle vier zu stapeln heißt nicht automatisch minimalen Tokenverbrauch. Sie adressieren verschiedene Teile des agentischen Coding-Workflows, und der Nutzen hängt stark von Agent, Modell, Repo und Aufgabenart ab.

Ich empfehle, sie in deiner eigenen Coding-Umgebung auszuprobieren. Starte mit einem Tool, miss den Effekt und füge bei Bedarf ein weiteres hinzu, wenn noch offensichtliche Verschwendungen bleiben. 

Vielleicht reicht ein einzelnes Tool für deinen Workflow – oder zwei bis drei im Zusammenspiel liefern bessere Ergebnisse.

Ich persönlich nutze Ponytail in den meisten meiner Coding-Workflows. Es ist schnell eingerichtet, und der Agent versteht zügig, wie er damit arbeiten soll. 

Meist setze ich es mit Zcode von Z.ai ein. Es hält Implementierungen fokussiert, ohne dass ich meine Prompts groß ändern muss.

Am Ende geht es bei der Reduktion des Tokenverbrauchs nicht darum, den Agenten weniger Nützliches tun zu lassen. Es geht darum, Verschwendung rund um die eigentliche Arbeit zu entfernen. 

Probiere Caveman, Ponytail, RTK und Context Mode einzeln und in Kombination, miss die Effekte in deinem Workflow und behalte das Setup, das für dich das beste Verhältnis aus Tokenverbrauch, Codequalität und Agent-Performance liefert.

Wenn du mehr darüber lernen willst, wie KI-Agents funktionieren, schau dir den AI Agent Fundamentals Lernpfad an.