Startseite / Artikel

Hochpreisige Bezahlung für Warten: Vergleich von Abfragen, Blockaden und Aufgaben

Ein Vergleich von drei Möglichkeiten, wie ein Agent auf eine langsame Cloud-Aufgabe warten kann: Polling, Blockieren und MCP-Aufgaben, der Token-Kostenfaktor für jede Methode sowie Richtlinien für Tool-Entwickler.

Verlag: REACTAPP.TOP8 Min. Lesezeit1807 Wörter

Quellen: Your Agent Doesn’t Know How to Wait

Fast jede Cloud-Infrastruktur-API weist diese Besonderheit auf. Ein Create-Aufruf gibt keinen fertigen Ressourcen zurück, sondern eine Quittung:

{
  "name": "operations/abc-123",
  "status": "RUNNING",
  "done": false
}

Die Datenbank benötigt mehrere Minuten, um bereit zu sein, und in der Zwischenzeit besitzt der Anrufer lediglich eine Tracking-ID. Dies ist das Muster der lang andauernden Operationen, kurz LRO, und es tritt sowohl bei der Bereitstellung von Infrastruktur, beim Training von Modellen, bei Datenbankmigrationen als auch bei der Videocodec-Konvertierung auf. Für einen Menschen am Terminal ist das Routine: Befehl ausführen, warten und sich einen Kaffee holen.

Für einen KI-Agenten stellt dies jedoch eine ernsthafte Konstruktionsentscheidung dar. Vergleiche von Methoden zur Bewältigung des Wartens zeigten einen Fünffachunterschied in den Kosten, ein Elfmal höheres Aufwand bei den erzeugten Ausgabetoken sowie erhebliche Konkurrenzengpässe. Die meisten Tool-Entwickler erkennen nicht, dass sie bei der Erstellung ihrer Tool-Definitionen eine bestimmte Vorgehensweise wählen. Der Vergleich umfasste drei Ansätze bei identischen Arbeitslasten mit demselben Modell: Polling innerhalb des Agentenloops, Blockieren auf der Serverseite sowie Übertragung des Wartens an eine von einem Harness verwaltete Aufgabe.

Warum Warten teuer ist

Ein Agent ist ein Sprachmodell, das in einer Schleife läuft. Er erhält ein Ziel sowie einige Werkzeuge, überlegt, ruft ein Werkzeug auf, prüft das Ergebnis und entscheidet, was zu tun ist. Jeder Zyklus stellt einen Schritt dar, und ein Schritt ist keine isolierte HTTP-Anfrage. Bei jedem Schritt wird der gesamte Dialog in das Kontextfenster eingegeben: der Systemprompt, jede Werkzeugg definition, das Ziel sowie alle früheren Aufrufe und Antworten. Die Gesamtkosten einer Aufgabe betragen daher ungefähr die Anzahl der Schritte multipliziert mit der Größe des Kontexts pro Schritt.

Stellen Sie sich nun vor, der Agent prüft den Status einer Operation. Er ruft get_operation auf und sieht „RUNNING“, wodurch eine vollständige Inferenz über alles Gesammelte erforderlich wird, um zu entscheiden, was als Nächstes zu tun ist. Er ruft erneut auf, sieht erneut „RUNNING“ und muss erneut eine vollständige Inferenz durchführen. Zur Implementierung einer Pause wird ein Frontier-Modell verwendet, dessen Kosten in Dollar pro Million Tokens angegeben werden.

Im Folgenden treten vier Begriffe immer wieder auf:

  • Schritte: Wie viele Tool-Aufrufe der Agent vornahm. Je weniger, desto besser.
  • In Rechnung gestellte Tokens: Die Kostenmetrik, bei der gepuffertes Kontextwissen günstiger bewertet wird – etwa ein Zehntel des Preises für frische Eingaben. Das ist die Zahl, die in der Cloud-Rechnung angegeben wird.
  • Tool-Verfügbarkeit: Alles, was der Agent aufrufen darf, sei es über einen MCP-Server oder durch das Eingeben von CLI-Befehlen in eine Shell.
  • Aufgaben: Hintergrundarbeiten, die an das Harness oder den MCP-Runtime übergeben werden, um den Hauptthread des Agents frei zu halten.

