Strona główna / Artykuły

Agenci płacą wysoką cenę za czekanie: porównanie ankietowania, blokowania i zadań

Przykład trzech sposobów, w jakie agent może czekać na wolną operację w chmurze: polling, blokowanie i zadania MCP, koszt tokena dla każdego z nich oraz zasady dla projektantów narzędzi.

Wydawca: REACTAPP.TOP8 min czytania1807 słów

Źródła: Your Agent Doesn’t Know How to Wait

Prawie każda API infrastruktury chmurowej zawiera tę samą funkcję pauzy. Wywołanie typu create nie zwraca gotowego zasobu – zwraca jedynie potwierdzenie:

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

Baza danych potrzebuje kilku minut, aby się uruchomić, a w tym czasie jedynym elementem, jaki posiada osoba dzwoniąca, jest identyfikator śledzenia. To właśnie jest wzorzec długotrwałych operacji, czyli LRO, który występuje zarówno przy przygotowywaniu infrastruktury, szkoleniu modeli, migracjach bazy danych, jak i kodowaniu wideo. Dla człowieka pracującego przy terminalu jest to rutyna: wykonać polecenie, poczekać i napić się kawy.

Dla agenta AI stanowi to poważny problem projektowy. Porównania różnych sposobów radzenia sobie z oczekiwaniem pokazały 5-krotną różnicę w kosztach, 11-krotny wzrost liczby generowanych tokenów oraz poważne problemy z jednoczesnością wykonywania zadań. Większość twórców narzędzi nie zdaje sobie sprawy, że przy definiowaniu swoich narzędzi wybiera określoną ścieżkę działania. Porównanie obejmowało trzy podejścia do identycznych obciążeń z użyciem tego samego modelu: sprawdzanie stanu wewnątrz pętli agenta, blokowanie na serwerze oraz przekazanie zadania do obsługi przez specjalny mechanizm.

Dlaczego oczekiwanie jest kosztowne

Agent to model językowy działający w pętli. Otrzymuje cel oraz niektóre narzędzia, rozważa różne opcje, wywołuje narzędzie, sprawdza wynik i decyduje, co robić dalej. Każdy cykl stanowi jeden krok, a krok to nie jest izolowana prośba HTTP. Na każdym kroku cała rozmowa jest ponownie wprowadzana do okna kontekstowego: prompt systemu, każda definicja narzędzia, cel oraz wszystkie wcześniejsze wywołania i odpowiedzi. Całkowity koszt zadania wynosi zatem w przybliżeniu liczbę kroków pomnożoną przez rozmiar kontekstu na każdym kroku.

Wyobraźmy teraz sobie, że agent sprawdza stan operacji. Wywołuje funkcję get_operation i widzi status RUNNING; aby zdecydować, co robić dalej, musi przeprowadzić pełną analizę wszystkich zgromadzonych danych. Wywołuje funkcję ponownie, ponownie widzi status RUNNING i musi zapłacić za kolejną pełną analizę. Do implementacji funkcji sleep używany jest model typu frontier, którego cena wynosi dolary za milion tokenów.

Poniżej pojawiają się cztery terminy:

  • Kroki: ile razy agent wykonał wywołania narzędzi. Im mniej, tym lepiej.
  • Tokeny opłacane: metryka kosztów, która tańsze ocenia kontekst z pamięci podręcznej, mniej więcej za jedną dziesiątą ceny świeżego wprowadzenia danych. To właśnie ta wartość jest widoczna w rachunku chmurowym.
  • Możliwości narzędzi: wszystko, do czego agent ma dostęp, czy to poprzez serwer MCP, czy poprzez wpisywanie poleceń CLI do wiersza poleceń.
  • Zadania: prace w tle przekazywane do narzędzia harness lub środowiska działania MCP, co zapobiega zablokowaniu głównego wątku agenta.

Jak przebiegał test benchmarkowy

