Практикум: стоимость AI-агентов в 2026

Что мы оптимизируем

У агентного workflow в 2026 обычно есть пять главных рычагов:

1. Routing - не пускать весь трафик в дорогую модель.
2. Budget guard - ограничивать стоимость run до того, как он разрастётся.
3. Caching - не платить заново за длинный повторяющийся префикс.
4. Batch - выносить асинхронные задачи из realtime.
5. Early stop - не давать агенту делать лишние шаги после фактического решения задачи.

Current price anchors на 20 марта 2026

Полезно держать в голове хотя бы несколько официально подтверждённых якорей:

• GPT-5.4: $2.50 input, $0.25 cached input, $15.00 output за 1M токенов.
• GPT-5 mini: $0.25 input, $0.025 cached input, $2.00 output.
• GPT-5 nano: $0.05 input, $0.005 cached input, $0.40 output.
• Claude Sonnet 4.x / 4.6 pricing baseline: $3 input, $15 output; prompt cache read = $0.30 за 1M токенов.
• Gemini 2.5 Flash: $0.30 input, $2.50 output; output price включает thinking tokens.
• Gemini 2.5 Flash-Lite: $0.10 input, $0.40 output.
• deepseek-chat / deepseek-reasoner: $0.28 input cache miss, $0.028 cache hit, $0.42 output.

1. Сначала считайте cost per task, а не cost per call

Для agent system самая полезная метрика:

cost_per_completed_task = model_costs + tool_costs + retries + failed_runs

Почему это важно:

• один тикет поддержки может закрываться за 2 model calls, а другой за 8;
• tool-heavy сценарии платят не только за токены, но и за search/tool execution;
• неуспешные runs тоже едят деньги.

Если вы смотрите только на среднюю цену одного model call, вы почти наверняка недооцениваете реальную стоимость automation.

2. Самый сильный рычаг: routing по ролям

Старый шаблон "всё на Sonnet" или "всё на GPT-5.4" в 2026 почти всегда слишком дорог.

Более практичная схема:

Идея простая: у каждого шага должна быть своя economic role.

3. Минимальный router и budget guard на Python

Ниже skeleton, который:

• выбирает lane по типу задачи;
• оценивает текущую стоимость run;
• прерывает run, если budget исчерпан.

from dataclasses import dataclass


PRICES = {
    "gpt-5.4": {"input": 2.50, "output": 15.00},
    "gpt-5-mini": {"input": 0.25, "output": 2.00},
    "gpt-5-nano": {"input": 0.05, "output": 0.40},
    "gemini-2.5-flash-lite": {"input": 0.10, "output": 0.40},
    "deepseek-chat": {"input": 0.28, "output": 0.42},
}


def estimate_cost_usd(model: str, input_tokens: int, output_tokens: int) -> float:
    p = PRICES[model]
    return (
        (input_tokens / 1_000_000) * p["input"]
        + (output_tokens / 1_000_000) * p["output"]
    )


def route_model(task_type: str, high_stakes: bool = False) -> str:
    if task_type in {"classification", "triage", "guardrail"}:
        return "gpt-5-nano"
    if task_type in {"faq", "extract", "simple_support"}:
        return "gpt-5-mini"
    if task_type in {"bulk_background_enrichment"}:
        return "deepseek-chat"
    if high_stakes:
        return "gpt-5.4"
    return "gpt-5-mini"


@dataclass
class RunBudget:
    max_cost_usd: float
    spent_usd: float = 0.0
    max_steps: int = 6
    steps: int = 0

    def can_continue(self) -> bool:
        return self.spent_usd < self.max_cost_usd and self.steps < self.max_steps

    def record(self, model: str, input_tokens: int, output_tokens: int) -> float:
        cost = estimate_cost_usd(model, input_tokens, output_tokens)
        self.spent_usd += cost
        self.steps += 1
        return cost


budget = RunBudget(max_cost_usd=0.03, max_steps=4)

model = route_model("simple_support")
step_cost = budget.record(model, input_tokens=2200, output_tokens=350)

