Цена токена обманывает как дешевые ИИ-агенты сжигают бюджет

9 минут чтения

Разработчик запускает агента для фонового исправления багов на дешевой модели и стандартном фреймворке. Ожидает копеечных затрат, но из-за неконтролируемых автоповторов рискует получить счет, который, как показывает практика, может вырасти в 31 раз.

Покажем, почему оптимизация на дешевых токенах приводит к высокой cost-per-outcome, и почему 40-60% бюджета уходит на мусор в контексте.

Агентские задачи сжигают миллионы токенов на один тикет

Агент для написания кода потребляет в тысячу раз больше токенов по сравнению с обычным диалогом о коде. Об этом прямо говорит исследование 2026 года. Программист ставит задачу исправить ошибку в логике приложения. Программа начинает работу. Сначала скрипт запрашивает структуру директорий. Затем читает содержимое нескольких файлов исходного кода. После этого пишет план действий. Далее вызывает инструменты для редактирования текста. В конце запускает тесты и проверяет логи компилятора. Каждый вызов инструмента требует передачи всей предыдущей истории действий в новом запросе к API.

Минималистичный принтер чеков печатает бесконечную гору пустой бумаги на темном фоне
Дешевые токены обманчивы так как агентская задача лавинообразно раздувает контекст на каждом шаге

Статистика показывает реальный масштаб потребления. Одна агентская задача сложности SWE-bench сжигает от 1M до 3.5M токенов. SWE-bench оценивает способность систем решать реальные проблемы из публичных репозиториев. Это абсолютно нормальное поведение для успешного выполнения сложного тикета. Оплата списывается за каждую итерацию поиска файлов и чтения логов ошибок. Контекст растет лавинообразно. На первом шаге модель читает короткий промпт. На десятом шаге модель читает промпт, девять своих прошлых ответов, содержимое трех файлов и девять ответов от терминала с результатами тестов. Процесс повторяется десятки раз до успешного прохождения всех проверок.

Проблема возникает при выборе модели. Инженер открывает каталог и видит цены DeepSeek V4.1 Flash с прайсом 0.15-0.30 доллара за миллион входных токенов. Возникает соблазн дать скрипту бесконечное число попыток. Кажется логичным разрешить дешевой нейросети ошибаться пятнадцать раз. Флагманская модель получает только одну попытку. Практика показывает ошибочность такого подхода. Стратегия ломается о механику внимания трансформеров.

Дешевая модель задыхается от собственных ошибок в контексте

Каждый шаг программы добавляется в историю переписки. Модель видит свой предыдущий неверный код и длинный лог ошибки от компилятора. Начинается процесс самообусловливания. Нейросети показывают резкое ухудшение точности на длинных дистанциях. Они накапливают собственные прошлые ошибки в контексте.

Присутствие неудачного кода в промпте заставляет систему чаще ошибаться в будущих шагах. Механизм внимания присваивает вес всем токенам в окне. Галлюцинация из прошлого ответа влияет на генерацию следующего. Программа начинает ходить по кругу. Пытается исправить синтаксис, ломает логику, откатывает изменения, снова ломает синтаксис. Дешевые версии особенно склонны к многословным извинениям. Они генерируют длинные абзацы текста с обещаниями исправить ошибку. Счет растет за генерацию этих извинений по тарифу выходных токенов.

Исследования показывают печальную картину. От 40 до 60 процентов API-бюджета компаний уходит на операционную неэффективность. Бюджет расходуется на редундантные системные промпты и пустые рассуждения. Нейросеть раз за разом перечитывает огромный кусок мусора из прошлых неудачных попыток. Полезная нагрузка тонет в логах предыдущих падений. Владелец проекта платит за обработку бесполезного текста при каждом новом вызове. Чем длиннее история неудач, тем меньше шансов на успешный исход.

Наивный автоповтор ломает внешние системы

Скрипты часто имеют доступ к внешним инструментам. Они создают тикеты, отправляют письма, делают коммиты в базу данных. Наивный механизм переповтора при сбое становится опасным для инфраструктуры.

Стильный степлер вбил огромную стопку скоб в одно и то же место на пустом листе
Автоматический перезапуск при сбое заставляет скрипт бесконечно дублировать одно и то же действие

