Каждый раз, когда вы отправляете новое сообщение, модель получает всю историю разговора — каждое предыдущее сообщение, каждый предыдущий ответ — как входные данные и обрабатывает их заново с нуля. Это фундаментальное свойство трансформерных моделей: нет памяти между вызовами API, каждый запрос воспроизводит весь контекст с самого начала.

На практике это означает, что расход токенов растёт квадратично с длиной разговора. Длинная сессия, подключённые MCP-инструменты, большой CLAUDE.md, расширенное мышление (extended thinking) — всё это незаметно суммируется и в итоге превращается в счёт, который удивляет.

Команда Branch8 задокументировала оптимизацию: в первый месяц они потратили $2 400 (около 240 миллионов токенов). После внедрения оптимизаций к третьему месяцу расходы составили $680 — снижение на 72%.

Разберём всё по порядку: от самого очевидного (выбор модели) до тонких, но значимых вещей (правильное время для /compact и структура CLAUDE.md).

Что это

Оптимизация расхода токенов Claude — это набор техник, которые снижают стоимость работы с моделями Claude (Haiku, Sonnet, Opus) без потери качества результата. Техники разбиты на восемь уровней: выбор модели, уровень effort, кэширование промптов, управление контекстом, субагенты, структура промптов, batch API и мониторинг. Каждый уровень независим — можно применять их по отдельности или вместе.

Зачем нужно

Токены — это деньги. Каждый вызов API оплачивается по количеству обработанных входных и сгенерированных выходных токенов. Выходные токены стоят в 5 раз дороже входных. Расход растёт квадратично с длиной разговора, потому что модель каждый раз перечитывает всю историю с нуля.

Если не оптимизировать, можно потратить $2 400 в месяц там, где достаточно $680. Оптимизация даёт от 50% до 90% экономии в зависимости от подхода.

Как устроено

Почему вы тратите больше, чем думаете

Прежде чем оптимизировать — стоит понять, откуда вообще берутся токены.

  • Системный промпт загружается всегда. CLAUDE.md загружается до того, как Claude прочитал ваш код, до того, как прочитал задачу, до всего. 5 000-токенный CLAUDE.md стоит 5 000 токенов на каждом ходу, каждой сессии. Постоянная базовая стоимость, которую вы несёте всё время.
  • Инструменты и MCP-коннекторы тоже занимают место. Каждый MCP-коннектор (Google Drive, Slack, Calendar и т.д.) и каждый включённый инструмент загружает своё полное определение в контекстное окно при каждом сообщении — используете вы его или нет. Если у вас подключено 5 коннекторов и вы не используете ни один для задачи с кодом — вы тратите тысячи токенов на сообщение просто на определения инструментов.
  • Выходные токены стоят в 5 раз дороже входных. Выходные токены оплачиваются ровно в пять раз по ставке входных токенов в текущем API Anthropic. Вы платите за 2 000-словный ответ, который вам не был нужен, несколько раз: один раз когда он написан, и один раз при каждом последующем ходу, который его перечитывает.
  • Extended thinking по умолчанию включён. Extended thinking включён по умолчанию, потому что значительно улучшает производительность на сложных задачах планирования и рассуждения. Токены мышления оплачиваются как выходные токены, и бюджет по умолчанию может составлять десятки тысяч токенов на запрос в зависимости от модели.

Слой 1: выбор модели — самый большой рычаг

Это самое важное решение, от которого зависит 50–70% итоговой стоимости. Не каждая задача требует мощнейшей модели.

МодельВходящие / млнИсходящие / млнДля каких задач
Haiku 4.5$1$5Классификация, переименование, форматирование, простые Q&A
Sonnet 5$2 → $3*$10 → $15*Большинство задач кодирования, повседневная работа
Opus 4.8$5$25Сложный архитектурный анализ, нетривиальный рефакторинг

Introductory pricing до 31 августа 2026, затем стандартные цены.

Haiku обходится в 15 раз дешевле Opus по входным токенам и в 5 раз дешевле Sonnet. Для задач вроде «переименовать переменную по всему файлу» или «конвертировать JSON в TypeScript-интерфейс» — Haiku абсурдно дёшев и абсурдно быстр.

