Как вы измеряете стоимость агента в production (не только токены)?

Краткий тезис

Стоимость агента в production складывается из четырёх основных компонентов: LLM-токены (входные и выходные), вызовы инструментов (API, базы данных, внешние сервисы с учётом latency и лимитов), человеческие верификации (human-in-the-loop) и инфраструктурные затраты (cost|хостинг, GPU, мониторинг). Ключевая метрика — cost per сессия|successful session (стоимость одной успешной сессии), которая позволяет сравнивать эффективность разных архитектур агентов. Измерение ведётся через логирование каждого шага агента и агрегацию затрат с учётом повторных попыток и отказов.

1. Термин: стоимость агента в production

Стоимость агента — это совокупные затраты на выполнение одной задачи (сессии) агентом в реальной эксплуатации. В отличие от простого LLM-запроса, агент может совершать несколько раундов вызова LLM, вызывать инструменты, ждать ответов от внешних систем, а иногда требовать вмешательства человека. Поэтому измерение только токенов даёт неполную картину.

Production — среда, где агент обслуживает реальных пользователей с требованиями к latency, надёжности и стоимости. В production важно не только среднее значение, но и хвостовые задержки (p99 latency) и стоимость неудачных попыток.

2. Компоненты стоимости агента

Ключевая формула (из черновика):

Cost_per_session = (LLM_tokens × price_per_token) + (API_calls × cost_per_call) + (human_verification_hours × hourly_rate) / successful_sessions

Но на практике нужно учитывать, что часть сессий может быть неудачными, и их стоимость тоже должна быть распределена на успешные.

3. LLM-токены: детальный разбор

Входные токены включают системный промпт, историю диалога, результаты вызовов инструментов, контекст из RAG. Чем больше шагов делает агент, тем больше входных токенов (из-за накопления истории). Выходные токены — это ответы LLM (действия, размышления, финальный ответ).

Пример расчёта на Python

def cost_llm(input_tokens, output_tokens, model="gpt-4"):
    prices = {
        "gpt-4": {"input": 0.03/1000, "output": 0.06/1000},
        "gpt-3.5-turbo": {"input": 0.0015/1000, "output": 0.002/1000}
    }
    p = prices[model]
    return input_tokens * p["input"] + output_tokens * p["output"]

# Агент делает 3 шага: каждый шаг 500 входных, 200 выходных токенов
total_input = 3 * 500
total_output = 3 * 200
print(f"Стоимость LLM: ${cost_llm(total_input, total_output):.4f}")

Важно при использовании caching (кэширование промптов) стоимость может снижаться, если провайдер не тарифицирует повторные одинаковые токены.

4. API-вызовы инструментов и latency

Агент может вызывать: поисковые API (Google, Bing), базы данных (SQL, векторные), калькуляторы, календари, CRM. Стоимость складывается из:

• Фиксированной платы за вызов (например, $0.002 за поисковый запрос)
• Затрат на время ожидания (latency): если агент ждёт ответа 2 секунды, это увеличивает время сессии и косвенно стоимость (больше времени работы инфраструктуры, хуже пользовательский опыт)

Метрика cost per tool call — средняя стоимость одного вызова инструмента (включая повторные попытки при ошибках).

Таблица типичных инструментов и их стоимости:

5. Человеческие верификации (Human-in-the-loop)

В production часто требуется, чтобы агент передавал управление человеку при низкой уверенности или для подтверждения критических действий (например, отправка email от имени пользователя). Стоимость человеческой верификации измеряется в часах оператора, затраченных на сессию.

Формула

Human_cost_per_session = (time_per_verification_minutes / 60) * operator_hourly_rate

Пример: оператор тратит 3 минуты на проверку одного действия агента, его ставка $25/час → $1.25 за сессию.

Важно если верификация требуется в 10% сессий, то средняя стоимость человеческого вмешательства = 0.1 * $1.25 = $0.125 на сессию.

6. Инфраструктурные затраты

Сюда входят:

• Хостинг агента (сервер, контейнер, serverless-функции)
• GPU для инференса (если используется self-hosted LLM)
• Хранение логов и мониторинг (ELK, Grafana, Datadog)
• Сеть (исходящий трафик)

Примерная оценка если агент работает на serverless (AWS Lambda) с 1 ГБ памяти и 10 секундами выполнения, стоимость одного вызова ~$0.0001. При 1000 сессий в день — $0.1 в день на инфраструктуру.

Метрика cost per request (включая compute, memory, network).

7. Мониторинг и observability

