Сколько на самом деле стоит кодинг-агент: почему счёт растёт из-за cache read, а не из-за input

1. Наблюдение: счёт не бьётся с интуицией

Типичный разговор в чате про AI-кодинг выглядит так. Человек сравнивает провайдеров по одной колонке — цене input-токенов, — выбирает самый дешёвый, подключает Claude Code, работает неделю и приходит с вопросом: «Почему счёт в три раза больше, чем я посчитал на салфетке?»

Ошибка не в арифметике. Ошибка в модели расхода. Интуиция подсказывает, что LLM-запрос — это «я написал промпт, модель написала ответ», то есть input плюс output. Для чата это почти правда. Для кодинг-агента — нет.

Кодинг-агент — это цикл. Он читает файл, думает, вызывает инструмент, получает результат, снова думает, правит, запускает тесты, читает вывод. Один пользовательский запрос «почини этот баг» превращается в 15–40 обращений к модели. И на каждом обращении агент заново подаёт модели весь накопленный контекст: системный промпт, описания инструментов, содержимое открытых файлов, всю историю предыдущих ходов.

Вот здесь и ломается интуиция. Токены, которые вы «написали один раз», модель видит десятки раз. И тарифицируются они каждый раз — просто по другой ставке.

2. Механика: что происходит на каждом ходе агента

Чтобы не оплачивать одни и те же 60 000 токенов контекста по полной input-ставке сорок раз подряд, существует prompt caching. Логика простая:

1. Агент отправляет запрос с большим неизменным префиксом (системный промпт → определения инструментов → содержимое файлов → история).
2. Провайдер сохраняет вычисленное состояние для этого префикса. Это запись кэша — она тарифицируется по input-ставке.
3. На следующем ходе агент отправляет тот же префикс плюс небольшой хвост из новых сообщений. Совпавшая часть не пересчитывается, а поднимается из кэша. Это чтение кэша (cache read) — отдельная, сильно более дешёвая ставка.
4. Новый хвост (результат инструмента, новая реплика) — это обычный input.
5. То, что модель сгенерировала, — output.

Итого в биллинге кодинг-агента живут три ставки, а не две:

В прайсе go2llm эти три колонки указаны явно для каждой модели — см. страницу цен или машиночитаемый GET /api/pricing. Это не косметика: без третьей колонки посчитать стоимость агента невозможно в принципе.

Ключевой момент, который ломает наивное сравнение: cache read дешевле input, но его объём на порядок больше. Дешёвая ставка, умноженная на огромный объём, легко перевешивает дорогую ставку на маленьком объёме.

3. Профиль нагрузки: 10 / 5 / 85

Мы считаем экономику кодинг-агента по такому профилю:

• вход — 10%
• выход — 5%
• чтение кэша — 85%

Откуда это берётся, если расписать один сеанс. Сразу оговорка: цифры ниже — реконструкция для наглядности, а не замер. Зафиксирован и опубликован только итоговый профиль 10 / 5 / 85; промежуточная раскладка нужна лишь чтобы показать, что он не выдуман.

Допустим, у агента установившийся контекст ~60 000 токенов: системный промпт и схемы инструментов (~8k), открытые файлы проекта (~35k), история диалога и результаты инструментов (~17k). Агент делает 30 ходов подряд.

• На первом ходе эти 60k пишутся в кэш → это input.
• На ходах 2–30 те же ~60k читаются из кэша → 29 × 60k ≈ 1.74M токенов cache read.
• На каждом ходе добавляется новый хвост: diff, вывод теста, новая инструкция — пусть в среднем 6k → 30 × 6k = 180k input.
• Модель генерирует: рассуждение, патчи, аргументы tool-call — пусть в среднем 3k на ход → 90k output.

Сложим: input ≈ 60k + 180k = 240k, output ≈ 90k, cache read ≈ 1 740k. Всего ≈ 2 070k. В долях: input 11.6%, output 4.3%, cache read 84.1%. Это и есть 10 / 5 / 85 с точностью до округления.