print(model, step_cost, budget.spent_usd, budget.can_continue())

Это уже полезно, потому что:

• router убирает premium model из default-path;
• budget guard не даёт длинному run тихо разрастись;
• считать цену можно на каждом шаге.

4. Prompt caching и context caching

В 2026 кэширование уже нельзя подавать как один универсальный механизм. У провайдеров surface разный:

OpenAI

OpenAI pricing даёт отдельную строку cached input. Это значит, что повторяющийся префикс реально должен жить как стабильный prefix, а не как хаотично меняющаяся сборка инструкций.

Anthropic

Anthropic даёт явный prompt caching:

• 5m write стоит 1.25x base input;
• 1h write стоит 2x base input;
• cache hit стоит 0.1x base input.

То есть длинные tool specs, policies, примеры и документы нельзя каждый раз слать заново как обычный input.

Gemini

Gemini поддерживает:

• implicit caching для Gemini 2.5 моделей;
• explicit context caching с гарантированным экономическим эффектом;
• minimum token threshold для cacheable input.

Практический вывод везде один: длинный системный префикс, policy bundle и повторяющиеся документы нужно выделять в cacheable layer.

5. Batch: асинхронные agent-задачи не должны жить в realtime

И OpenAI, и Anthropic, и Gemini дают 50%-класс скидки на batch/async режимы.

Batch почти всегда подходит для:

• nightly evals;
• массовой классификации и теггинга;
• enrichment pipeline;
• offline summarization;
• периодических отчётов;
• large-scale support triage без жёсткого SLA на секунды.

Что не надо держать в realtime:

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

6. Early stop важнее, чем кажется

Многие agent systems переплачивают не потому, что выбрали не ту модель, а потому что позволяют run жить слишком долго.

Нужны простые stop conditions:

• max steps;
• max cost;
• repeated failure count;
• no-new-information threshold;
• success confidence threshold.

Простейший пример:

def should_stop(
    step_number: int,
    consecutive_failures: int,
    new_facts_found: int,
    cost_spent_usd: float,
) -> bool:
    if step_number >= 6:
        return True
    if consecutive_failures >= 2:
        return True
    if new_facts_found == 0 and step_number >= 3:
        return True
    if cost_spent_usd >= 0.05:
        return True
    return False

Чем раньше вы ловите "run уже не приносит нового value", тем дешевле вся система.

7. Output budgeting: часто дешевле резать output, чем input

У многих моделей output заметно дороже input. Поэтому cost control - это не только compression.

Работает лучше всего:

• жёсткий max_output_tokens;
• короткий structured output вместо свободного эссе;
• answer mode split: short, detailed, audit;
• evaluator, который принимает краткий verdict, а не многословный пересказ.

Плохой запрос:

"Подробно распиши всё, что ты думаешь о задаче".

Хороший:

"Верни 3 причины, confidence и next action в JSON".

8. Tool-cost surface тоже нужно считать

В 2026 агентный счёт может расти не только из-за токенов:

• web search у некоторых провайдеров тарифицируется отдельно;
• grounding / search queries могут считаться по числу запросов;
• computer-use и другие built-in tools имеют свой fee surface;
• повторные retrieval/search вызовы быстро множат общую цену run.

Поэтому cost logging должен видеть:

• model tokens;
• cache hits;
• search/tool invocations;
• retries;
• failed runs.

Без этого вы не поймёте, где реально горят деньги.

9. Практический baseline для команды

Если нужен короткий и реалистичный baseline на 20 марта 2026:

1. realtime routing держите на GPT-5 mini / GPT-5 nano уровне по умолчанию;
2. premium lane включайте только по eval-based routing;
3. вынесите длинный prefix в cacheable слой;
4. всё асинхронное переведите в batch;
5. добавьте max_cost_usd, max_steps и stop conditions на каждый run;
6. считайте cost per completed task, а не только cost per model call.

Именно это обычно даёт первый реальный 2-5x win по стоимости.

Проверьте себя