W teście użyto Evalbench wobec tego samego planu sterowania bazy danych chmurowej w trzech konfiguracjach:

  • MCP Toolbox – serwer z z góry przygotowaną konfiguracją bazy danych.
  • Podstawowy serwer MCP oferujący proste narzędzia do tworzenia, odczytu, aktualizacji i usuwania danych oraz informacje o stanie operacji.
  • Alternatywne ustawienie CLI (gcloud), bez narzędzi MCP, w którym agent korzysta z poleceń wiersza poleceń.
  • Na każdym poziomie trudności było 12 zadań, wykonywanych za pomocą Claude Opus na ustalonej wersji CLI, przy czym ocenę przeprowadzał zautomatyzowany sędzia. Wśród trudnych zadań dwa trwały długo: klonowanie instancji oraz przygotowanie instancji o wysokiej dostępności. Te trzy rozwiązania radzą sobie z oczekiwaniem na trzy różne sposoby.

    Trzy wzorce oczekiwania

    Pytanie wewnątrz pętli

    Serwer zwraca identyfikator operacji, a agent nadal zadaje pytania w ramach swojej pętli rozumowania:

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

    Te pełne przejścia przez kontekst modelu tylko po to, by dowiedzieć się, że klonowanie wciąż trwa.

    Blokada na serwerze

    Serwer dostarcza narzędzie, które utrzymuje połączenie otwarte, dopóki operacja nie osiągnie stanu końcowego:

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

    To jest jeden krok. Czas bezczynności jest spędzany na serwerze, za który pobierana jest niska opłata w wysokości znikomej części centa na godzinę, a nie w kontekście modelu, za który płaci się dolarami za milion tokenów. Problem polega na tym, że blokowanie odbywa się ściśle sekwencyjnie, a dopóki połączenie jest otwarte, wątek agenta jest zamarznięty.

    Zadania przekazywane do narzędzia

    Zamiast blokować agenta lub marnować tokeny na polecenia typu poll, agent przekazuje operację do w tle działającego wykonywacza zadań:

    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
    

    Dzięki rozszerzeniu MCP Tasks rozpoczynanie pracy i odbieranie jej rezultatu stają się odrębnymi zdarzeniami. Agent uruchamia zadanie, otrzymuje identyfikator lekkiego zadań i przechodzi do innych użytecznych czynności. Gdy w końcu potrzebuje bazy danych, sprawdza ten identyfikator lub czeka na sygnał zakończenia. Tylko ten model pozwala agentowi czekać na kilka operacji jednocześnie lub łączyć długie oczekiwanie z produktywnymi obliczeniami.

    Koszt testu klonowania

    Podczas oceny klonowania (sklonowanie instancji, czekanie aż będzie gotowa, potwierdzenie sprawności) podstawowa operacja trwa około 13 minut w czasie rzeczywistym we wszystkich środowiskach. Różnice w czasie rzeczywistym były niewielkie, natomiast aspekty ekonomiczne związane z tokenami znacznie się różniły:

    • MCP Toolbox z blokującym czekaniem osiągnął najlepsze wyniki we wszystkich metrykach: 4 kroki, 211 854 opłaconych tokenów, 765 sekund.
    • Bazowy serwer MCP wykonujący dziesięć prób pollingu zajmował najwięcej czasu – 864 sekundy przy 23 krokach.
    • CLI awaryjne miało największe obciążenie: 328 316 opłaconych tokenów i 14 108 tokenów wyjściowych w ciągu 19 kroków.

    Jedno długotrwałe oczekiwanie skróciło liczbę kroków o 80%, liczbę opłaconych tokenów o 26% w porównaniu z podstawowym mechanizmem polling, a koszty o 35% w porównaniu z CLI awaryjnym. Ponadto rozwiązanie to ukończyło zadanie jako pierwsze, ponieważ agenty typu polling ciągle się budziły, aby przeprowadzić dodatkowe iteracje rozumowania.

    Najbardziej uderzającą wartością są tokeny wyjściowe – były one 11 razy wyższe w przypadku CLI. Bez narzędzi MCP agent musiał napisać własny skrypt ponawiania prób w języku bash:

    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
    

    Napisano, że ten pętla została wykonywana trzy razy w nieco różnych formach, ponieważ każda próba nie powiodła się ze względu na problemy z dokładnym monitorowaniem. W końcu zrezygnowano i ustawiono timer budzący za pięć minut. Model autonomiczny wydał 14 000 tokenów na ponowne stworzenie funkcji wait_for_operation od zera, i zrobił to słabo. Agent, któremu zabrano możliwość czekania, będzie musiał ją sam stworzyć, co będzie kosztować wiele, a rezultat będzie gorszy niż w przypadku narzędzia, które nie zostało wydane.

    Wskazówki dla projektantów API i narzędzi

    Projektowanie z myślą o agentach oznacza ponowne przemyślenie konwencji REST i gRPC w kontekście ograniczenia, z którym one nigdy się nie spotkały: każdy ujawniony bajt jest ponownie odczytywany na każdym kroku. Każda z poniższych praktyk ma swoje źródło w czymś mierzalnym.

    Zaproponuj model czekania w kilku poziomach

    Różne sytuacje wymagają różnego czasu oczekiwania, dlatego należy zapewnić wszystkie trzy poziomy i pozwolić agentowi na wybór:

    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
    

    Użycie wszystkich trzech metod prawie nie zwiększa nakładów, a jednak różnica pomiędzy nimi stanowiła 55% całkowitego kosztu w jednym zadaniu klonowania. Ograniczenie się do pierwszego poziomu zmusiło agenta CLI do stworzenia własnego mechanizmu ponawiania prób, co kosztowało 14 108 tokenów wyjściowych.

    Umieszczenie ID operacji w ciele JSON

    Klasyczny REST umieszcza linki do operacji w nagłówkach takich jak Location lub Operation-Location. Współczesne warstwy wywoływania narzędzi, w tym MCP, OpenAI Tools i LangChain, często pomijają nagłówki HTTP i przekazują modelowi jedynie treść JSON.

    Gdy identyfikator nie występuje w ciele żądania, model nie zwraca wyraźnego komunikatu o błędzie. Zamiast sprawdzać operację, przechodzi na bezpośrednie zapytanie do docelowej zasoby. Jest to droższe i bardziej niejasne, ponieważ punkty końcowe zasobów często podczas inicjalizacji zwracają błędy 404 lub przestarzałe dane, przez co procesowanie trwa bez różnicy od przypadku błędu. W jednym przypadku doprowadziło to do 221 powtórzonych wywołań funkcji get_instance.

    Dodaj wyraźne limity czasowe z ustrukturyzowanymi częściowymi wynikami

    Nieograniczone blokowanie niesie rzeczywiste ryzyko: przerwanych połączeń, czasowego ograniczenia przez balanser obciążeń wynoszącego 300 sekund oraz zadań zamrożonych na zawsze. Narzędzie do oczekiwania o najniższych ogólnych kosztach nie miało żadnego limitu czasowego i w jednym przypadku blokowało przez szesnaście minut, co sprawiło, że agent nie miał żadnego planu awaryjnego na wypadek zatrzymania połączenia.

    Rozwiązaniem jest parametr timeout_seconds, którego domyślna wartość wynosi około 300. Po osiągnięciu tego limitu należy zwrócić ustrukturyzowany stan, który nie jest błędem, zamiast rzucać wyjątek:

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

    Teraz model może sprawdzić postęp i zdecydować, czy czekać ponownie, w tle kontynuować pracę, czy poinformować użytkownika, bez uruchamiania procedur obsługi błędów. To właśnie to pole odróżnia blokujące czekanie od ryzykownego podejścia.

    Projektowanie z myślą o zadaniach i mechanizmach asynchronicznych

    Autor serwera implementujący MCP uzyskuje standaryzowaną formę trzeciego wzorca poprzez rozszerzenie Tasks. Istotne są kilka kwestii:

    • Niech serwer decyduje o ścieżce wykonywania. Zadania są kierowane przez serwer. Ogłoś protokół io.modelcontextprotocol/tasks i zwróć CreateTaskResult zamiast zwykłego rezultatu, gdy żądanie będzie wymagało dużo czasu. Nie wymagaj od wywołujących przekazywania flagi asynchroniczności, ponieważ klient decyduje o tym podczas negocjacji możliwości.
    • Zwracaj strukturyzowane metadane identyfikatora: taskId, początkowy stan, ttlMs oraz pollIntervalMs, i upewnij się, że zadanie zostało trwale utworzone przed wysłaniem odpowiedzi. Dzięki temu narzędzia mogą śledzić postęp bez budzenia modelu, a klienci mogą się odzyskać po awarii.
    • Obsługuj powiadomienia o zakończeniu. Tam, gdzie transport na to pozwala, używaj powiadomień typu push/zadań zamiast polegać na pytaniach ze strony klienta. Pytania pozostają jako rozwiązanie awaryjne, ale powiadomienia eliminują niepotrzebne przejazdy tam i z powrotem.
    • Zachowuj stan zakończonych zadań i operacji przez co najmniej 24 do 48 godzin. Jeśli kontekst agenta zostanie skompresowany podczas oczekiwania, a później zapyta o zakończone zadanie, powinien otrzymać wynik, a nie błąd 404.

    Licz schematy

    Każde zainstalowane narzędzie obciąża kosztami każdy krok każdego zadania, włączając te, które go w ogóle nie wykorzystują. Koszt wynosi mniej więcej ilość kroków pomnożona przez rozmiar kontekstu. Czekanie blokujące poprawia pierwszy czynnik, natomiast nadmiar schematów narzędzi może zniwelować te korzyści dzięki drugiemu czynnikowi. Serwer z najmniejszą liczbą kroków może nadal zużywać najwięcej tokenów, jeśli przy każdym z nich w kontekście znajdują się duże schematy narzędzi. Dzięki dużym schematom narzędzi, ładowaniu definicji na żądanie, wykorzystywaniu umiejętności lub dodawaniu funkcji wyszukiwania narzędzi, zawsze obecne schematy pozostają małe.

    Główny wniosek

    Czekanie to decyzja architektoniczna, która kształtuje ekonomikę agenta, a nie drobna optymalizacja. Zastąpienie kosztownego pollingu czekaniem warstwowym, blokującym lub opartym na zadaniach zmniejsza nakłady, a lżejsze schematy narzędzi pomagają agentom skalować się bez konieczności płacenia za modely do liczenia sekund.

    Podobne materiały