Профиль сдвигается в зависимости от стиля работы. Если вы гоняете агента длинными сессиями по большому репозиторию — доля cache read растёт. Если дёргаете его короткими одноразовыми вопросами без общего контекста — падает, но тогда растёт доля дорогого input, потому что кэш не переиспользуется. Ни один из сценариев не делает input главной статьёй расхода. Живой пример длинного сеанса — UI-анимация, которую Claude Code собрал по одному промпту: 73 запроса за полтора часа, и 97% токенов пришлись на чтение кэша.

Важно: 10 / 5 / 85 — это модель для сравнения тарифов, а не гарантия вашего личного расклада. Свой реальный профиль надо измерять — как именно, в разделе 8.

4. Формула смешанной цены

Если профиль известен, тариф сворачивается в одно число — смешанную цену за 1M токенов:

mixed = input × 0.10 + output × 0.05 + cache_read × 0.85

На пальцах: возьмите миллион токенов, прошедших через агента. Сто тысяч из них (10%) оплачиваются по input-ставке. Пятьдесят тысяч (5%) — по output-ставке. Восемьсот пятьдесят тысяч (85%) — по cache-read-ставке. Сложите три произведения — получите стоимость этого миллиона.

def mixed_price(price_in: float, price_out: float, price_cache: float) -> float:
    """USD за 1M смешанных токенов при профиле кодинг-агента 10/5/85."""
    return price_in * 0.10 + price_out * 0.05 + price_cache * 0.85


def monthly_bill(mixed: float, million_tokens: float) -> float:
    return mixed * million_tokens


# Официальный тариф Claude Opus 4.5: in 5.00 / out 25.00 / cache read 0.50
opus = mixed_price(5.00, 25.00, 0.50)
print(round(opus, 4))                        # 2.175
print(round(monthly_bill(opus, 200), 2))     # 435.0

Подставьте в ту же формулу ставки любого тарифа — своего текущего или нашего. Актуальные ставки go2llm по каждой модели лежат на странице цен: там же посчитана смешанная цена по этому профилю и экономия против официального тарифа. Ставки мы пересматриваем, поэтому здесь они намеренно не продублированы — цифра в статье живёт дольше, чем остаётся верной.

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

5. Расчёт по шагам

Дальше — арифметика с полной раскладкой по официальным тарифам вендоров (сверены 2026-09-09, тарифы Sonnet и DeepSeek пересверены 2026-09-26; для DeepSeek взят дневной тариф, который вендор указывает первым). Считаем по ним, а не по нашим ставкам, намеренно: официальный прайс — общая система отсчёта, он меняется редко, и выводы из него не протухают. Наши текущие ставки и посчитанную по этому же профилю экономию смотрите на странице цен.

5.1. Claude Opus 4.5

Официальный тариф: 5.00 / 25.00 / 0.50 за 1M.

input      5.00 × 0.10 = 0.500
output    25.00 × 0.05 = 1.250
cache      0.50 × 0.85 = 0.425
-------------------------------
mixed                  = 2.175 $ / 1M

Отдельного внимания заслуживает то, как эти 2.175 распределены по статьям — см. раздел 5.5, там результат контринтуитивный.

5.2. Claude Sonnet 4.5

Официальный тариф: 2.00 / 10.00 / 0.20.

2.00 × 0.10 = 0.200
10.00 × 0.05 = 0.500
0.20 × 0.85 = 0.170
--------------------
mixed        = 0.870 $ / 1M

5.3. DeepSeek

Официальный тариф: 0.66 / 1.98 / 0.022.

0.66  × 0.10 = 0.0660
1.98  × 0.05 = 0.0990
0.022 × 0.85 = 0.0187
---------------------
mixed         = 0.1837 $ / 1M

Сравните порядки: официальный Opus 4.5 — 2.175 за 1M смешанных, DeepSeek — 0.1837. Это разрыв в 11.8 раза внутри одного профиля нагрузки. Держать Opus на задачах, где справится Flash, — самая дорогая привычка в этом списке, и она дорогая у любого поставщика: соотношение задаёт вендорский прайс, а не наша наценка.

5.4. Сводка смешанных цен по официальным тарифам

