Агенты дорого платят за ожидание: сравнение опросов, блокировок и задач
Критерии оценки трех способов, с помощью которых агент может ожидать завершения медленной операции в облаке: опрос, блокировка и задачи MCP, стоимость токенов для каждого способа, а также правила для разработчиков инструментов.
Источники: Your Agent Doesn’t Know How to Wait
Почти во всех API облачных инфраструктур присутствует один и тот же механизм приостановки. Запрос на создание не возвращает готовый ресурс — он возвращает квитанцию:
{
"name": "operations/abc-123",
"status": "RUNNING",
"done": false
}
Для запуска базы данных требуется несколько минут, и за это время у звонящего есть только идентификатор отслеживания. Это пример долгозатягивающейся операции, или LRO, которая встречается при настройке инфраструктуры, обучении моделей, миграциях баз данных и транскодировании видео. Для человека, работающего с терминалом, это обычная процедура: выполняется команда, следует ожидание, можно выпить кофе.
Для ИИ-агента же это серьезная проблема в проектировании. Исследования, сравнивающие способы обработки периода ожидания, показали разницу в стоимости в 5 раз, снижение количества генерируемых токенов на 11 раз и серьезные проблемы с одновременной обработкой задач. Большинство создателей инструментов даже не осознают, что выбирают определенный путь при написании их определений. В сравнении рассматривались три подхода к одинаковым задачам с использованием одной и той же модели: опросы внутри цикла агента, блокировка на стороне сервера и передача задачи на обработку специальному механизму управления.
Почему ожидание дорогостояще
Агент — это языковая модель, работающая в цикле. Она получает цель и некоторые инструменты, рассуждает, вызывает инструмент, проверяет результат и принимает решение о дальнейших действиях. Каждый цикл представляет собой шаг, причем шаг — это не изолированный HTTP-запрос. На каждом шаге в окно контекста вводится вся предыдущая переписка: системное сообщение, определения всех инструментов, цель, а также все предыдущие вызовы и ответы. Суммарная стоимость выполнения задачи примерно равна количеству шагов умноженному на размер контекста на каждом шаге.
Теперь представьте, что агент запрашивает статус операции. Он вызывает функцию get_operation и видит статус «RUNNING», после чего для принятия решения о дальнейших действиях необходимо провести полную обработку всей накопленной информации. Он вызывает функцию снова, снова видит статус «RUNNING» и оплачивает ещё одну полную обработку. Для реализации функции ожидания используется модель типа frontier, цена которой указана в долларах за миллион токенов.
Ниже повторяются четыре термина:
- Шаги: количество вызовов инструментов, совершённых агентом. Чем меньше, тем лучше.
- Взимаемые токены: показатель стоимости, при котором кэшированный контекст оценивается дешевле, примерно в десять раз дешевле, чем свежий ввод. Именно этот показатель отражается в счёте за использование облачных ресурсов.
- Набор инструментов: всё, что разрешено агенту вызывать, будь то через сервер MCP или путём ввода команд CLI в терминал.
- Задачи: фоновая работа, передаваемая в механизм обработки или среду выполнения MCP, что позволяет основному потоку агента оставаться свободным.
Как проходил тестирование
В тесте использовался Evalbench для работы с тем же управляющим слоем облачной базы данных в трёх конфигурациях:
- MCP Toolbox — сервер с заранее настроенной базой данных.
- Простой сервер MCP, предоставляющий инструменты для создания, чтения, обновления и удаления данных, а также информацию о статусе операций.
На каждом уровне сложности было по 12 заданий, выполняемых с помощью Claude Opus на фиксированной версии CLI с автоматическим оценщиком для подсчёта баллов. Среди сложных заданий два выполнялись длительное время: клонирование инстанса и настройка инстанса с высокой доступностью. Три способа настройки обрабатывают процесс ожидания по-разному.
Три способа ожидания
Поллинг внутри цикла
Сервер возвращает идентификатор операции, и агент продолжает запрашивать информацию внутри своего цикла обработки:
create_instance() → operations/abc-123
get_operation(abc-123) → RUNNING
get_operation(abc-123) → RUNNING
... ×10 ...
get_operation(abc-123) → DONE
Десять полных запусков в контексте модели лишь для того, чтобы узнать, что клоны всё ещё генерируются.
Задержка на сервере
Сервер предоставляет инструмент, который поддерживает открытую связь до тех пор, пока операция не достигнет окончательного состояния:
create_instance() → operations/abc-123
wait_for_operation(abc-123) → DONE (one call, eleven minutes later)
Это лишь один шаг. Время простоя проходит на сервере, за который взимается плата в крошечной доле цента в час, а не внутри контекста модели, где стоимость рассчитывается в долларах за миллион токенов. Проблема заключается в том, что блокировка происходит строго последовательно, и пока вызов открыт, поток агента замораживается.
Задачи, передаваемые в фреймворк
Вместо того чтобы блокировать агента или тратить токены на запросы, агент передает операцию в фоновый запускач задач:
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
Благодаря расширению MCP Tasks запуск работы и получение её результата становятся отдельными этапами. Агент запускает задачу, получает уникальный идентификатор задания и переходит к другим полезным действиям. Когда ему наконец требуется доступ к базе данных, он проверяет этот идентификатор или ждёт сигнала о завершении работы. Только такой подход позволяет агенту одновременно ожидать нескольких операций или совмещать длительное ожидание с продуктивными вычислениями.
Стоимость теста клонирования
В процессе оценки клонирования (клонирование экземпляра, ожидание готовности, проверка состояния) основная операция занимает примерно 13 минут в реальном времени в любой среде. Различия во времени выполнения были незначительными, но экономика токенов сильно отличалась:
- MCP Toolbox с его механизмом блокирующего ожидания показал лучшие результаты по всем показателям: 4 шага, 211 854 оплаченных токена, 765 секунд.
- Базовый сервер MCP с десятью попытками опроса занял наибольше времени — 864 секунды при 23 шагах.
- Фоновая CLI имела наибольшие затраты: 328 316 оплачиваемых токенов и 14 108 токенов вывода за 19 шагов.
Одно блокирующее ожидание сократило количество шагов на 80%, количество оплачиваемых токенов — на 26% по сравнению с базовым методом опроса, а затраты — на 35% по сравнению с фоновой CLI. Кроме того, этот метод завершил работу первым, поскольку агенты, использующие метод опроса, постоянно пробуждались для дополнительных процедур обработки.
Самым впечатляющим показателем являются токены вывода — они в 11 раз выше в CLI. Поскольку инструментов MCP не было, агенту пришлось написать собственный скрипт повторных попыток на 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
В документе говорилось, что этот цикл был реализован три раза в незначительно разных формах, поскольку каждая попытка не справлялась с задачей чистого мониторинга. В итоге было решено сдаться и установить таймер пробуждения за пять минут до окончания срока. Одна автономная модель потратила 14 000 токенов вывода на полную переработку функции wait_for_operation с нуля, причем с плохим результатом. Агент, у которого отсутствует возможность ожидания, будет вынужден создать её сам, что приведёт к высоким затратам, и итог окажется хуже, чем у инструмента, который так и не был выпущен.
Рекомендации для разработчиков API и инструментов
При проектировании для агентов необходимо переосмыслить конвенции REST и gRPC с учётом ограничения, с которым они раньше не сталкивались: каждый переданный байт перечитывается на каждом этапе. Каждая из приведённых ниже рекомендаций основана на измеримых показателях.
Предложите многоуровневую модель ожидания
Разные ситуации требуют разного времени ожидания, поэтому предоставьте все три уровня и позвольте агенту самому выбрать подходящий вариант:
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
Использование всех трех вариантов практически не увеличивает нагрузку, однако разница между ними составила 55% от общей стоимости одной задачи клонирования. Ограничение использования только первого уровня вынудило агент CLI создать собственный механизм повторных попыток, что обошлось в 14 108 токенов вывода.
Включение идентификатора операции в тело JSON
В классическом REST-интерфейсе ссылки на операции размещаются в заголовках, таких как Location или Operation-Location. Современные слои вызова инструментов, включая MCP, OpenAI Tools и LangChain, часто опускают HTTP-заголовки и передают модели только JSON-полезную нагрузку.
Когда идентификатор отсутствует в теле запроса, модель не выдает явного сигнала об ошибке. Вместо этого она переходит к прямому запросу к целевому ресурсу, вместо того чтобы проверять результат операции. Это более дорогостояще и менее предсказуемо, поскольку конечные точки ресурсов часто возвращают код 404 или устаревшие данные во время инициализации, из-за чего процесс обработки невозможно отличить от сбоя. В одном случае это привело к 221 повторному вызову функции get_instance.
Добавление явных таймаутов с структурированными частичными результатами
Бесконечное ожидание несёт реальные риски: потеря соединений, прерывание работы балансировщика нагрузки через 300 секунд и застой задач навсегда. Инструмент ожидания с наименьшими общими затратами не имел таймаута и в одном случае блокировался в течение шестнадцати минут, не оставив агенту возможности реагировать на затягивание запроса.
Решением является параметр timeout_seconds с значением по умолчанию около 300. При достижении лимита следует возвращать структурированный статус, который не является ошибкой, вместо того чтобы выбрасывать исключение:
{
"done": false,
"operation": "operations/abc-123",
"elapsed_seconds": 300,
"status": "RUNNING",
"metadata": { "percent_complete": 65 }
}
Теперь модель может отслеживать прогресс и решать, стоит ли снова ждать, запустить работу в фоновом режиме или уведомить пользователя, не запуская процедуры обработки ошибок. Именно это поле позволяет отличить блокирующее ожидание от рискованного подхода.
Проектирование для задач и асинхронных механизмов
Разработчик сервера, реализующий MCP, получает стандартизированную форму третьего паттерна через расширение Tasks. Важны следующие моменты:
- Пусть сервер определяет путь выполнения. Задачи управляются сервером. Объявите io.modelcontextprotocol/tasks и возвращайте CreateTaskResult вместо обычного результата, когда выполнение запроса займет много времени. Не требуйте от вызывающих сторон передачи флага асинхронности, поскольку клиент сам выбирает этот режим во время согласования возможностей.
- Возвращать структурированные метаданные об объекте управления: taskId, начальный статус, ttlMs и pollIntervalMs, а также убедиться, что задача создана надежно перед отправкой ответа. Таким образом, механизмы мониторинга могут отслеживать прогресс без активации модели, а клиенты смогут восстановиться после сбоя.
- Поддерживать уведомления об завершении. При наличии возможности транспортного слоя использовать уведомления типа push или задачи вместо регулярного опроса со стороны клиента. Опрос остается резервным вариантом, но уведомления исключают ненужные запросы-ответы.
- Хранить информацию о завершенных задачах и операциях как минимум в течение 24–48 часов. Если контекст агента сжимается во время ожидания, а затем он запрашивает информацию о завершенной задаче, он должен получить результат, а не код ошибки 404.
Подсчет схем
Каждый инструмент влияет на затраты на каждом шаге каждой задачи, включая те задачи, в которых он вообще не используется. Стоимость примерно равна количеству шагов умноженному на размер контекста. Задержки из-за ожидания улучшают первый фактор, в то время как чрезмерная сложность схемы может свести на нет эти преимущества из-за второго фактора. Сервер с наименьшим количеством шагов всё равно может потратить больше токенов, если при каждом из них в контексте находятся крупные схемы инструментов. При большом объёме схем инструментов загрузка определений по мере необходимости, использование навыков или добавление функции поиска инструментов позволяют сохранять небольшой размер постоянно присутствующей схемы.
Вывод
Ожидание — это архитектурное решение, которое влияет на экономическую эффективность агента, а не просто незначительная оптимизация. Замена токеноемкого опроса на поэтапное, блокирующее или задаче-ориентированное ожидание снижает накладные расходы, а более лаконичные схемы инструментов помогают агентам масштабироваться без необходимости использования сложных моделей для подсчёта времени.