Скрипты успешно выполняют задачи в нормальных условиях с вероятностью 84 процента. При небольших инъекционных сбоях показатель восстановления падает до 47 процентов. Инъекционный сбой означает нестандартный ответ API. Инструмент вернул ошибку сервера или сломанный HTML вместо ожидаемого формата JSON. Нейросеть не понимает причину отказа инструмента и просто дергает его снова с теми же параметрами.

В 53.33 процента случаев наивный автоповтор приводит к дублированию внешних эффектов. Программа получает ошибку таймаута от трекера задач. Тикет успешно создался на сервере. Скрипт повторяет запрос и создает дубликат. Возникает петля, которая мусорит в рабочих системах тысячами одинаковых записей. Разбор таких инцидентов отнимает часы рабочего времени команды. Об этом мы упоминали в статье про создание ИИ-агентов. Автоматический откат действий работает плохо из-за непредсказуемости состояния внешней системы.

Дефолтные настройки фреймворков разоряют

Разные фреймворки имеют критически разные предохранители. Программисты устанавливают библиотеку и оставляют настройки по умолчанию.

OpenAI Agents SDK прерывает работу по достижению десяти итераций. Это жесткий лимит от создателей проприетарных моделей. LangGraph в базовой конфигурации позволяет выполнение до 10007 шагов. Фреймворк с открытым исходным кодом перекладывает ответственность за контроль бюджета на программиста. Десять тысяч шагов с растущим контекстом гарантированно опустошат баланс любого проекта.

Люди часто ошибочно оценивают сложность задачи для скрипта. Разработчик ставит лимит в сто шагов для простейшего багфикса. Ожидает завершения за три шага. Программа застревает на чтении файла и использует весь выделенный лимит.

Показателен инцидент с обработкой сложного изображения. Скрипт получил базовый 64-бит энкодинг картинки в виде текста. Строка состояла из сотен тысяч символов. Программа застряла в петле, пытаясь прочитать этот огромный массив символов как исполняемый код. Потребление токенов увеличилось в 31 раз до обнаружения ошибки оператором. Токенизатор разбивает бессмысленный набор букв на огромное количество мелких фрагментов. Дефолтный лимит позволил сжечь месячный бюджет за пару часов работы одного процесса.

Стандартные калькуляторы скрывают арифметическую прогрессию

Обычный расчет стоимости запроса умножает размер промпта на цену токена. Этот подход работает для генерации текста или перевода статей. Агентские скрипты ломают эту формулу. Контекст агента растет динамически с каждым новым действием. Возникает эффект арифметической прогрессии.

Разработчик выделяет агенту десять шагов на выполнение задачи. На каждом шаге скрипт вызывает инструмент и получает ответ длиной десять тысяч токенов. Кажется логичным умножить десять шагов на десять тысяч токенов и получить сто тысяч токенов общего расхода. Реальная математика работает иначе.

На первом шаге модель обрабатывает десять тысяч токенов. На втором шаге модель обрабатывает первые десять тысяч плюс новые десять тысяч. На третьем шаге объем достигает тридцати тысяч. К десятому шагу размер промпта вырастает до ста тысяч токенов. Суммарный объем обработанных входных данных за десять итераций составляет пятьсот пятьдесят тысяч токенов. Оплата списывается за весь этот объем.

Каждая ошибка компилятора или длинный лог от базы данных навсегда оседает в истории переписки. Скрипт перечитывает этот мусор на каждой следующей итерации. Компания платит за чтение одного и того же лога ошибки девять раз подряд. Именно эта прогрессия превращает дешевые токены в огромные счета при возникновении бесконечного цикла.

Флагман с первого раза обходится дешевле десяти попыток

Посчитаем затраты на конкретных числах из прайсов. Возьмем задачу рефакторинга крупного модуля. Требуется прочитать 2M токенов контекста репозитория и написать новый класс.

Один идеальный дротик в центре мишени и куча сломанных дешевых дротиков на полу
Одна успешная попытка умной модели стоит меньше чем десятки провалов дешевой нейросети

Сравним три модели из каталога. Берем GPT-6.1 Sol, Gemini 3.8 Flash и DeepSeek V4.1 Flash. Представим два сценария. Первый сценарий предполагает чистое решение за два шага. Первый шаг съедает 2M входных и дает 50k выходных токенов. Второй шаг съедает 2.05M входных и дает 150k выходных. Суммарный вход составляет 4.05M токенов. Суммарный выход составляет 0.2M токенов.