Обратите внимание на Haiku: 0.435 — это официальная цена «быстрой дешёвой модели». Держите это число в голове, когда будете сравнивать со ставками любого шлюза, включая наши.

5.5. Находка первая: 5% объёма дают 57% счёта

Теперь посмотрим, куда на самом деле уходят деньги внутри одного тарифа. Возьмём Claude Opus 4.5 и разложим смешанную цену по статьям — рядом с долей объёма.

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

Читается это так: output — это 5% токенов и 57.5% счёта. Input — 10% токенов и 23% счёта. Cache read — 85% токенов и 19.5% счёта.

Отсюда два вывода, которые ломают обе популярные интуиции сразу:

1. Сравнивать по input бессмысленно — он отвечает меньше чем за четверть счёта.
2. Но и «всё дело в кэше» — тоже неправда. Cache read делает счёт большим не потому, что дорогой, а потому, что его много, и он единственная статья, на которую вы влияете архитектурой промпта. Самая же дорогая строка — output, при том что её объём микроскопический. Поэтому max_tokens (раздел 7.4) даёт эффект несоразмерно усилию.

Пропорция не универсальна — она зависит от того, как у модели соотносятся три ставки. Сравните:

У GLM (0.15 / 0.50 / 0.03) cache read действительно почти главная строка — 38.9%, потому что output дешёвый, а кэш относительно дорогой. У DeepSeek кэш дешёвый (0.022) и даёт лишь десятую долю счёта, зато output забирает больше половины. Один и тот же профиль нагрузки даёт три разные структуры расхода. Это ещё одна причина, почему одну колонку прайса читать нельзя — нужны все три.

5.6. Источники официальных тарифов

Официальные ставки в расчётах выше — включая cache read, который вендоры публикуют отдельной строкой, — взяты из прайсов самих вендоров и сверены 2026-09-09 (тарифы Sonnet и DeepSeek пересверены 2026-09-26). Для Anthropic-моделей источник — platform.claude.com/docs/en/about-claude/pricing, для DeepSeek — api-docs.deepseek.com/quick_start/pricing. Прайсы остальных вендоров: OpenAI, Google, xAI, Z.ai, Moonshot, Alibaba. Ставки go2llm и ссылка на официальный прайс по каждой модели отдаются машиночитаемо через GET /api/pricing вместе с версией каталога — актуальную цену всегда можно получить одним curl.

6. Месячный счёт при N млн токенов

Теперь то же самое в деньгах. Столбцы — объём смешанных токенов за месяц. 50M — это примерно «час-два агента в день». 200M — плотная ежедневная работа. 500M — агент как основной способ писать код, либо небольшая команда на общем ключе.

Раскладка объёма по статьям (профиль 10/5/85):

Счёт в месяц, USD:

Счёт по официальным тарифам вендоров, USD:

Проверка одной клетки вручную, чтобы было видно, что цифры не с потолка. Opus 4.5, 200M смешанного объёма:

input:       20M × $5.00 / 1M  = $100.00
output:      10M × $25.00 / 1M = $250.00
cache read: 170M × $0.50 / 1M  = $ 85.00
----------------------------------------
итого                            $435.00

Справочно в рублях по курсу ЦБ 86,3793 ₽ за $1 на 01.09.2026: $435.00 ≈ 37 575 ₽. Баланс и списания у нас ведутся в USD, рубли — только для ориентира.

Чтобы получить свой счёт через go2llm, возьмите смешанную цену нужной модели со страницы цен и умножьте на объём в миллионах — там же показана экономия против официального тарифа по этому же профилю 10/5/85.

7. Как реально снизить счёт

Восемь приёмов, отсортированных по отношению «эффект / усилие».

7.1. Держите системный промпт стабильным

Кэш попадает только на точное совпадение префикса. Любая подвижная деталь в начале — текущее время, случайный session_id, перетасованный список инструментов, автоматически подставляемая дата — обнуляет совпадение, и весь контекст на следующем ходе пойдёт по input-ставке вместо cache-read.

