MCP vs. CLI: Warum Agenten mit Token-Fressern kämpfen — ein Test

KI-Agenten, die Werkzeuge wie Dateizugriffe oder API-Aufrufe nutzen, stehen vor einer grundlegenden Entscheidung: Soll man das neue Model Context Protocol (MCP) einsetzen oder auf bewährte direkte CLI-Befehle setzen? Während MCP als zukunftsweisender Standard gilt, offenbart ein aktueller Test ein entscheidendes Manko: die Token-Effizienz.

MCP vs. CLI: Ein direkter Vergleich

Ich habe ein einfaches Dateilese-Werkzeug entwickelt und beide Ansätze unter realistischen Bedingungen getestet. Die Ergebnisse zeigen ein überraschendes Ungleichgewicht:

• MCP (strukturiert): ~3.400 Tokens pro Aufruf bei durchschnittlich 280 Millisekunden Latenz
• CLI (direkt): ~200 Tokens pro Aufruf bei durchschnittlich 45 Millisekunden Latenz

Das Verhältnis von 17:1 bei den Tokens (und sogar 6:1 bei der Geschwindigkeit) wirft Fragen auf: Warum ist MCP so viel teurer – und wann lohnt es sich trotzdem?

Die drei Hauptgründe für den Token-Overhead

Der hohe Token-Verbrauch von MCP lässt sich auf drei zentrale Mechanismen zurückführen:

1. Tool-Schemata in jedem Request

Jeder Aufruf überträgt das komplette JSON-Schema aller verfügbaren Werkzeuge. Selbst bei einem einfachen Dateilese-Werkzeug summiert sich das schnell:

{
  "name": "read_file",
  "description": "Liest den Inhalt einer Datei an einem angegebenen Pfad",
  "parameters": {
    "type": "object",
    "properties": {
      "path": {
        "type": "string",
        "description": "Pfad zur zu lesenden Datei"
      }
    },
    "required": ["path"]
  }
}

Bei 10 oder mehr Werkzeugen summieren sich schnell 8.000+ Tokens allein durch die Schemata – und das bei jedem einzelnen Aufruf.

2. Strukturierte Antwortformate

MCP verpackt jede Antwort in ein standardisiertes Format mit Metadaten, Statuscodes und typisierten Inhalten. Selbst eine einfache Fehlermeldung wie "Datei nicht gefunden" wird zu einem 200-Token-JSON-Objekt.

3. Protokoll-Overhead durch den Round-Trip

Jeder MCP-Aufruf durchläuft mehrere Schritte:

• Request an den Server
• Parsen der Anfrage
• Ausführung des Befehls
• Formatierung der Antwort
• Rückgabe an den Client
• Parsen der Antwort
• Extraktion der eigentlichen Daten

Jeder dieser Schritte fügt Tokens für Protokoll-Rahmen hinzu – ein Prozess, der bei direkten CLI-Befehlen komplett entfällt.

Der ungeschönte Vorteil der CLI

Ein direkter CLI-Befehl zeigt den Unterschied deutlich:

cat /pfad/zur/datei.txt

Hier gibt es keine Schemata, keine Metadaten, keine zusätzlichen Tokens – nur Rohdaten. Die Einfachheit schlägt sich in Effizienz nieder.

Wann MCP trotzdem die bessere Wahl ist

Trotz des Token-Overheads bietet MCP entscheidende Vorteile in spezifischen Szenarien:

• Dynamische Werkzeugsuche: Agenten können verfügbare Werkzeuge automatisch entdecken und nutzen – ideal für unvorhersehbare Arbeitsabläufe.
• Wiederverwendbare Werkzeugserver: Ein MCP-Server kann von mehreren Agenten oder Projekten genutzt werden, was die Wartung vereinfacht.
• Granulare Sicherheit: MCP ermöglicht feinere Zugriffssteuerungen als einfache CLI-Befehle.
• Teamübergreifende Zusammenarbeit: Standardisierte Werkzeugdefinitionen erleichtern die Zusammenarbeit in größeren Projekten.

Der praktische Kompromiss: Ein hybrider Ansatz

Nach den Testergebnissen setze ich mittlerweile auf eine kombinierte Strategie, die die Vorteile beider Methoden nutzt:

• Einfache, häufige Operationen (z. B. Dateizugriffe oder Basis-Befehle) → CLI
• Komplexe, strukturierte Operationen (z. B. Datenbankabfragen oder API-Aufrufe) → MCP
• Caching nutzen: Unabhängig vom Ansatz – doppelte Aufrufe vermeiden

Diese Methode reduzierte meinen Token-Verbrauch um 60 %, während die Vorteile von MCP dort zum Einsatz kommen, wo sie wirklich zählen.

Langfristige Einsparungen im Praxistest

Über einen vollständigen Arbeitstag mit 847 Werkzeugaufrufen zeigte sich folgendes Bild:

| Metrik | MCP-only | Hybrid-Ansatz | |----------------------------|---------------|-----------------| | Gesamtzahl der Aufrufe | 847 | 847 | | Token-Kosten (Werkzeuge) | 2,88 Millionen | 1,15 Millionen | | Kosten (@ 3,00 €/1 Mio. Token) | 8,64 € | 3,45 € | | Ersparnis | — | 5,19 € pro Tag (60 %) |

Die Zahlen sprechen für sich: Selbst bei identischer Funktionalität lassen sich durch intelligente Wahl des Ansatzes erhebliche Kosten einsparen.

Wichtige Erkenntnisse für die Praxis

Die Messungen werfen ein klares Licht auf die Token-Effizienz von KI-Agenten:

• Messen Sie Ihre eigenen Kosten: Die Token-Nutzung hängt stark von der Komplexität der Werkzeuge ab – einfache Befehle sind günstiger.
• Nicht jedes Werkzeug braucht MCP: Für Routineaufgaben ist die CLI oft die effizientere Wahl.
• Schema-Größe optimieren: Je detaillierter das MCP-Schema, desto höher der Token-Verbrauch. Halten Sie Parameterbeschreibungen so knapp wie möglich.
• Hybride Lösungen sind pragmatisch: Nutzen Sie MCP dort, wo es strukturierte Vorteile bietet, und setzen Sie auf CLI für einfache Operationen.
• Der 17:1-Faktor ist variabel: Bei einfachen Werkzeugen fällt der Unterschied geringer aus, bei komplexen steigt er.

Fazit: Effizienz vor Dogma

MCP ist zweifellos ein mächtiger Standard, der die Interoperabilität und Sicherheit von KI-Agenten revolutioniert. Doch wie bei vielen technologischen Entscheidungen ist der richtige Einsatz entscheidend. Wer Token-Kosten minimieren will, sollte nicht blind auf den neuen Standard setzen, sondern bewusst zwischen MCP und CLI abwägen – oder eine hybride Lösung wählen.

Die Zukunft der KI-Agenten liegt nicht in der ausschließlichen Nutzung eines Ansatzes, sondern darin, die Stärken beider Welten intelligent zu kombinieren. Haben Sie bereits Ihre eigenen Token-Effizienz-Messungen durchgeführt? Welche Erfahrungen haben Sie mit MCP und CLI gemacht?