Разработчики, которые запускают AI-агентов в продакшн, рано или поздно упираются в вопрос: сколько это на самом деле стоит? Ответ «зависит от модели» перестаёт устраивать, когда счёт за API начинает расти быстрее, чем покрытие тестов. В отличие от классического SaaS, где стоимость лицензии фиксирована, AI-агент потребляет ресурсы динамически: каждый вызов LLM, каждый запрос к инструменту и каждая секунда ожидания между шагами превращаются в деньги.
Эта статья — не абстрактное рассуждение об экономике ИИ, а метод, который можно применить к своему агенту уже сегодня. Мы разберём три компонента затрат, покажем рабочий скрипт для оценки стоимости на Python и разложим типовые сценарии по таблице. Данные для расчётов — актуальные цены OpenAI и Anthropic на сентябрь 2026 года.
Почему стоимость AI-агента не равна стоимости одного запроса к LLM
Типичная ошибка — умножить цену одного токена на среднюю длину ответа и получить бюджет. На практике AI-агент делает несколько вызовов LLM за один цикл: сначала анализирует промпт, потом решает, какой инструмент вызвать, затем обрабатывает результат вызова, и на каждом шаге генерирует новый запрос. К этому добавляются холостые циклы — когда агент повторяет попытку после ошибки, переспрашивает уточнения или просто ждёт таймаут.
В работе «AI Agents in Production: Cost Analysis and Optimization» (arXiv, 2024) авторы приводят данные: в среднем агент совершает от 4 до 12 вызовов LLM на одно завершённое действие пользователя. Причём значительная часть токенов уходит на повторяющийся контекст — историю диалога, системный промпт, описание доступных инструментов. Этот контекст передаётся с каждым вызовом, и его объём растёт по мере выполнения задачи.
Таким образом, реальная формула затрат выглядит иначе: стоимость = сумма по всем вызовам (входные токены × цена входного токена + выходные токены × цена выходного токена) + стоимость вызовов инструментов + стоимость времени выполнения.
Три компонента затрат: токены, инструменты, время
Разложим каждый компонент на практические составляющие.
1. Токены: входные и выходные
Провайдеры LLM разделяют стоимость входных (prompt) и выходных (completion) токенов. Например, на сентябрь 2026 года цены OpenAI для GPT-4o составляют $2.50 за миллион входных токенов и $10.00 за миллион выходных. У Anthropic для Claude 3.5 Sonnet — $3.00 за входные и $15.00 за выходные. Разница не случайна: генерация токена требует больше вычислительных ресурсов, чем его чтение.
Что важно: в «входные» токены входит не только запрос пользователя, но и системный промпт, история диалога, результаты предыдущих вызовов инструментов и описание доступных функций. Если агент работает в режиме multi-turn, каждый новый виток добавляет предыдущий ответ в контекст. За десять шагов объём входных токенов может вырасти в 3–5 раз относительно первого запроса.
2. Вызовы инструментов (tool calling)
Когда агент решает вызвать внешний инструмент — поиск в базе данных, чтение файла, отправку HTTP-запроса — это не бесплатно. Во-первых, сам вызов инструмента может иметь собственную стоимость (например, платное API или затраты на compute при локальном выполнении). Во-вторых, результат вызова возвращается в LLM как часть контекста следующего запроса, увеличивая количество входных токенов.
Кроме того, не все вызовы инструментов успешны. Ошибка соединения, таймаут, некорректный ответ — каждый такой случай порождает повторный цикл: агент анализирует ошибку, формирует новый запрос и повторяет попытку. В некоторых архитектурах количество повторных попыток может достигать 3–5 на один вызов, что умножает затраты на токены.
3. Время выполнения
Этот компонент часто упускают из виду. Если агент работает в облачной среде (AWS Lambda, Google Cloud Run, собственный Kubernetes), каждая секунда выполнения стоит денег. Даже когда LLM не генерирует ответ, агент может ждать ответа от инструмента, обрабатывать таймауты или просто находиться в состоянии ожидания следующего шага.
Для агентов с длинным жизненным циклом — например, автоматизированный анализ документов или многошаговая верификация — время выполнения может составлять минуты. При стоимости виртуальной машины $0.10–$0.50 за час это добавляет к затратам центы, которые при масштабировании превращаются в десятки долларов.
Метод расчёта: пошаговый алгоритм
Чтобы оценить реальную стоимость агента, не нужно ждать счёта от провайдера. Достаточно пройти пять шагов.
Шаг 1. Определите профиль задачи
Опишите типовой сценарий работы агента: количество шагов, среднюю длину системного промпта, типичный объём ответа пользователя, количество и типы вызываемых инструментов. Например: «агент анализирует лог-файл, делает 5–7 шагов, системный промпт — 500 токенов, каждый ответ пользователя — 50 токенов, вызывает два инструмента: чтение файла и поиск по базе».
Шаг 2. Оцените средний расход токенов на один вызов
Запустите агента на тестовом наборе из 10–20 примеров и замерьте фактическое количество входных и выходных токенов на каждом шаге. Большинство SDK (openai, anthropic) возвращают usage-статистику в ответе. Сохраните эти данные — они станут основой для расчёта.
Шаг 3. Подставьте цены провайдера
Используйте актуальные цены из официальной документации. Для OpenAI — https://openai.com/api/pricing/, для Anthropic — https://docs.anthropic.com/en/docs/about-claude/pricing. Учитывайте, что цены могут меняться, и для долгосрочных проектов стоит закладывать запас 10–20%.
Шаг 4. Добавьте стоимость инструментов и времени
Для каждого вызова инструмента оцените его стоимость: бесплатно (локальный вызов), по тарифу API (например, $0.01 за запрос) или по времени выполнения (например, $0.0005 за секунду на Lambda). Суммируйте с затратами на токены.
Шаг 5. Умножьте на ожидаемую нагрузку
Если агент будет обрабатывать 1000 запросов в день, умножьте стоимость одного цикла на 1000. Это даст дневной и месячный бюджет. Не забудьте учесть пиковую нагрузку: при превышении лимитов провайдера стоимость может вырасти из-за retry-логики.
Пример расчёта на Python
Ниже — функция, которая принимает логи вызовов агента и возвращает разбивку затрат. Скрипт использует цены OpenAI GPT-4o и Anthropic Claude 3.5 Sonnet, но модель легко заменить на свою.
import json
# Цены за миллион токенов (USD, сентябрь 2026)
PRICING = {
"gpt-4o": {"input": 2.50, "output": 10.00},
"claude-3.5-sonnet": {"input": 3.00, "output": 15.00}
}
def calculate_agent_cost(logs, model="gpt-4o", tool_cost_per_call=0.0, compute_cost_per_second=0.0):
"""
logs: список словарей с ключами 'input_tokens', 'output_tokens', 'tool_calls', 'elapsed_seconds'
"""
total_input = sum(log['input_tokens'] for log in logs)
total_output = sum(log['output_tokens'] for log in logs)
total_tool_calls = sum(log['tool_calls'] for log in logs)
total_time = sum(log['elapsed_seconds'] for log in logs)
price = PRICING[model]
cost_input = (total_input / 1_000_000) * price['input']
cost_output = (total_output / 1_000_000) * price['output']
cost_tools = total_tool_calls * tool_cost_per_call
cost_compute = (total_time / 3600) * compute_cost_per_second * 3600 # если compute_cost_per_second — стоимость секунды
return {
"total_input_tokens": total_input,
"total_output_tokens": total_output,
"cost_input_usd": round(cost_input, 4),
"cost_output_usd": round(cost_output, 4),
"cost_tools_usd": round(cost_tools, 4),
"cost_compute_usd": round(cost_compute, 4),
"total_cost_usd": round(cost_input + cost_output + cost_tools + cost_compute, 4)
}
# Пример: 10 циклов агента на GPT-4o
example_logs = [
{"input_tokens": 1500, "output_tokens": 300, "tool_calls": 2, "elapsed_seconds": 12},
{"input_tokens": 2100, "output_tokens": 450, "tool_calls": 1, "elapsed_seconds": 8},
# ... ещё 8 записей
]
result = calculate_agent_cost(example_logs, model="gpt-4o", tool_cost_per_call=0.001, compute_cost_per_second=0.00003)
print(json.dumps(result, indent=2))
Этот код — не production-решение, а стартовая точка. В реальном проекте логи собираются автоматически (OpenTelemetry, LangSmith, собственный middleware), и расчёт встраивается в CI/CD для отслеживания регрессии затрат при каждом изменении агента.
Таблица сравнения: три типовых сценария
Чтобы показать, как разные архитектуры влияют на стоимость, сравним три сценария. Все расчёты — для GPT-4o, 1000 запросов, без учёта стоимости инструментов и compute (только токены).
| Сценарий | Среднее число вызовов LLM | Входные токены (на запрос) | Выходные токены (на запрос) | Стоимость за 1000 запросов |
|---|---|---|---|---|
| Простой чат-бот (1 вызов, без инструментов) | 1 | 500 | 200 | $3.25 |
| Агент с 1 инструментом (3 вызова, контекст растёт) | 3 | 1200 | 600 | $9.00 |
| Многошаговый агент (8 вызовов, 3 инструмента, retry) | 8 | 4500 | 1800 | $29.25 |
Разница между простым чат-ботом и многошаговым агентом — почти десятикратная. При этом в реальном проекте к цифрам из таблицы добавляется стоимость инструментов и времени выполнения, что может увеличить затраты ещё на 20–40%.
Как снизить затраты без потери качества
После того как вы оценили текущие затраты, возникает естественный вопрос: что можно оптимизировать? Вот несколько практических приёмов, которые не требуют смены модели.
Сокращайте контекст
Каждый лишний токен в системном промпте или истории диалога увеличивает стоимость каждого последующего вызова. Проверьте, действительно ли агенту нужна вся история или достаточно последних 3–5 шагов. Некоторые реализации используют скользящее окно контекста или сжатие истории через суммаризацию.
Ограничьте количество retry
Повторные попытки после ошибки — один из главных источников неожиданных затрат. Установите жёсткий лимит (2–3 попытки) и используйте экспоненциальную задержку. Если инструмент стабильно падает, лучше обработать ошибку на уровне агента, а не пытаться перезапустить LLM-цикл.
Кэшируйте ответы инструментов
Если агент вызывает один и тот же инструмент с одинаковыми параметрами несколько раз в рамках сессии, результат можно закэшировать. Это сокращает как количество вызовов инструмента, так и объём контекста, который передаётся в LLM.
Используйте более дешёвую модель для простых шагов
Не все шаги агента требуют топовой модели. Классификация запроса, предварительная фильтрация или обработка стандартных ошибок могут выполняться на GPT-4o mini или Claude Haiku. Стоимость таких моделей в 5–10 раз ниже, а для простых задач качество остаётся приемлемым.
Метод, описанный в статье, даёт прозрачную картину затрат, но у него есть ограничения. Цены провайдеров меняются, модели обновляются, и реальная стоимость может отличаться от расчётной. Кроме того, метод не учитывает затраты на разработку и поддержку пайплайна логирования — их придётся оценивать отдельно. Рекомендуется закладывать бюджет с запасом 30–50% на первые два месяца продакшна, пока не накопится статистика по реальным сценариям использования.
Следующий шаг — внедрить автоматический сбор метрик в вашего агента. Без данных о фактическом потреблении токенов и времени выполнения любые оценки останутся гаданием. Начните с простого: добавьте логирование usage-статистики из SDK провайдера и запустите тестовый прогон на 10–20 примерах. Цифры, которые вы получите, скорее всего, окажутся выше ваших ожиданий — и это нормально. Лучше узнать об этом до того, как придёт первый большой счёт.