По официальному тарифу Opus 4.5 это разница между $0.50/1M и $5.00/1M на 85% объёма. Промах кэша на 60k контекста × 30 ходов = 1.8M токенов, которые вместо $0.90 стоят $9.00. На одном сеансе мелочь, на месяце — десятикратная переплата по самой массовой статье. Соотношение между двумя ставками у любого шлюза своё, но порядок разрыва задаёт вендор.

Правило: всё изменчивое — в конец сообщения, всё стабильное — в начало.

7.2. Не дёргайте контекст между ходами

Каждая перестройка контекста — удаление файла из выдачи, пересортировка истории, вставка чего-то в середину — ломает префикс начиная с места правки. Агент, который «умно» подрезает контекст на каждом ходе, платит за пересборку кэша чаще, чем экономит на объёме.

Контекст должен расти только с конца. Если его действительно надо чистить — чистите редко и целиком, а не по чуть-чуть каждый ход.

7.3. Подбирайте модель под задачу

Самая большая экономия — не в тарифе, а в выборе модели. По официальным тарифам разрыв между Opus 4.5 (2.175) и DeepSeek (0.1837) — 11.8×, между Opus 4.5 и Haiku 4.5 (0.435) — 5×. Порядок сохраняется у любого поставщика: это свойство вендорских прайсов, а не чьей-то наценки.

Разумное разделение:

Смешанную цену каждой из них по этому профилю смотрите на странице цен.

В Claude Code модель переключается переменной окружения — без правки кода:

export ANTHROPIC_BASE_URL=https://go2llm.tech
export ANTHROPIC_AUTH_TOKEN=YOUR_API_KEY
export ANTHROPIC_MODEL=claude-sonnet-5
claude

Отдельно: используйте именно ANTHROPIC_AUTH_TOKEN, а не ANTHROPIC_API_KEY. Если на машине уже есть вход в Claude Code под личным аккаунтом, ANTHROPIC_API_KEY может уступить сохранённому логину, и запрос уйдёт мимо шлюза с 401. ANTHROPIC_AUTH_TOKEN всегда обращается к указанному ANTHROPIC_BASE_URL. Подробности — в docs по кодинг-инструментам.

7.4. Ограничивайте max_tokens

Output — 5% объёма, но у Opus 4.5 это 57% счёта (1.250 из 2.175). Доля не зависит от того, чей прайс: скидка, ровная по всем трём ставкам, её не меняет. Модель, которой разрешили писать 8192 токена, регулярно ими пользуется — на задаче, где хватило бы 800.

Плюс практический побочный эффект: шлюз резервирует оценочную стоимость до вызова и списывает фактическую после. Завышенный max_tokens раздувает резерв. Если баланс на исходе, вы получите 402 insufficient_balance — и в описании ошибки прямо сказано: пополнить баланс или уменьшить max_tokens.

7.5. Ставьте квоту на ключ

Ключ поддерживает квоту в долларах, список разрешённых моделей, IP allow-list и срок действия. Это единственный способ гарантированно не узнать о проблеме постфактум.

Практика: отдельный ключ на эксперименты с квотой $5 и разрешёнными только дешёвыми моделями; отдельный — на рабочий агент. Ключ с квотой 0 — это ключ без отдельного лимита, его расход ограничен только общим балансом. Ключ, созданный с пустым полем квоты, тоже идёт без отдельного лимита — лимит выставляется вручную в кабинете.

7.6. Читайте usage.cost_usd в каждом ответе

Стоимость запроса возвращается прямо в ответе, в поле usage.cost_usd. Не нужно ждать выписки и не нужно самому перемножать токены на тариф. Об этом — весь следующий раздел.

7.7. Учитывайте лимит 20 RPM

По умолчанию на ключ действует лимит 20 запросов в минуту. Для интерактивного агента это некритично — человек физически не генерирует столько ходов. Но если вы запускаете пакетную обработку в несколько потоков, вы упрётесь в 429 с кодом rate_limit.

Обрабатывайте 429 по Retry-After, а не слепым ретраем: агрессивный ретрай в цикле — это лишние запросы, которые всё равно не проходят.

import time
import httpx