Там, где Haiku ломается — задачи, которые выглядят простыми, но требуют читать код и принимать решения. Он даёт неверные ответы быстрее, что обходится вам циклом исправления. В сомнительных случаях Sonnet — надёжная золотая середина.

Если вам нужна рассуждение уровня Opus, но вы хотите контролировать расходы, псевдоним модели opusplan предоставляет автоматизированный гибридный подход: Claude использует Opus во время режима планирования для сложных рассуждений и архитектурных решений, затем автоматически переключается на Sonnet для генерации кода и реализации.

В Claude Code это команда /model opusplan — вы платите за Opus только на этапе составления плана, а вся дальнейшая работа выполняется на Sonnet.

Слой 2: уровни effort — управление глубиной мышления

Параметр effort позволяет напрямую контролировать, сколько токенов Claude тратит на обдумывание ответа. Это один из самых быстрых способов снизить расходы без смены модели. Вы можете повысить уровень до max для абсолютно максимальных возможностей, или снизить его, чтобы консервативнее расходовать токены, оптимизируя скорость и стоимость при принятии некоторого снижения возможностей.

УровеньКогда использовать
lowПростая классификация, быстрые поиски, высокообъёмные задачи
mediumБольшинство повседневных задач разработки
highПо умолчанию. Сложные задачи, требующие глубокого рассуждения
xhighНетривиальные архитектурные решения
maxКритически важные задачи, где любая ошибка дорого обходится

В Claude Code: команда /effort или настройка в /model.

Через API:

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=4096,
    effort="medium",  # low | medium | high | xhigh | max
    messages=[{"role": "user", "content": "Рефактори эту функцию"}]
)

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

# Ограничить thinking-токены в Claude Code
export MAX_THINKING_TOKENS=8000

Для более простых задач, где глубокое рассуждение не нужно, можно снизить расходы, понизив уровень effort с помощью /effort или в /model, отключив мышление в /config, или установив MAX_THINKING_TOKENS. Отключение мышления недоступно на Fable 5 — он всегда использует extended thinking.

Слой 3: кэширование промптов — экономия до 90%

Кэширование промптов — самый высокодоходный инструмент, если вы используете API напрямую.

Кэш write-токены стоят 1,25× стандартной ставки (единоразовая стоимость), но кэш read-токены стоят только 0,1× — скидка 90%. Если ваш системный промпт состоит из 10 000 токенов и вы делаете 100 API-вызовов, вы сэкономите примерно 990 000 токенов обработки.

ProjectDiscovery’s агент Neo задокументировал 59% кумулятивное снижение только от кэширования промптов, доходящее до 90%+ на полностью оптимизированных путях.

Правило структуры запроса: статичный контент всегда должен идти первым, динамичный — последним:

1. Системный промпт (статичный)      ← кэшируется
2. Определения инструментов (статичные) ← кэшируется
3. Большие документы (статичные)    ← кэшируется
4. История разговора (растёт)       ← частично кэшируется
5. Текущий запрос (динамичный)      ← не кэшируется