Wie der Benchmark durchgeführt wurde

Der Test nutzte Evalbench gegen denselben Cloud-Datenbank-Steuerungsplan in drei Konfigurationen:

  • MCP Toolbox, ein Server mit einer vorgefertigten Datenbankkonfiguration.
  • Ein einfacher MCP-Server, der grundlegende create-, read-, update- und delete-Tools sowie den Status der Operationen bereitstellt.
  • Eine Ersatz-CLI-Einrichtung (gcloud) ohne MCP-Tools, bei der der Agent auf Shell-Befehle zurückgreift.
  • Es gab 12 Aufgaben pro Schwierigkeitsstufe, die mit Claude Opus auf einer festgelegten CLI-Version ausgeführt wurden, wobei ein automatisierter Bewertungssystem die Punkte vergab. Unter den schwierigen Aufgaben dauerten zwei besonders lange: das Klonen einer Instanz sowie die Einrichtung einer hochverfügbaren Instanz. Die drei Einrichtungsvarianten handhaben das Warten auf drei verschiedene Arten.

    Die drei Wartemuster

    Abfragen innerhalb der Schleife

    Der Server gibt eine Operation-ID zurück, und der Agent fragt weiterhin innerhalb seiner Überlegungsschleife nach:

    create_instance()      → operations/abc-123
    get_operation(abc-123) → RUNNING
    get_operation(abc-123) → RUNNING
    ... ×10 ...
    get_operation(abc-123) → DONE
    

    Zehn vollständige Durchläufe durch den Modellkontext nur, um herauszufinden, dass die Klonierung noch in Bearbeitung ist.

    Blockade auf dem Server

    Der Server stellt ein Tool zur Verfügung, das die Verbindung offen hält, bis die Operation einen endgültigen Zustand erreicht hat:

    create_instance()           → operations/abc-123
    wait_for_operation(abc-123) → DONE   (one call, eleven minutes later)
    

    Das ist ein erster Schritt. Die Inaktivitätszeit verbringt sich auf einem Server, der mit einem winzigen Bruchteil eines Cent pro Stunde abgerechnet wird – und nicht innerhalb eines Modellkontexts, der in Dollar pro Million Token berechnet wird. Das Problem ist, dass das Blockieren streng seriell erfolgt und während der Anruf offen ist, der Thread des Agents eingefroren bleibt.

    Aufgaben an den Task-Handler übergeben

    Anstatt den Agenten zu blockieren oder Tokens durch Abfragen zu verbrauchen, leitet der Agent die Operation an einen Hintergrund-Task-Runner weiter:

    Bash(cmd, run_in_background: true)  → task_id: task-8921
    ... agent configures network rules, audits schemas, writes migration scripts ...
    TaskOutput(task-8921, block: true)  → done
    

    Durch die MCP Tasks-Erweiterung werden das Starten der Arbeit sowie die Verarbeitung des Ergebnisses zu separaten Vorgängen. Der Agent startet die Aufgabe, erhält einen Handle für die Aufgabe und kümmert sich um andere Aufgaben. Wenn er schließlich auf die Datenbank zugreifen muss, prüft er den Handle oder wartet auf ein Abschlusssignal. Nur dieses Muster ermöglicht es einem Agenten, gleichzeitig auf mehrere Operationen zu warten oder eine lange Wartezeit mit produktiver Berechnung zu überbrücken.

    Kosten des Klon-Tests

    Bei der Klon-Bewertung (eine Instanz klonen, bis sie bereit ist warten, den Zustand überprüfen) dauert die zugrunde liegende Operation in jedem Umfeld etwa 13 Minuten in der echten Zeit. Die Unterschiede in der reellen Zeit waren gering, doch die Token-Kosten unterschieden sich stark:

    • Die MCP Toolbox mit ihrer blockierenden Wartezeit erzielte in allen Metriken die besten Ergebnisse: 4 Schritte, 211.854 abgerechnete Tokens, 765 Sekunden.
    • Das einfache MCP-Server-Polling zehn Mal dauerte am längsten, insgesamt 864 Sekunden bei 23 Schritten.
    • DieFallback-CLI hatte den höchsten Overhead: 328.316 abgerechnete Tokens und 14.108 Ausgabetokens über 19 Schritte.

    Durch das einzige blockierende Warten verringerten sich die Schritte um 80 %, die abgerechneten Tokens um 26 % im Vergleich zur einfachen Polling-Methode, und die Kosten um 35 % im Vergleich zur Fallback-CLI. Zudem wurde die Aufgabe zuerst abgeschlossen, da die Polling-Agenten immer wieder zum zusätzlichen Verarbeiten geweckt wurden.

    Die auffälligste Zahl sind die Ausgabetokens – sie waren bei der CLI 11-mal höher. Da es keine MCP-Tools gab, musste der Agent seinen eigenen Wiederholungs-Skript in Bash schreiben:

    while true; do
      st=$(cloud-cli operations list --project=production-db \
           --instance=staging-replica --format='value(status)' | head -1)
      [ "$st" = "DONE" ] && break
      sleep 20
    done
    

    Es wurde diese Schleife dreimal in leicht unterschiedlichen Formen ausgeführt, da jeder Versuch fehlschlug, da eine saubere Überwachung nicht möglich war. Schließlich gab man auf und stellte einen Wecktimer auf fünf Minuten ein. Ein autonomes Modell verbrauchte 14.000 Ausgabetoken, um wait_for_operation von Grund auf neu zu entwickeln – und tat dies schlecht. Ein Agent, dem eine Warteoption verwehrt wird, wird sie auf hohen Kosten selbst erstellen, wobei das Ergebnis schlechter ist als das unveröffentlichte Tool.

    Richtlinien für API- und Tool-Entwickler

    Die Gestaltung für Agenten bedeutet, die REST- und gRPC-Konventionen im Licht einer Bedingung neu zu überdenken, mit der sie bisher nie konfrontiert waren: Jeder freigegebene Byte wird bei jedem Schritt erneut gelesen. Jede der folgenden Empfehlungen beruht auf messbaren Ergebnissen.

    Bieten Sie ein gestuftes Wartemodell an

    Unterschiedliche Situationen erfordern unterschiedliche Wartezeiten – daher sollten alle drei Ebenen bereitgestellt werden, damit der Agent wählen kann:

    create_instance()                       → { "operation": "operations/abc-123", "done": false }
    get_operation(id)                       → Tier 1: inspect status, resume after interruption
    wait_for_operation(id, timeout_seconds) → Tier 2: the 90% single-instance case
    create_instance(async)                  → Tier 3: durable handle for parallel, fleet-wide work
    

    Die Bereitstellung aller drei fügt fast keinen zusätzlichen Aufwand hinzu, doch der Unterschied zwischen ihnen machte 55 % der Gesamtkosten bei einer einzigen Klonierungsaufgabe aus. Die Beschränkung auf die erste Ebene zwang den CLI-Agenten, seinen eigenen Wiederholungsmechanismus zu entwickeln, was 14.108 Ausgabetoken kostete.

    Platzieren Sie die Operation-ID im JSON-Body

    Klassischer REST platziert Operationssсылungen in Header wie Location oder Operation-Location. Moderne Tool-Aufrufschichten, einschließlich MCP, OpenAI Tools und LangChain, verwenden oft keine HTTP-Header mehr und übergeben dem Modell nur den JSON-Payload.

    Falls die ID im Anfragekörper fehlt, versagt das Modell nicht offensichtlich. Stattdessen wendet es sich direkt an die Zielressource, anstatt die Aktion zu überprüfen. Dies ist kostspieliger und unklarer, da Ressourcendienstpunkte während der Initialisierung oft 404-Fehler oder veraltete Daten zurückgeben, wodurch eine aktive Verarbeitung nicht von einem Versagen zu unterscheiden ist. Bei einem Lauf führte dies zu 221 wiederholten Aufrufen von get_instance.

    Explizite Zeitlimits mit strukturierten Teilergebnissen hinzufügen

    Unbegrenztes Blockieren birgt echte Risiken: abgebrochene Verbindungen, 300-sekündige Abschaltungen durch Load Balancer sowie Aufgaben, die dauerhaft blockiert bleiben. Das Tool mit den niedrigsten Gesamtkosten hatte kein Zeitlimit und blockierte in einem Fall sechzehn Minuten lang, wodurch der Agent ohne Notfallmaßnahmen dastand, falls der Aufruf stecken blieb.

    Die Lösung ist ein Parameter namens timeout_seconds mit einem Standardwert von etwa 300. Bei Erreichen des Limits sollte anstelle des Werfens einer Ausnahme ein strukturierter Status zurückgegeben werden, der kein Fehler ist:

    {
      "done": false,
      "operation": "operations/abc-123",
      "elapsed_seconds": 300,
      "status": "RUNNING",
      "metadata": { "percent_complete": 65 }
    }
    

    Nun kann das Modell den Fortschritt überwachen und entscheiden, ob es erneut warten, die Aufgabe im Hintergrund ausführen oder dem Benutzer mitteilen soll, ohne Fehlerbehandlungsprozeduren auszulösen. Dieses eine Feld unterscheidet ein blockierendes Warten von einem Risiko-Einsatz.

    Entwurf für Aufgaben und asynchrone Mechanismen

    Ein Serverentwickler, der MCP implementiert, erhält die standardisierte Form des dritten Musters über die Tasks-Erweiterung. Mehrere Punkte sind wichtig:

    • Lassen Sie den Server den Ausführungsweg bestimmen. Aufgaben werden vom Server gesteuert. Deklarieren Sie io.modelcontextprotocol/tasks und geben Sie einen CreateTaskResult anstelle eines normalen Ergebnisses zurück, wenn eine Anfrage lange dauern wird. Verlangen Sie nicht, dass Aufrufer ein asynchrones Flag übergeben, da der Client dies während der Funktionalitätsverhandlung aktiviert.
    • Übergeben Sie strukturierte Metadaten zum Handhaben: einen taskId, einen Anfangszustand, ttlMs sowie pollIntervalMs, und stellen Sie sicher, dass die Aufgabe vor dem Senden der Antwort dauerhaft erstellt wird. Auf diese Weise können die Steuermechanismen den Fortschritt überwachen, ohne das Modell zu wecken, und die Clients können nach einem Absturz wiederhergestellt werden.
    • Unterstützung von Abschlussbenachrichtigungen. Sofern das Übertragungsprotokoll es zulässt, werden Push-Benachrichtigungen/Aufgaben verwendet anstelle von Client-Polling. Polling bleibt als Ersatzoption bestehen, doch Benachrichtigungen vermeiden unnötige Hin- und Herbewegungen.
    • Speichern Sie den Zustand abgeschlossener Aufgaben und Operationen mindestens 24 bis 48 Stunden lang. Wenn der Kontext eines Agenten während des Wartens komprimiert wird und dieser später eine abgeschlossene Aufgabe abfragt, sollte er das Ergebnis erhalten und nicht eine 404-Fehlermeldung.

    Zählen Sie die Schemata

    Jedes installierte Tool verursacht Kosten bei jedem Schritt jeder Aufgabe – auch bei Aufgaben, bei denen es nie verwendet wird. Die Kosten liegen in etwa bei Schritten mal Größe des Kontexts. Ein blockierendes Warten verbessert den ersten Faktor, während ein übermäßiger Schema-Umfang den Gewinn durch den zweiten Faktor wieder aufheben kann. Ein Server mit den wenigsten Schritten kann dennoch die meisten Token verbrauchen, wenn große Tool-Schemata bei jedem dieser Schritte im Kontext vorhanden sind. Durch eine große Tool-Oberfläche, das Aufladen von Definitionen nach Bedarf, die Verwendung von Fähigkeiten oder das Hinzufügen einer Tool-Suche bleibt das stets vorhandene Schema klein.

    Die Schlussfolgerung

    Warten ist eine architektonische Entscheidung, die die Wirtschaftlichkeit eines Agents prägt – und keine geringfügige Optimierung. Das Ersetzen von tokenintensivem Polling durch gestufte, blockierende oder auf Aufgaben basierende Wartezeiten verringert die Overhead-Kosten, und eine kompaktere Tool-Oberfläche hilft Agents dabei, sich zu skalieren, ohne dafür ein Grenzmodell bezahlen zu müssen, das Sekunden zählt.