def call_with_backoff(client, payload, attempts=5):
    for i in range(attempts):
        r = client.post("/v1/messages", json=payload)
        if r.status_code == 429:
            wait = float(r.headers.get("Retry-After", 2 ** i))
            time.sleep(wait)
            continue
        if r.status_code == 402:
            raise RuntimeError("insufficient_balance: пополнить баланс или снизить max_tokens")
        r.raise_for_status()
        return r.json()
    raise RuntimeError("rate_limit: не прошло за отведённые попытки")

7.8. Не гоняйте агента по большому репозиторию без нужды

Объём кэша прямо пропорционален количеству файлов в контексте. 35k токенов файлов против 120k — это разница в 3.4× по 85% вашего счёта. Агенту, который правит один модуль, не нужен весь монорепозиторий. Самый дешёвый токен — тот, который вы не отправили.

8. Как измерить свой расход

Не верьте расчётной модели, включая эту. Измеряйте.

Каждый ответ шлюза содержит фактическую стоимость запроса в usage.cost_usd — включая финальный usage-блок SSE-стрима. Это не оценка и не токены, которые ещё надо умножать, а то, что реально списалось.

Обычный (нестримовый) вызов через Anthropic SDK:

import os
from anthropic import Anthropic

client = Anthropic(
    base_url="https://go2llm.tech",
    api_key=os.environ["GO2LLM_API_KEY"],
)

msg = client.messages.create(
    model="claude-opus-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Привет"}],
)
print(msg.usage)  # у шлюза там ещё cost_usd

Чтобы накапливать расход по сессии, заведите тонкую обёртку и суммируйте cost_usd:

import os
from anthropic import Anthropic

client = Anthropic(base_url="https://go2llm.tech", api_key=os.environ["GO2LLM_API_KEY"])

TOTAL = 0.0

def ask(model: str, prompt: str, max_tokens: int = 1024):
    global TOTAL
    msg = client.messages.create(
        model=model,
        max_tokens=max_tokens,
        messages=[{"role": "user", "content": prompt}],
    )
    usage = msg.usage.model_dump() if hasattr(msg.usage, "model_dump") else dict(msg.usage)
    cost = float(usage.get("cost_usd", 0.0))
    TOTAL += cost
    print(f"[{model}] cost_usd={cost:.6f}  сессия={TOTAL:.6f}")
    return msg

ask("claude-haiku-4-5", "Перепиши в camelCase: user_first_name")
ask("claude-opus-5", "Разбери архитектурные риски этого модуля")
print(f"ИТОГО за сессию: ${TOTAL:.4f}")

Для стрима стоимость приходит в финальном usage-блоке. Самый быстрый способ убедиться в этом — посмотреть на сырой SSE:

curl -N https://go2llm.tech/v1/messages \
  -H "x-api-key: YOUR_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"claude-sonnet-5","max_tokens":200,"stream":true,"messages":[{"role":"user","content":"Напиши функцию сортировки на Go"}]}' \
  | grep --line-buffered cost_usd

Что с этим делать дальше: погоняйте свой реальный рабочий день, сложите cost_usd, поделите на объём — получите свою смешанную цену. Если она сильно выше расчётной для выбранной модели — у вас промахивается кэш (см. 7.1 и 7.2). Если сильно ниже — у вас профиль ближе к чату, чем к агенту, и вам стоит смотреть на другие модели.

Актуальный список моделей и endpoint'ов всегда доступен без ключа:

curl https://go2llm.tech/v1/models

9. Где сравнение врёт

Три систематические ошибки, которые встречаются почти в каждом сравнении провайдеров.

9.1. Ошибка первая: cache read вообще не опубликован

Провайдер печатает две колонки, input и output, и молчит про третью. Дальше возможны варианты: кэширования нет вовсе и весь префикс тарифицируется по input-ставке, либо оно есть, но по какой цене — узнаете из выписки.

Посчитайте худший случай для Opus-подобной модели. Если 85% объёма идёт по input-ставке вместо cache-read, смешанная цена становится 5.00 × 0.10 + 25.00 × 0.05 + 5.00 × 0.85 = 6.00 вместо 2.175 — счёт вырастает в 2.76 раза, хотя сама строка cache read подорожала в 10 раз. Разница между «в 10 раз дороже одна статья» и «в 2.76 раза дороже весь счёт» — ровно та причина, по которой считать надо смешанную цену, а не отдельные ставки.