Реализация через Python SDK:

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=4096,
    system=[
        {
            "type": "text",
            "text": "Ты — эксперт по Python. Отвечай кратко и точно.",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[{"role": "user", "content": "Объясни декораторы"}]
)

Кэш живёт 5 минут с момента последнего использования (и продлевается при каждом обращении). Это значит: при активной работе с одним промптом кэш будет активен всё время сессии.

В Claude Code кэширование работает автоматически — отключать не нужно.

Слой 4: управление контекстом — главный источник незаметного расхода

Контекст — это не просто «история чата». Это всё, что Claude несёт с собой в каждом сообщении: файлы, которые он прочитал, выводы команд, определения инструментов, CLAUDE.md. Каждый следующий запрос оплачивает весь этот груз заново.

/compact — создать сжатую сводку текущего контекста:

# Compact — создать сжатую сводку текущего контекста
/compact

# Compact с указанием фокуса
/compact "Оставь только контекст, связанный с аутентификацией"

К тому моменту, когда Claude проверил несколько файлов, выполнил команды и исследовал несколько ложных следов, ваша сессия обычно содержит много материала, который больше не важен. Это правильный момент для compact.

Своевременность важнее, чем люди думают. Распространённая ошибка — использовать /compact слишком поздно. Если compact выполнить раньше, пока сессия ещё «здорова», сводка будет намного лучше.

/clear между задачами:

# Полная очистка контекста между задачами
/clear

Когда переключаетесь на принципиально другую задачу — полная очистка дешевле, чем тащить весь контекст.

CLAUDE.md: держите его компактным. 5 000 токенов в CLAUDE.md — это 5 000 токенов на каждом ходу каждой сессии навсегда. Оставьте только то, что действительно нужно при каждом запросе:

# Хорошо: 200 токенов
- Проект: e-commerce на Next.js 14
- БД: PostgreSQL + Prisma
- Тесты: Vitest
- Линт: ESLint flat config

# Плохо: 5 000+ токенов
- Полная история проекта
- Все соглашения по коду
- Документация API
- Описание каждой папки

Инструменты и коннекторы: отключайте то, что не используете в текущей задаче. В claude.ai: кнопка «+» → Connectors → Tool access → выбрать только нужные для сессии.

Прецизионное чтение файлов — не просите Claude прочитать весь репозиторий, давайте только нужный контекст:

# Плохо: Claude читает весь файл
"Прочитай src/auth/ и найди баг"

# Хорошо: только релевантные строки
"Посмотри на validateToken() в src/auth/jwt.ts:45-80"

Слой 5: субагенты — изолировать «шумную» работу

Запуск тестов, получение документации или обработка лог-файлов могут потреблять значительный контекст. Делегируйте это субагентам, чтобы verbose-вывод оставался в контексте субагента, а в ваш главный разговор возвращалось только краткое резюме.

Субагенты (.claude/agents/.md) запускаются в собственных контекстных окнах. Задача «проверь 30 файлов на нарушения стиля» загрязнила бы главную сессию огромным контекстом. Субагент изолирует этот шум и возвращает только: «Найдено 12 нарушений, вот список».

# Создание субагента в Claude Code
/agents create code-reviewer

# Использование: субагент работает изолированно
"Проверь весь src/ на TypeScript-ошибки через субагента"

Вместо того чтобы Claude тащил все 30 файлов в главный контекст — субагент работает изолированно, главная сессия остаётся лёгкой.

Слой 6: структура промптов — точность как компрессия

Вялые или неясные промпты ведут к более плохой работе. Расплывчатый 15-словный промпт, вынуждающий Claude задать три уточняющих вопроса, обходится дороже по итогу, чем точный 60-словный промпт, который работает с первого раза.

Это counter-intuitive, но важно: экономить токены на промпте — плохая идея, если это приводит к некачественному ответу и циклу переспрашивания. Более длинный, но точный промпт в итоге дешевле.

Разделяйте системный промпт и пользовательский запрос:

# Плохо: всё в одном сообщении
messages=[{"role": "user", "content": """
Ты эксперт по Python. Используй type hints.
Всегда добавляй docstrings.
Напиши функцию для валидации email.
"""}]

# Хорошо: системный промпт отделён
system="Ты эксперт по Python. Используй type hints. Всегда добавляй docstrings.",
messages=[{"role": "user", "content": "Напиши функцию для валидации email"}]

Ограничивайте длину ответа явно:

response = client.messages.create(
    model="claude-haiku-4-5",
    max_tokens=500,  # Жёсткий лимит на ответ
    messages=[{"role": "user", "content": "Что такое REST API?"}]
)

Используйте stop_sequences, чтобы не платить за лишние токены:

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=4096,
    stop_sequences=["\n\n## Конец"],  # Остановить на маркере
    messages=[{"role": "user", "content": "Сгенерируй документацию"}]
)

Слой 7: batch API для несрочных задач

Многие организации отправляют запросы по одному, тогда как пакетная обработка была бы эффективнее.

Batch API Anthropic даёт 50% скидку на входные токены для асинхронных запросов, которые не требуют немедленного ответа. Подходит для: генерации документации, анализа кодовой базы, создания тест-кейсов, пакетного рефакторинга.

import anthropic

client = anthropic.Anthropic()