Второй сценарий описывает провал и зацикливание на пятнадцать шагов. Суммарный вход достигает 35M токенов из-за арифметической прогрессии. Суммарный выход достигает 2M токенов из-за генерации извинений.

МодельЦена входа (1M)Цена выхода (1M)Успех за 2 шагаПровал за 15 шагов
GPT-6.1 Sol$2.00$10.00$10.10$90.00
Gemini 3.8 Flash$2.00$10.00$10.10$90.00
DeepSeek V4.1 Flash$0.30$1.20$1.45$12.90

Считаем чистый успех для GPT-6.1 Sol. Вход: 4.05M умножаем на 2.00 доллара. Выход: 0.2M умножаем на 10.00 долларов. Итоговая цена: 10.10 доллара.

Считаем провал для DeepSeek V4.1 Flash. Вход: 35M умножаем на 0.30 доллара. Выход: 2M умножаем на 1.20 доллара. Итоговая цена: 12.90 доллара.

Дешевая модель потратила больше денег и провалила задачу. Разница в базовой цене токена полностью компенсируется объемом мусора в контексте. Деньги списываются за чтение одних и тех же логов снова и снова. Подробнее о механике ценообразования читайте в нашем разборе счетов API.

Замена на reasoning модель не гарантирует выход из петли

Очевидным решением кажется переход на модели с цепочкой рассуждений. Практика показывает ограничения этого подхода. Внутреннее мышление действительно снижает частоту синтаксических ошибок на первых шагах. Нейросеть лучше планирует действия и реже опечатывается в названиях переменных. Петля все равно возникает при столкновении с нестандартным ответом внешнего инструмента.

Крупные облачные провайдеры не гарантируют битовую воспроизводимость. Генерируемый ответ может меняться при идентичных промптах даже с нулевой температурой. Архитектура Mixture of Experts направляет запросы на разные узлы кластера. Запрос обрабатывают разные экспертные сети. Агент запускается локально для отладки. Он проходит проблемный участок без ошибок. Код уходит в продакшен. Скрипт снова зацикливается на том же месте.

Недетерминированность делает отладку бесконечных циклов крайне сложной задачей. Невозможно надежно воспроизвести состояние, при котором скрипт сошел с ума. Экономия токенов при замене обычных моделей на reasoning-версии в агентских петлях остается фрагментарной и сильно зависит от конкретной платформы.

Как жестко ограничить агента в понедельник

Остановить сжигание бюджета можно тремя изменениями в коде оркестратора.

Сначала требуется установить жесткий лимит шагов. Десять итераций достаточно для большинства рутинных задач. Если программа не справилась за десять шагов, она провалит задачу и за сто. Лучше получить уведомление о сбое, чем счет за миллионы токенов.

Затем требуется настроить агрессивную фильтрацию контекста. Необходимо удалять длинные трейсы ошибок перед следующим запросом. Достаточно оставлять только последнюю строку лога с описанием исключения. Полезно удалять промежуточные шаги рассуждений из истории. Это замедлит лавинообразный рост входных токенов и снизит эффект самообусловливания. Нейросеть перестанет опираться на свои прошлые галлюцинации.

Полезно ограничить бюджет и количество попыток на уровне цикла выполнения. Покажем пример для скрипта, который в цикле обращается к API генерации изображений. Инструмент проверяет лимит итераций и прерывает работу при сбоях.

Python
import requests

api_key = "ar-test-key-123"
url = "https://api.altrouter.ai/images/generations"
max_steps = 10

for step in range(max_steps):
    response = requests.post(
        url,
        headers={"Authorization": f"Bearer {api_key}"},
        json={
            "model": "nano-banana-pro",
            "prompt": "A developer looking at a huge API bill, cinematic lighting"
        }
    )
    
    if response.status_code == 200:
        print("Task completed successfully.")
        break
        
    print(f"Attempt {step + 1} failed. Status: {response.status_code}")
    # Здесь логика фильтрации логов перед следующей попыткой

Жесткие лимиты (например, 10 итераций) и фильтрация контекста (удаление дублей логов) защищают от арифметической прогрессии расходов.