Если в прайсе нет строки cache read, а вы запускаете агента, — у вас нет прайса. У нас cache read вынесен в отдельную колонку на странице цен, рядом с ним стоит официальная ставка вендора со ссылкой на первоисточник, и всё это отдаётся машиночитаемо через GET /api/pricing с версией каталога.

9.2. Находка вторая: сортировка по input даёт ответ, противоположный правильному

Это не абстракция и не гипотетика. Возьмём пару моделей и посчитаем обе колонки — ту, по которой обычно выбирают, и ту, по которой надо. Ставки здесь официальные, вендорские: переворот не зависит от наценки, потому что скидка, ровная по всем трём ставкам, порядок не меняет.

Qwen 3.8 Flash против MiMo v2.5. Обе — дешёвые рабочие лошадки, и обе выглядят сопоставимо.

Прочитайте эту таблицу дважды. Qwen дешевле по input — по той самой колонке, на которую смотрят первой и по которой сортируют списки моделей. И при этом для кодинг-агента она дороже на 39%, потому что проигрывает по третьей колонке в 5 раз (0.014 против 0.0028), а третья колонка — это 85% объёма.

Проверка: 0.113 × 0.10 + 0.382 × 0.05 + 0.014 × 0.85 = 0.0113 + 0.0191 + 0.0119 = 0.0423 против 0.14 × 0.10 + 0.28 × 0.05 + 0.0028 × 0.85 = 0.014 + 0.014 + 0.00238 = 0.0304.

Разница в input между ними — 19%, и она уводит в неправильную сторону. Разница в cache read — пятикратная, и именно она решает: выигрыш в 19% на десятой части объёма не перекрывает проигрыш в 5 раз на восьмидесяти пяти процентах.

Вывод: если вы выбираете модель для агента по колонке input, вы с заметной вероятностью выберете не ту — и узнаете об этом из счёта, а не из прайса.

9.3. Ошибка третья: усреднение в одно число без раскрытия профиля

«Средняя цена $X за 1M» ничего не значит, пока не сказано, при каком соотношении input/output/cache она получена. Наш профиль опубликован явно — 10 / 5 / 85 — и вы можете подставить свой и пересчитать формулой из раздела 4 (готовый калькулятор — в разделе 11). Число, полученное по нераскрытому профилю, невозможно ни проверить, ни воспроизвести.

9.4. И про совместимость, потому что цена без неё не имеет смысла

Claude Code — проверено живым запросом, работает через Anthropic Messages. OpenCode — проверено живым запросом, через OpenAI Chat Completions. Cline, RooCode, Continue.dev, Aider — работают по документации, если клиент умеет свой base URL; вручную мы их не тестировали. Codex CLI — проверено живым запросом 2026-09-14 (codex exec 0.151.0, wire_api = "responses", модель qwen3-8-flash): актуальные версии для кастомных провайдеров поддерживают только Responses API, и с этого дня endpoint /v1/responses у нас опубликован.

Cursor мы живым запросом не проверяли и поэтому не утверждаем ни что он работает, ни что не работает. Если вам нужен именно Cursor — проверяйте на своей конфигурации сами, а не по чужому обещанию.

10. Итог

• У кодинг-агента три статьи расхода, а не две. Третья — cache read — это ~85% объёма.
• Корректная метрика: mixed = input × 0.10 + output × 0.05 + cache_read × 0.85.
• Внутри счёта пропорции переворачиваются: у claude-opus-5 output — это 5% токенов и 57.5% счёта, input — 10% токенов и 23% счёта, cache read — 85% токенов и 19.5% счёта.
• Поэтому сравнение по input-ставке не просто неточное, а способно переставить модели местами: Qwen 3.8 Flash дешевле MiMo v2.5 по input на 19% — и при этом дороже для агента на 39%.
• По официальному тарифу смешанная цена Opus 4.5 — 2.175 $/1M, то есть $435.00 за 200M токенов в месяц. Свою — считайте по ставкам со страницы цен и этой же формуле.
• Самый большой рычаг — не тариф, а выбор модели: разрыв между Opus 4.5 и DeepSeek по официальным тарифам — 11.8×.
• Проверяйте не расчёт, а факт: usage.cost_usd приходит в каждом ответе, включая финальный usage-блок стрима.