Чтобы измерять стоимость, нужно логировать каждый шаг агента. Рекомендуется использовать structured logging с полями:

• session_id
• step_number
• input_tokens, output_tokens
• tool_name, tool_latency_ms, tool_cost
• human_intervention_seconds
• success (bool)

Пример структуры лога (JSON):

{
  "session_id": "abc123",
  "step": 2,
  "llm_input_tokens": 450,
  "llm_output_tokens": 180,
  "tool": "search_web",
  "tool_latency_ms": 320,
  "tool_cost": 0.005,
  "human_time_sec": 0,
  "success": true
}

Агрегируя такие логи, можно построить дашборд с метриками: средняя стоимость сессии, p99 стоимости, стоимость по типам инструментов.

8. Стоимость ошибок и отказов

Неудачные сессии (агент не смог выполнить задачу, дал неверный ответ, превысил лимит шагов) тоже имеют стоимость, но не приносят пользы. Их нужно учитывать в cost per successful session.

Формула

Cost_per_success = Total_cost_all_sessions / Number_of_successful_sessions

Пример: 100 сессий, 80 успешных, общая стоимость $50 → Cost_per_success = $50 / 80 = $0.625.

Дополнительно стоимость повторных попыток (retry logic) — если агент перезапускается при ошибке, затраты удваиваются.

9. Метрики для измерения стоимости

Пример дашборда (Grafana):

Average Cost per Session: $0.12
Success Rate: 85%
Cost per Success: $0.14
LLM Cost Ratio: 60%
Human Cost Ratio: 25%
Tool Cost Ratio: 10%
Infrastructure: 5%

10. Оптимизация стоимости

• Уменьшение числа шагов агента (лучше планирование, меньше итераций)
• Кэширование результатов инструментов (одинаковые запросы не вызывать повторно)
• Использование более дешёвых моделей для простых шагов (router: GPT-3.5 для простых, GPT-4 для сложных)
• Лимит на количество шагов (max_steps) — предотвращает бесконечные циклы
• Human-in-the-loop только для критических действий (снизить частоту верификации)
• Batch-обработка (если агент обрабатывает много похожих запросов, можно объединять вызовы)

Пет-проект для закрепления

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

Инструменты Python, SQLite (или CSV), библиотека tiktoken для подсчёта токенов.

Шаги:

1. Создайте класс AgentCostTracker, который хранит логи в списке словарей.
2. Реализуйте метод log_step(session_id, step, input_tokens, output_tokens, tool_name, tool_latency, tool_cost, human_time).
3. Добавьте метод calculate_report(), который вычисляет:
   • Общее количество сессий
   • Количество успешных сессий (параметр success)
   • Среднюю стоимость сессии (LLM + tools + human)
   • Cost per successful session
   • Распределение по компонентам (LLM, tools, human)
4. Сымитируйте 50 сессий агента со случайными параметрами (нормальное распределение токенов, случайные вызовы инструментов, 10% человеческих вмешательств).
5. Выведите отчёт в консоль и сохраните в CSV.

Ожидаемый результат Вы увидите, что cost per successful session выше, чем средняя стоимость, из-за неудачных сессий. Сможете проанализировать, какой компонент доминирует.

Пример кода (фрагмент):

import random
import tiktoken

class AgentCostTracker:
    def __init__(self):
        self.logs = []
    
    def log_step(self, session_id, step, input_tokens, output_tokens, tool_name, tool_latency, tool_cost, human_time, success):
        self.logs.append({
            'session_id': session_id,
            'step': step,
            'input_tokens': input_tokens,
            'output_tokens': output_tokens,
            'tool_name': tool_name,
            'tool_latency': tool_latency,
            'tool_cost': tool_cost,
            'human_time': human_time,
            'success': success
        })
    
    def calculate_report(self):
        # ... агрегация
        pass

# Симуляция
tracker = AgentCostTracker()
for session in range(50):
    success = random.random() > 0.15  # 85% success
    for step in range(random.randint(1, 5)):
        tracker.log_step(
            session_id=f"session_{session}",
            step=step,
            input_tokens=random.randint(200, 800),
            output_tokens=random.randint(50, 300),
            tool_name=random.choice(['search', 'sql', 'calc']),
            tool_latency=random.randint(100, 1000),
            tool_cost=random.uniform(0.001, 0.01),
            human_time=random.choice([0, 120]) if random.random() < 0.1 else 0,
            success=success
        )

Связь с другими вопросами

Навигация

• Предыдущий: 147
• Следующий: 149
• Индекс: 00. Индекс разборов