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

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

Стоимость делегирования — это совокупные издержки, которые несёт AI-агент (или система) при передаче подзадачи внешнему инструменту, другому агенту или LLM. Она складывается из токенов на вызов, времени ожидания ответа, штрафа за возможные ошибки и накладных расходов на сериализацию и трейсинг. Без количественной оценки стоимости делегирования невозможно оптимизировать архитектуру Agentic RAG и выбрать рациональный порог «когда делегировать, а когда обработать самостоятельно». Предлагается формула: Cost_delegation = Σ(шаг_i) [cost_вызова_i + latency_i + penalty_за_ошибку_i + overhead_передачи.

1. Термин: «Стоимость делегирования» и её контекст

В Вики/Agentic RAG|Agentic RAG агент часто решает: выполнить шаг сам (например, сделать внутренний поиск по документу) или делегировать задачу специализированному инструменту (калькулятор, API погоды, другой агент). Каждое такое решение имеет цену. стоимость делегирования — это метрика, которая объединяет все затраты, связанные с внешним вызовом, в единый численный показатель.

Понятие включает не только прямые денежные траты (токены * price|цена LLM + стоимость вызова API), но и временные издержки (latency), а также потенциальные убытки от неправильного делегирования (penalty). Без этой метрики архитектура рискует либо слишком часто делегировать (дорого, медленно), либо слишком редко (ухудшение качества ответа).

2. Компоненты стоимости делегирования

2.1 cost_вызова — прямые денежные затраты

Включает:

• Токены LLM: стоимость input- и output-токенов для запроса к языковой модели (цена зависит от модели: GPT-4, Claude, локальная LLM).
• API-вызовы инструментов: плата за каждый вызов стороннего сервиса (например, $0.01 за запрос к погодному API).
• Токены памяти/контекста: затраты на повторную передачу предыдущих сообщений или контекста агента (при делегировании другому агенту).

Формула для одного шага:

cost_вызова_i = (input_tokens_i * price_input + output_tokens_i * price_output) + api_call_cost_i

2.2 latency — временные издержки

Latency — время от момента отправки запроса до получения полного ответа. Включает:

• Время транспорта: сетевая задержка при вызове удалённого API.
• Время генерации: для LLM — время на генерацию токенов (TTFT + TPOT).
• Время выполнения инструмента: например, время выполнения SQL-запроса во внешней БД.

Временные издержки конвертируются в денежный эквивалент, если:

• Система работает в реальном времени (клиенты ждут).
• Каждая секунда простоя стоит бизнесу (например, чат-бот поддержки, торговля).

Конверсия: latency_cost_i = latency_i_sec * cost_per_second_of_user_wait.

cost_per_second можно оценить через SLA или среднюю дневную выручку на одного пользователя.

2.3 penalty_за_ошибку — штраф за некорректное делегирование

Делегирование может привести к ошибке: инструмент вернул неверные данные, LLM неправильно интерпретировала результат, вызов упал с таймаутом. Penalty — это ожидаемые потери от такой ошибки, умноженные на вероятность её возникновения.

penalty_за_ошибку_i = P(error_i) * cost_of_error_i

• P(error_i) — вероятность ошибки на шаге i (оценивается по логам или эмпирически).
• cost_of_error_i — стоимость инцидента: возврат средств, потеря клиента, исправление вручную, репутационный ущерб.

Для упрощённых расчётов penalty можно задавать фиксированным числом (например, $0.50 за сбой) и корректировать по мере накопления статистики.

2.4 overhead_передачи — накладные расходы инфраструктуры

Сюда входят затраты, не связанные напрямую с вызовом, но обязательные для делегирования:

• Сериализация/десериализация контекста: упаковка состояния агента в JSON, передача между модулями.
• Логирование и трейсинг: каждый вызов инструмента дополнительно логируется (стоимость хранения логов, работа трейсингового сервера).
• Оркестрация: затраты CPU/RAM на принятие решения о делегировании (агентский цикл).

Эти расходы обычно малы по сравнению с токенами, но могут накапливаться при тысячах вызовов. Их можно измерять как фиксированную надбавку (например, $0.001 на вызов).

3. Формула расчёта для всего сценария

Полная стоимость делегирования для одного трассировочного шага (trace) агента:

Cost_delegation = Σ_{i=1}^{n} (cost_вызова_i + latency_cost_i + penalty_за_ошибку_i + overhead_передачи_i)

где n — количество вызовов инструментов/агентов в данном сценарии.

Пример: Агент трижды делегирует: поиск документов, вызов калькулятора, вызов LLM для рерайтинга.

• cost_вызова = $0.03 + $0.01 + $0.05 = $0.09
• latency = 0.5 сек + 1.2 сек + 2.0 сек = 3.7 сек; при цене $0.01/сек → $0.037
• penalty: вероятность ошибки 5% для калькулятора, стоимость ошибки $10.0 → $0.5. Для остальных шагов ошибка пренебрежимо мала.
• overhead = $0.001 * 3 = $0.003

Итог: $0.09 + $0.037 + $0.5 + $0.003 = $0.63.

4. Метрики для мониторинга в реальном времени

Для оперативного измерения стоимости делегирования нужны дашборды с агрегированными метриками:

Эти метрики позволяют выявить «дорогие» инструменты, узкие места по latency и инструменты с высокой частотой ошибок.

5. Инструменты для измерения

На практике стоимость делегирования собирается автоматически через платформы наблюдаемости:

• [Вики/LangSmith|LangSmith(Вики/TLS|https://smith.Вики/agent|langchain.com) / Вики/LangSmith|LangFuse — отслеживают вызовы Вики/GPT-4o|LLM, инструментов, замеряют Вики/cost|токены, Вики/Latency|latency, Вики/cost|стоимость (по ценовой модели). Можно выгрузить сырые трассы.
• Helicone / Portkey — прокси-серверы для LLM, логируют все вызовы и считают стоимость.
• Prometheus + OpenTelemetry — если агент написан на Python, можно экспортировать свои метрики (кастомные counter и histogram) с лейблами «инструмент», «статус».
• Lunary — open-source трейсинг для LLM-приложений, поддерживает кастомные метрики стоимости.

Рекомендуется в коде агента оборачивать каждый вызов инструмента в декоратор, который фиксирует:

• id трассы
• имя инструмента
• количество токенов (если LLM)
• время начала и конца
• результат (ok/error)
• объём переданных данных (overhead)

Пример на Python (схематично):

import time, asyncio
from opentelemetry import metrics

cost_counter = metrics.get_meter("agent").create_counter("delegation_cost",
    unit="USD", description="Total cost of delegation")

async def track_delegation(tool_name: str, cost_fn, overhead=0.001):
    start = time.time()
    try:
        result = await cost_fn()  # сам вызов
        status = "ok"
    except Exception:
        status = "error"
        result = None
    latency = time.time() - start
    # cost_вызова извне (например из возвращаемого значения)
    call_cost = result.get("cost", 0) if result else 0
    # penalty — вычисляется отдельно по частоте ошибок
    total = call_cost + latency * config.USER_SECOND_COST + overhead
    cost_counter.add(total, {"tool": tool_name, "status": status})
    return result

6. Балансировка стоимости и качества

Знание стоимости делегирования позволяет принимать рациональные решения:

• Порог делегирования: если ожидаемая стоимость вызова инструмента выше, чем стоимость обработки внутри агента (например, простой вопрос можно решить без внешнего LLM), то делегирование невыгодно.
• Выбор инструмента: между несколькими API с разной ценой и точностью можно выбирать по cost + penalty (например, дешёвый API с 10% ошибок может быть выгоднее дорогого с 1% ошибок, если penalty мала).
• Dynamic routing: агент может оценивать стоимость каждого шага в реальном времени и переключаться между локальными compute и внешними вызовами.

Пример простой эвристики:

if estimated_delegation_cost(prompt) > THRESHOLD:
    handle_internally()
else:
    delegate_to_tool()

Порог вычисляется как средняя стоимость одного внутреннего шага (токены на промит + время).

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

Задача: Разработать панель мониторинга стоимости делегирования для агента, который использует три инструмента: поиск по векторной БД, вызов open‑weather API и рерайтинг ответа через LLM.

Инструменты:

• Python + LangChain / CrewAI (для прототипа агента)
• LangSmith (для логирования) или self‑hosted OpenTelemetry + Prometheus + Grafana
• PostgreSQL (для хранения трасс, если свой сборщик)

Шаги:

1. Создайте агента с тремя инструментами. Каждый инструмент возвращает структуру {"cost": float, "latency": float, "data": ...}.
2. Внедрите декоратор, который записывает в метрический регистр: cost, latency, error_flag, overhead (условно 0.001 USD на вызов).
3. Настройте экспорт метрик в Prometheus (используя prometheus_client).
4. Разверните Grafana и создайте дашборды:
   • Общая стоимость делегирования (столбчатая диаграмма по инструментам)
   • P95 latency по каждому инструменту
   • Error rate (процент ошибок)
   • Cost per session (для последних 10 сессий)
5. Проведите A/B тест: измените порог делегирования (THRESHOLD) на 10% и $0.05, сравните метрики.

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

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

Навигация

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