Тарифы, endpoint'ы и коды ошибок — в документации. Цены по каждой модели вместе с официальным тарифом и ссылкой на первоисточник — на странице цен.

11. Калькулятор: посчитайте свою смешанную цену

Всё, что выше, посчитано для профиля 10 / 5 / 85. Ваш профиль другой — измерьте его по usage.cost_usd (раздел 8) и подставьте сюда. Скрипт принимает доли, две тройки ставок и объём, и печатает месячный счёт для обеих.

#!/usr/bin/env python3
"""Смешанная цена и месячный счёт кодинг-агента.

mixed = in * share_in + out * share_out + cache * share_cache
Ставки — USD за 1M токенов. Объём — в млн токенов за месяц.
"""

from dataclasses import dataclass


@dataclass(frozen=True)
class Rates:
    """Тариф: вход (и запись кэша), выход, чтение кэша. USD / 1M токенов."""
    inp: float
    out: float
    cache: float


@dataclass(frozen=True)
class Profile:
    """Доли объёма. Должны давать в сумме 1.0."""
    inp: float = 0.10
    out: float = 0.05
    cache: float = 0.85

    def __post_init__(self) -> None:
        total = self.inp + self.out + self.cache
        if abs(total - 1.0) > 1e-9:
            raise ValueError(f"доли должны давать 1.0, получено {total}")


def mixed_price(rates: Rates, profile: Profile = Profile()) -> float:
    """USD за 1M смешанных токенов."""
    return (
        rates.inp * profile.inp
        + rates.out * profile.out
        + rates.cache * profile.cache
    )


def compare(
    model: str,
    official: Rates,
    go2llm: Rates,
    volumes_mtok: tuple[float, ...] = (50, 200, 500),
    profile: Profile = Profile(),
) -> None:
    mix_off = mixed_price(official, profile)
    mix_g2l = mixed_price(go2llm, profile)

    print(f"\n{model}")
    print(f"  профиль:   in {profile.inp:.0%} / out {profile.out:.0%} / cache {profile.cache:.0%}")
    print(f"  mixed:     официально ${mix_off:.6f} | go2llm ${mix_g2l:.6f} | дешевле в {mix_off / mix_g2l:.2f}x")
    print(f"  {'объём':>8} {'официально':>14} {'go2llm':>12} {'экономия':>12}")
    for v in volumes_mtok:
        bill_off, bill_g2l = mix_off * v, mix_g2l * v
        print(f"  {v:>7.0f}M {bill_off:>13.2f}$ {bill_g2l:>11.2f}$ {bill_off - bill_g2l:>11.2f}$")


if __name__ == "__main__":
    # Официальные прайсы вендоров сверены 2026-09-09. Во второй тройке — ставки вашего шлюза:
    # наши возьмите со страницы цен https://go2llm.tech/pricing (колонки in / out / cache read),
    # или подставьте любого другого поставщика, чтобы сравнить на своём профиле.
    compare("claude-opus-5",
            official=Rates(5.00, 25.00, 0.50),
            go2llm=Rates(0.00, 0.00, 0.00))   # <- впишите три ставки

    compare("claude-sonnet-5",
            official=Rates(3.00, 15.00, 0.30),
            go2llm=Rates(0.00, 0.00, 0.00))

    compare("deepseek-v4-flash",
            official=Rates(0.30, 1.20, 0.006),
            go2llm=Rates(0.00, 0.00, 0.00))

    # Свой профиль: например, короткие сессии, кэш попадает хуже.
    compare("claude-opus-5 (профиль 25/10/65)",
            official=Rates(5.00, 25.00, 0.50),
            go2llm=Rates(0.00, 0.00, 0.00),
            profile=Profile(inp=0.25, out=0.10, cache=0.65))

Колонка официального тарифа в первом блоке должна совпасть с разделом 6: mixed 2.175 и $435.00 на 200M. Если совпало — вы читаете тот же прайс вендора, что и мы, и дальше можно доверять второй колонке со своими ставками.