batch_request = client.messages.batches.create(
    requests=[
        {
            "custom_id": "doc-1",
            "params": {
                "model": "claude-sonnet-5",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": "Сгенерируй JSDoc для этой функции"}]
            }
        },
        {
            "custom_id": "doc-2",
            "params": {
                "model": "claude-sonnet-5",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": "Сгенерируй JSDoc для этой функции"}]
            }
        }
    ]
)

# Результаты доступны в течение 24 часов
# Скидка 50% на input и output токены

Слой 8: мониторинг — оптимизировать то, что видишь

Нельзя оптимизировать то, чего не видишь. Производственные AI-команды в 2026 году запускают слой наблюдаемости, который отслеживает потребление токенов на функцию, пользователя, модель с денежной атрибуцией.

В Claude Code:

# Показать разбивку использования токенов
/usage

Вывод показывает разбивку по навыкам, субагентам, плагинам и отдельным MCP-серверам — каждый как процент от общего.

Для API-приложений — каждый ответ от API содержит точные данные об использовании:

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Привет"}]
)

print(response.usage)
# {
#   "input_tokens": 12,
#   "output_tokens": 25,
#   "cache_read_input_tokens": 0,
#   "cache_creation_input_tokens": 0
# }

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

Когда использовать

  • Счета за API растут быстрее, чем ожидается — первый сигнал: нужен аудит расхода токенов.
  • Команда использует Claude Code в ежедневной работе — CLAUDE.md, MCP-коннекторы и длинные сессии незаметно сжигают токены.
  • Запускаете продукт на API Claude — кэширование промптов, batch API и max_tokens напрямую влияют на юнит-экономику.
  • Нужен контроль бюджета без потери качества — выбор модели по задаче + уровень effort дают точный баланс.
  • Branch8-сценарий: $2 400 → $680 — если месячный счёт удивляет, значит несколько уровней оптимизации ещё не применены.

Пример

Кейс Branch8: команда задокументировала результаты внедрения оптимизаций за три месяца.

МесяцРасходТокеныЧто внедрили
Месяц 1$2 400~240 млнБазовая работа без оптимизации
Месяц 2——Выбор модели по задаче, effort levels, compact
Месяц 3$680—Полный набор: кэш, субагенты, batch, спринты

Снижение на 72%. Основной вклад: разбивка больших тикетов на короткие «спринты» (одна функция за раз), каждый спринт начинался с компакта существующего контекста и /clear в конце — это дало 67% снижение стоимости.

Типичные ловушки, которые встречаются на практике:

  • Ошибка #1: экономить на промпте → платить за переспрашивание. Расплывчатый промпт дешевле, только если Claude угадал правильно. Если нет — вы платите за уточняющие вопросы и переработку.
  • Ошибка #2: /compact слишком поздно. К моменту, когда появляется предупреждение о контексте — сессия уже перегружена и сводка получается грязной. Compact на 50–70% заполнения дёшевле и качественнее.
  • Ошибка #3: включённые инструменты, которые не используются. Каждый подключённый MCP-коннектор стоит токенов на каждом сообщении — независимо от того, используете ли вы его.
  • Ошибка #4: extended thinking на простых задачах. По умолчанию thinking включён. Для задачи «переименуй переменную» это буквально тысячи лишних токенов.
  • Ошибка #5: один большой разговор вместо сфокусированных сессий. Branch8 разбивала большие тикеты на короткие «спринты», охватывая только одну функцию за раз. Каждый спринт начинался с компакта существующего контекста и /clear в конце. Это дало 67% снижение стоимости.

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

Разработчик, который эффективно использует Claude, не срезает углы. Он демонстрирует то самое инженерное суждение, которое всегда отличало старших инженеров: понять проблему до её формулировки, декомпозировать чисто, предоставить нужный контекст и не больше, критически оценить вывод. Количество токенов — это побочный эффект ясного мышления.

Не существует одной «серебряной пули». Оптимизация расходов редко достигается одним изменением. Она приходит от комбинации умного выбора модели, эффективного дизайна промптов, управления контекстом, стратегий кэширования и настройки параметров API.

Актуально для Claude Sonnet 5, Opus 4.8, Haiku 4.5 и Claude Code 2.x. Июль 2026. Цены и параметры обновляются — проверяйте актуальные значения в docs.anthropic.com.