Получить ключ и сделать первый запрос за 3 минуты

→ https://go2llm.tech/

При регистрации на баланс начисляется $1 — этого хватает на первый запрос без пополнения. Минимальное пополнение — $1, оплата рублями через СБП или криптовалютой. Подписок и обязательной ежемесячной платы нет, только pay-as-you-go.

export ANTHROPIC_BASE_URL=https://go2llm.tech
export ANTHROPIC_AUTH_TOKEN=YOUR_API_KEY
export ANTHROPIC_MODEL=claude-sonnet-5
claude

FAQ

Почему счёт за Claude Code больше, чем я посчитал по цене input? Потому что у кодинг-агента input — это примерно 10% объёма токенов. Ещё 5% — output, а 85% — cache read: агент на каждом ходе заново подаёт модели весь накопленный контекст, и совпавший префикс поднимается из кэша по отдельной ставке. Считать нужно смешанную цену: input × 0.10 + output × 0.05 + cache_read × 0.85.

Сколько стоит месяц работы на Claude Opus 5? При 200M смешанных токенов в месяц (плотная ежедневная работа с агентом) — $435.00 по официальному тарифу 5.00 / 25.00 / 0.50 и $43.70 в go2llm по тарифу 0.503 / 2.51 / 0.05025. Раскладка: 20M input, 10M output, 170M cache read. При 50M — $108.75 против $10.93, при 500M — $1087.50 против $109.26.

Запись кэша оплачивается отдельно? Запись кэша тарифицируется по input-ставке — в прайсе go2llm это колонка in. Чтение кэша идёт по отдельной, сильно более дешёвой ставке cache. У Anthropic для Opus 4.5 это 5.00 и 0.50 $/1M (см. прайс Anthropic); наши — на странице цен. Поэтому промах кэша дорог: те же токены стоят в 10 раз больше.

Правда ли, что для агента главная статья расхода — cache read? По объёму — да, 85% токенов. По деньгам — зависит от модели. У Opus 4.5 cache read даёт всего 19.5% счёта, а 57.5% приходится на output, хотя это лишь 5% токенов. У GLM 4.6 Flash почти наоборот: cache read — 38.9% счёта. Поэтому единственный корректный ответ — посчитать по своим ставкам и своему профилю; скрипт для этого есть в разделе 11.

Как узнать точную стоимость конкретного запроса? Она приходит в ответе в поле usage.cost_usd, в том числе в финальном usage-блоке SSE-стрима. Это фактическое списание, а не оценка. Шлюз резервирует оценочную стоимость до вызова, затем списывает фактическую и освобождает остаток резерва; баланс не уходит ниже нуля.

Что сделать первым делом, чтобы снизить расход? По убыванию эффекта: (1) выбрать модель под задачу — разрыв между Opus 4.5 и DeepSeek по смешанной цене 11.8×; (2) стабилизировать системный промпт, чтобы кэш попадал, и не перестраивать контекст между ходами; (3) ограничить max_tokens — output даёт больше половины счёта при 5% объёма; (4) выставить квоту в долларах на ключ. И измерить свой реальный профиль по usage.cost_usd, а не доверять чужой модели.

*Расчёты в статье ведутся по официальным тарифам вендоров, USD за 1M токенов; актуальные ставки go2llm — на странице цен и в GET /api/pricing. Официальные тарифы — включая ставки cache read — сверены 2026-09-09 (Sonnet и DeepSeek — 2026-09-26) по первоисточникам: Anthropic, DeepSeek, OpenAI, Google, xAI, Z.ai, Moonshot, Alibaba. Цены меняются — источник правды в рантайме всегда GET /api/pricing и GET /v1/models.*

*Две оговорки, чтобы не было вопросов. Раскладка сеанса в разделе 3 (60k контекста, 30 ходов, 6k хвоста, 3k генерации) — реконструкция для наглядности, а не замер: зафиксирован и опубликован только итоговый профиль 10 / 5 / 85. Cursor мы живым запросом не проверяли и статус его совместимости не утверждаем.*