Ограничения

Ограничения

Кэш TTL фиксирован — стандартный кэш живёт 5 минут.

Если интервал между запросами больше — кэш истекает, и первый запрос каждый раз оплачивается по полной ставке (1,25× write).

Batch API асинхронный — результаты доступны в течение 24 часов.

Для real-time интерфейсов и интерактивных чатов batch не подходит.

MAX_THINKING_TOKENS работает не на всех моделях

— Fable 5 всегда использует extended thinking, отключить нельзя.

Effort

— поведенческий сигнал, не жёсткий лимит — на низких уровнях Claude всё ещё может думать на достаточно сложных задачах, но меньше, чем на высоких.

Цены меняются — introductory pricing Sonnet 5 действует до 31 августа 2026, далее стандартные тарифы.

Актуальные значения нужно проверять в docs.anthropic.com.

Haiku не универсален

— на задачах, где нужно читать код и принимать решения, Haiku даёт неверные ответы быстрее; цикл исправления обходится дороже экономии.

Subagent-изоляция требует настройки

— субагенты живут в .claude/agents/.md, их нужно создать и описать формат возврата, иначе шум вернётся в главную сессию.

Cache не работает с динамическим контентом — если системный промпт меняется от запроса к запросу, кэш бесполезен.

Структура запроса (статичное → динамичное) обязательна.

Антипаттерны

Антипаттерны

Не делать: гигантский CLAUDE.md на 5 000+ токенов — каждое сообщение оплачивает этот груз.

Оставьте только то, что нужно при каждом запросе; остальное — в отдельные файлы.

Не делать: все MCP-коннекторы включены постоянно

— Slack, Google Drive, Calendar, GitHub каждый стоит тысячи токенов на сообщение, даже если вы не кодите.

Не делать: /compact по сигналу тревоги — когда Claude Code предупреждает о контексте, уже поздно.

Compact на 50–70% заполнения даёт чистую сводку.

Не делать: одна сессия на весь день — разные задачи в одном контексте означают, что каждая следующая задача оплачивает весь контекст предыдущих.

/clear между задачами дешевле.

Не делать: экономия на промпте ради короткого ввода — 15-словный расплывчатый промпт ведёт к 3 уточняющим вопросам и переработке.

60-словный точный промпт — ответ с первого раза. Второе дешевле.

Не делать: extended thinking на тривиальных задачах — «переименуй переменную» с thinking = тысячи лишних output-токенов.

Понижайте effort или отключайте thinking.

Не делать: чтение всего файла вместо нужных строк

— «Прочитай src/auth/» вместо «Посмотри на validateToken() в src/auth/jwt.ts:45-80» — разница в десятки тысяч токенов.

Не делать: игнорирование response.usage

— если вы не логируете использование токенов, вы не знаете, где теряете деньги.

Чеклист

Чеклист

Выбрать минимально достаточную модель

— Haiku для простого, Sonnet для большинства, Opus для сложного.

Проверить effort

— понизить до medium или low для простых задач.

Включить кэширование промптов — cache_control:

{“type”: “ephemeral”} на статичный контент.

Выстроить порядок запроса — системный промпт

→ инструменты → документы → история → запрос.

Сократить CLAUDE.md

— убрать всё, что не нужно при каждом запросе.

Отключить неиспользуемые MCP-коннекторы

— оставить только нужные для текущей сессии.

Использовать /compact на 50–70%

— не ждать предупреждения о контексте.

Делать /clear между задачами

— полная очистка дешевле, чем тащить контекст.

Делегировать «шумную» работу субагентам

— тесты, логи, поиск по файлам.

Писать точные промпты

— 60 слов с первого раза дешевле, чем 15 слов плюс 3 уточнения.

Использовать max_tokens и stop_sequences

— ограничивать вывод жёстко.

Batch API для несрочных задач

— 50% скидка на input и output.

Логировать response.usage

— строить аналитику расходов.

Разбивать большие тикеты на спринты

— одна функция за раз, compact + clear.

Проверять цены в docs.anthropic.com

— тарифы обновляются.

Ссылки

Ссылки

По теме

По теме