Как сэкономить токены в LLM: практический гайд для Claude Code

Потратить 10 подписок по $200 — не проблема. Проблема — сделать это осмысленно. Ниже собраны рабочие подходы к экономии токенов, которые я использую в ежедневной работе с Claude Code.

1. Как мы вообще платим

Claude Code тарифицирует input и output токены. Input — все, что попадает в контекст: системный промпт, история чата, файлы, скриншоты. Output — то, что модель генерирует.

Каждое сообщение в чате добавляет к input весь накопленный контекст. В Claude Code сейчас доступен 1M-контекст для Opus (см. официальный гайд по сессиям) — это значит, что каждое сообщение в большой сессии оплачивается так, будто вы заново отправляете весь миллион токенов. Output тоже участвует в забивании контекста — он наращивается с каждым ответом.

Итого: чем короче переписка — тем дешевле. Чем меньше контекст — тем дешевле. Чем меньше “думает” модель — тем дешевле.

⚠️ Сюрприз перехода на Opus 4.7. У 4.7 обновленный токенизатор: тот же текст теперь маппится в ×1.0–1.35 токенов по сравнению с 4.6. Плюс на поздних ходах в агентских сессиях модель думает больше — output растет. Если вы переехали на 4.7 и счет “вдруг” подрос — это не баг, это новая тарификация. Перемерьте бюджеты на реальном трафике.

2. Субагенты — мастхэв

Главный процесс (лид) не должен ничего делать сам. Его задача — координировать и делегировать. Всю работу выполняют субагенты с маленькими контекстами.

Зачем:

• Контекст лид-процесса держится в рамках 100–200K и не растет
• Субагент отработал — контекст очистился
• Можно запускать параллельно десятки агентов

Как настраивать:

Главный процесс (Opus, 200K контекст)
├── Агент 1 (Haiku, короткий контекст) — обработка скриптов
├── Агент 2 (Sonnet, короткий контекст) — написание тестов
└── Агент 3 (Haiku, короткий контекст) — рефакторинг

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

🆕 Opus 4.7 спавнит меньше субагентов по дефолту. Anthropic в best practices пишут прямо: модель стала более “бережливой” и предпочитает делать сама. Если у вас сценарий, где fan-out по файлам реально экономит — пропишите явно: “Spawn multiple subagents in the same turn when fanning out across items or reading multiple files. Do not spawn a subagent for work you can complete directly in a single response.”

Ментальный тест Anthropic перед запуском субагента: “нужен ли мне будет промежуточный вывод инструмента еще раз — или только финальный вывод?” Если только вывод — это идеальный кандидат на субагента: весь шум останется в детском контексте, в родительский вернется только результат.

3. Context rot: контекст и галлюцинации — нелинейная зависимость

У этого явления есть официальный термин — context rot. Anthropic определяет его так: качество модели деградирует с ростом контекста, потому что внимание размазывается по большему числу токенов, а старый нерелевантный контент начинает мешать текущей задаче.

Opus с контекстом 100K работает точнее, чем Opus с контекстом 1M. То есть большой контекст — это и дороже, и хуже по качеству.

Особенно злая штука — autocompact в плохой момент: автоматическое сжатие контекста срабатывает, когда вы уже подобрались к лимиту, а это ровно тот момент, когда модель из-за context rot находится на минимуме своего интеллекта. Сводки получаются кривые, ключевые детали выпадают.

Вывод: держите контексты компактными. Лучше 5 чатов по 100K, чем 1 чат на 500K. И не ждите, пока сработает autocompact.

4. Управление сессией: rewind, compact, clear, /usage

С релизом 1M-контекста Anthropic подробно расписали, что каждый ход в Claude Code — это branching point. У вас не один путь (“написать еще сообщение”), а пять:

Практические правила:

• Новая задача = новая сессия. Это базовый rule of thumb от Anthropic.
• /rewind лучше, чем “попробуй иначе”. Если Claude прочитал 5 файлов и пошел по неудачному пути — не пишите “не работает, попробуй X”. Откатитесь к моменту после чтения файлов и переформулируйте: “не используй подход A, foo не экспортит это, иди сразу через B”. Полезные file reads сохраняются, провал выпадает из контекста.
• /compact vs /clear. /compact — автосводка, lossy, можно рулить инструкцией: /compact focus on the auth refactor, drop the test debugging. /clear — вы сами пишете бриф (“рефакторим auth middleware, ограничение X, файлы A и B, подход Y отмели”). Дольше — но контекст ровно тот, что вы решили оставить.
• Делайте /compact проактивно, пока модель еще не уперлась в стену. У вас 1M — времени хватает. Не ждите autocompact на минимуме интеллекта.
• Слеш-команда /usage показывает фактический расход — пользуйтесь, чтобы калибровать поведение.

Кто платит за /compact: суммаризацию делает ваша дорогая модель

Неочевидный момент: и /compact, и autocompact выполняются той же моделью, что выбрана в сессии. Кодите на Opus — значит “перечитать и ужать” миллион токенов истории Opus будет за полную цену Opus. Это чисто техническая суммаризация, за которую вы платите по флагманскому тарифу.

Что с этим делают (от худшего к лучшему):

1. Переключить модель перед сжатием — почти всегда ловушка. /model на Haiku/Sonnet → /compact → обратно на Opus. В теории сжатие дешевле. На практике смена модели в живой сессии сбрасывает prompt-кэш: накопленный кэш Opus сгорает, новой модели приходится перечитывать всю историю с нуля, и за это чтение спишут больше, чем вы сэкономили. Плюс у Sonnet/Haiku окно 200K против 500K–1M у Opus — на большом контексте младшая модель просто “ослепнет” (Context window exceeded). Прием оправдан только на небольших контекстах, где кэш и так крошечный.

2. Прокси, который перехватывает запрос на суммаризацию. Локальный прокси на ANTHROPIC_BASE_URL (тот же механизм, что у оберток из §6): обычные запросы идут на Opus, а служебный запрос на сжатие — он опознается по системному промпту или объему контекста — перехватывается и уходит на дешевую Haiku или на почти бесплатный Gemini Flash / GPT-4o-mini через OpenRouter. Для Claude Code это незаметно. Кэш основной сессии при этом не трогается: запрос на суммаризацию все равно читает историю целиком и от кэша почти не выигрывает, поэтому отдать его дешевой модели — чистая экономия.

3. Внешний агент + /clear (самый дешевый). В соседнем терминале гоняете отдельный CLI-агент на дешевой модели: он читает историю и измененные файлы проекта и пишет короткий context_summary.md. В Claude Code — /clear (контекст в ноль), затем “продолжаем на основе @context_summary.md”. Opus видит только крошечную выжимку. Ручная версия принципа “сохрани в .md”, доведенная до конца.

   Удобный кандидат на роль такого агента — opencode: полноценный терминальный агент с headless-режимом и выбором любой дешевой модели прямо на запрос.

   # дешевый агент пишет выжимку, не трогая токены Opus-сессии
   opencode run -m openrouter/google/gemini-flash \
     "Прочитай git log и измененные файлы, собери context_summary.md: ключевые решения, текущее состояние, следующие шаги"

   --format json дает машиночитаемый вывод, opencode serve + opencode run --attach … убирает холодный старт при частых вызовах. Это можно повесить на хук (§11): PreCompact/Stop дергает opencode run на Haiku/Gemini Flash — грязную суммаризацию делает копеечный агент сбоку, а Opus не жжет токены на чтение собственной истории. Важная оговорка: сам /clear (то, что реально обнуляет расход) хук вызвать не может — выжимку он подготовит автоматически, а обнулить контекст вы триггерите сами. Идейно — то же, что фоном делает cmdop-claude из §7, только готовым инструментом, который заодно можно просить выполнять и обычные подзадачи на дешевой модели, разгружая основную сессию.

⚠️ Кэш — главный подводный камень всей затеи. Любой прием со сменой модели в живой сессии сжигает prompt-кэш и session id: накопили 200K в Opus, переключились на Sonnet — весь кэш Opus сгорел, новая модель перечитывает все заново по тарифу подписки. Поэтому метод (1) обычно бессмыслен, а (2) и (3) выигрывают именно тем, что не трогают основную сессию — дешевая модель работает сбоку. Если нужно сжатие без сноса кэша прямо в сессии — смотрите CacheAligner в headroom (§13).

5. Скиллы решают

Навыки (skills) — преднастроенные промпты, которые загружаются по требованию и не сидят в контексте постоянно. Многие фреймворки первым делом подготавливают/скачивают скиллы для работы.

В отличие от MCP-серверов (которые постоянно загружают свои инструкции в контекст), скиллы активируются только когда нужны. До Opus 4.5 на MCP терялось много токенов — сейчас проблему решили, но подход “заменить MCP на скиллы и команды” все еще актуален для экономии.

Caveman

Caveman — открытый скилл и плагин для Claude Code (и других агентов): просит модель отвечать ультра-кратко в стиле речи пещерного человека, сохраняя техническую точность — наглядная реализация тезиса “чем короче переписка — тем дешевле” из §1. В бенчмарках репозитория в среднем около 65% экономии output-токенов; отдельно есть caveman-compress для сжатия прозы в memory-файлах и экономии input.

Если MCP все-таки нужен — сожмите его поверхность

MCP-серверы грузят описания всех своих инструментов в контекст при старте. Если совсем отказаться от MCP нельзя, есть прокси, которые режут этот оверхед:

• mcp-compressor от Atlassian Labs — прокси, который показывает агенту сжатую “поверхность” инструментов, а полную схему отдает только когда конкретный инструмент реально выбран. Уровни сжатия от low до max, есть OAuth. Бьет прямо по раздутым tool-definition.
• Context7 от Upstash — MCP, который по запросу подтягивает актуальную, версионно-точную документацию библиотек прямо в промпт, вместо того чтобы вы сами вываливали в контекст целые доки (или модель галлюцинировала устаревший API). Документация как инструмент по требованию, а не простыня в контексте.

6. Китайские модели и дешевые подписки

Alibaba Cloud, китайские подписки — по соотношению цена/токен они сильно выигрывают. Подписка за ~$30 дает сопоставимое с Anthropic $200 количество токенов.

Практика:

• Используются обертки над Claude, позволяющие переключать провайдера моделей
• Глобальные env-переменные не модифицируются — нужные передаются только при запуске обертки
• Gemini тоже имеет дешевые подписки, которые можно использовать аналогично

Пока нет готового решения “зашить все модели от разных провайдеров прямо в Claude”, но обертки закрывают 80% потребностей. Одна из таких — Clother — позволяет запускать Claude Code с разными провайдерами моделей, не трогая глобальные настройки.

7. Графы знаний и RAG: сокращение токенов в 10 раз

LightRAG

LightRAG — подход, который связывает графы знаний и LLM. Позволяет сократить расход токенов до 10 раз за счет структурированного извлечения релевантной информации вместо загрузки всего контекста.

væd.ai

væd.ai (ранее a8e) от ivansglazunov — единое ассоциативное поле вместо таблиц и коллекций: каждая сущность и связь живут в одном реактивном графе через оператор æ(), синхронизируемом с любым хранилищем (IndexedDB, PostgreSQL, FS, блокчейн). Для экономии токенов смысл тот же, что у LightRAG: связать граф и LLM и доставать релевантный срез контекста, а не вываливать в окно все подряд. Проект уже публичный: npm i vaed-ai, лицензия Unlicense (public domain). Глубже идея — в этом видео.

cmdop-claude

cmdop-claude — подход от markolofsen. Из графов используются деревья Меркла. Основная идея: крутить фоном почти бесплатные китайские LLM, чтобы приводить .claude папку в порядок — подготавливать контекст для основной модели.

Готовую глобальную настройку графа знаний — graphify с бэкендом на OpenRouter, чтобы семантика не ела токены Claude — разбираю в §13 вместе с rtk.

8. Фреймворки для управления агентами

Superpowers

Популярный фреймворк для Claude Code с набором готовых скиллов, паттернов и пайплайнов.

AI Factory

ai-factory — интересный фреймворк для управления AI-агентами. В связке с aif-handoff дает фронтенд с канбан-досками и фильтрами.

Ключевая идея: человек ставит изначальные задачи, AI их декомпозирует, но работа не начинается без одобрения человеком готового плана. Это и экономит токены (нет переделок), и дает контроль.

9. Effort levels у Opus 4.7: xhigh дефолт, max — антипаттерн

С Opus 4.7 появился новый уровень xhigh между high и max. И в Claude Code теперь это дефолт для всех планов. Старая интуиция “выкручу max — будет умнее” больше не работает.

Anthropic рекомендует так:

Ключевой тезис. Если вы апгрейдились с 4.6 — не переносите старый effort механически. Поэкспериментируйте: то, что вы крутили на high у 4.6, на 4.7 часто работает на medium за меньшие деньги.

Adaptive thinking: фиксированного бюджета больше нет

Extended Thinking с фиксированным thinking budget в 4.7 не поддерживается. Вместо него — adaptive thinking: модель сама решает на каждом шаге, нужно ли “думать”, и сколько.

Управляется промптом:

• Хотите больше размышления: “Think carefully and step-by-step before responding; this problem is harder than it looks.”
• Хотите экономии: “Prioritize responding quickly rather than thinking deeply. When in doubt, respond directly.” — теряете часть точности на сложных шагах, но сохраняете токены.

10. Практические мелочи

Опишите задачу полностью на первом ходе. Anthropic пишут прямо: “относитесь к Claude как к способному инженеру, которому делегируете, а не как к напарнику, которого ведете построчно”. Хорошее ТЗ с intent, ограничениями, acceptance-критериями и путями к файлам — на первом сообщении. Размазанные по 10 ходам уточнения не только дороже (каждый ход добавляет reasoning overhead), но и снижают качество результата на 4.7.

Auto mode для доверенных длинных задач. В Claude Code Max появился auto-режим (Shift+Tab) — Claude принимает решения за вас, прерываясь реже. Меньше итераций согласования = меньше токенов.

Скиллы вместо MCP. До Opus 4.5 замена MCP на скиллы давала ощутимую экономию. Сейчас разница меньше, но для массовых задач подход все еще рабочий.

Управление моделью субагентов. Можно указывать, какую модель должен использовать субагент. Для рутинных задач — Haiku, для сложных — Sonnet или Opus.

Длина ответа теперь калибруется автоматически. Opus 4.7 короче на простых запросах и длиннее на open-ended анализе — менее verbose по дефолту. Если жестко нужна определенная длина или стиль — указывайте явно. Anthropic подсказывают: позитивные примеры стиля работают лучше, чем “не делай так”.

Меньше инструментов, больше рассуждений. Opus 4.7 по дефолту реже ходит в инструменты. Если вашему сценарию нужен агрессивный поиск/чтение файлов — пропишите когда и зачем, иначе модель сэкономит ходы за счет догадок.

Task budgets (API). В Claude Platform появились task budgets в public beta — можно ограничивать токеновый бюджет на длинный run целиком, а не молиться, чтобы модель сама не разогналась.

Режим --bare — чистый запуск. Флаг --bare запускает Claude Code без хуков, LSP, синхронизации плагинов, авто-памяти, фоновой предзагрузки и — главное — без авто-обнаружения CLAUDE.md. Все это обычно подгружается в системный промпт и жжет токены еще до первого сообщения. В bare-режиме контекст стартует минимальным, а нужные данные можно передать точечно через --system-prompt, --append-system-prompt, --add-dir или --mcp-config. Идеально для массовых субагентов, где лишний препромпт — чистый расход.

11. Хуки — автоматическая экономия

Хуки (hooks) — это скрипты, которые срабатывают на события внутри Claude Code. Настраиваются в .claude/settings.json и позволяют автоматизировать рутину, экономящую токены.

Типы хуков

• PreToolUse — срабатывает перед вызовом инструмента. Можно фильтровать или модифицировать входные данные.
• PostToolUse — срабатывает после. Полезен для автоформатирования и постобработки.
• PreCompact — срабатывает перед сжатием контекста. Позволяет сохранить важную информацию.
• Stop — срабатывает, когда агент заканчивает работу. Можно проверить полноту выполнения.
• SessionStart — срабатывает при старте сессии. Полезен для предзагрузки контекста.

Примеры полезных хуков

Фильтрация вывода тестов. Официальный пример от Anthropic — хук на PreToolUse для Bash, который обрезает длинный вывод тестов, оставляя только упавшие тесты и summary. Вместо 500 строк лога в контекст попадает 10 строк — прямая экономия токенов.

{
  "hooks": {
    "PreToolUse": [{
      "matcher": "Bash",
      "command": "ваш_скрипт_фильтрации.sh"
    }]
  }
}

Автоформатирование после записи. Хук на PostToolUse для Write/Edit — запуск prettier или black после каждого сохранения файла. Модели не нужно тратить токены на форматирование кода — она пишет логику, а форматирование делает хук.

Защита от деструктивных команд. Хук на PreToolUse для Bash, который блокирует rm -rf, DROP TABLE и подобные команды. Не экономит токены напрямую, но защищает от дорогих ошибок и переделок.

Сохранение контекста перед компактом. Хук на PreCompact — перед сжатием контекста можно сохранить ключевые решения и состояние в файл, чтобы не потерять их после компакта. Сильный прием — отдать саму суммаризацию внешнему агенту на дешевой модели (например, opencode run -m …, см. §4): хук пишет выжимку руками копеечной модели, а не заставляет Opus перечитывать собственную историю по флагманскому тарифу.

Что хуки НЕ могут

Автокомпакт каждое N-е сообщение нельзя настроить через хуки — это встроенная функция Claude Code. Но можно использовать хук PreCompact, чтобы управлять тем, что сохраняется при сжатии.

12. Скриншоты — скрытый пожиратель токенов

Claude по документации сжимает изображения по разрешению. На практике — сжатия не заметно. На 4K-мониторе один скриншот стоит дорого.

⚠️ С Opus 4.7 ситуация еще хуже. Модель теперь принимает картинки до 2576px по длинной стороне (~3.75 МП) — это в три с лишним раза больше, чем у предыдущих моделей. Anthropic в сноске анонса пишут прямо: “higher-resolution images consume more tokens, users who don’t require the extra detail can downsample images before sending them to the model”. То есть штатный апгрейд по vision одновременно стал и апгрейдом счета.

Решение: урезать скриншоты до ~400px по ширине перед отправкой. Текст остается читаемым, а токенов тратится на порядок меньше.

Для macOS я сделал Open Screenshot — утилиту, которая делает скриншоты сразу в ужатом по разрешению формате. Ничего ресайзить вручную не нужно. Пользуйтесь!

13. Готовая настройка из коробки: rtk + graphify

Два инструмента, которые держу включенными глобально — каждый бьет по своей статье из §1: rtk режет input от команд, graphify убирает “прочитай весь репозиторий” из контекста. Оба без своего API-ключа (graphify гоняет семантику через дешевый OpenRouter, а не через токены Claude). Вместе с caveman (§5) получается законченный стек: input команд + контекст репозитория + output модели.

Готовую настройку собрал в отдельный репозиторий — suenot/claude-code-token-savers (скрипты, патчи, хуки, setup.sh).

rtk — сжатие вывода команд

rtk (Rust Token Killer) — CLI-прокси: фильтрует, дедуплицирует и обрезает вывод 100+ команд (git, docker, pytest, cargo…) на 60–90% перед тем, как он попадет в контекст. Один бинарь, без зависимостей, <10 мс оверхеда, без LLM.

brew install rtk
rtk init -g --auto-patch   # ставит глобальный PreToolUse-хук для Claude Code
# рестарт Claude Code; проверка: git status

Хук прозрачно переписывает git status → rtk git status. Это тот же прием, что в §11 (фильтрация вывода тестов хуком), но сразу на сотне команд.

graphify — граф знаний вместо чтения всего репозитория

graphify превращает код и доки в граф знаний (узлы, сообщества, god-nodes), который вы запрашиваете (/graphify query "…") вместо того, чтобы вываливать файлы в контекст — практическое воплощение идеи из §7. Ключевой трюк: семантическое извлечение гоняется через OpenRouter (deepseek/deepseek-v4-flash), а не через токены Claude — сборка графа среднего проекта стоит ~$0.10 на OpenRouter и ноль токенов сессии.

Что в готовой настройке (репо выше, папка graphify/, ./setup.sh):

• бэкенд OpenRouter (~/.graphify/providers.json, модель меняется через GRAPHIFY_OPENROUTER_MODEL);
• SessionStart-хук авто-watch: есть граф — следит за изменениями и обновляет; проект не инициализирован — просто пишет “run /graphify .” (чтобы случайно открытая корневая/огромная папка не сожрала токены);
• чистый тумблер no-media (touch ~/.graphify/no-media) — не тащить картинки/pdf/видео в граф, без возни с ignore-файлами;
• фикс безопасности: .graphifyignore больше не “затмевает” .gitignore (мерж вместо замены, PR #1364 в апстрим), плюс pre-commit-guard, не дающий закоммитить граф с попавшим в него .gitignore-файлом.

Caveman (§5) добивает третий слой — вывод самой модели. rtk + graphify + caveman = input команд, контекст репозитория и output модели соответственно. Только над текстами caveman лучше выключать (“normal mode”) — лаконичный стиль мешает редактуре.

headroom — компрессия всего входа (и где он спорит со стеком)

headroom от Headroom Labs идет дальше rtk: сжимает не только вывод команд, а вообще весь вход — tool-output, логи, файлы, код, RAG-чанки, историю — на заявленные 60–95%. Под капотом конвейер из специализированных компрессоров: SmartCrusher (JSON/массивы), CodeCompressor (AST-парсинг Python/JS/Go/Rust/Java/C++), Kompress-base (обученная модель для прозы) и роутер, который сам определяет тип входа. Два важных козыря:

• CacheAligner — стабилизирует префиксы, чтобы родной KV-кэш Anthropic/OpenAI все-таки попадал. То есть headroom целенаправленно решает ту самую проблему сгорающего кэша из §4.
• CCR (reversible compression) — оригиналы кэшируются локально, и если модели реально нужна полная версия, она дергает инструмент headroom_retrieve. Сжатие без необратимой потери данных.

Ставится и оборачивает Claude Code так:

pip install "headroom-ai[all]"
headroom wrap claude        # есть флаги --memory и --code-graph под Claude Code

Режимов несколько: библиотека (compress(messages)), HTTP-прокси на localhost:8787, CLI-обертка (headroom wrap) и MCP-сервер.

Будет ли конфликт с уже стоящим стеком (rtk + graphify + caveman + Clother)? Зависит от режима:

Сам пока не гоняю в проде, но как “тяжелая артиллерия” поверх rtk/graphify — кандидат номер один, особенно ради CacheAligner (см. §4 про сгорающий кэш).

pxpipe — рендер запроса в картинки (§12 наоборот)

pxpipe от teamchong заходит к входу с неожиданной стороны. В §12 скриншот — враг: картинка жрет токены. pxpipe переворачивает это: стоимость картинки в токенах фиксирована ее размером в пикселях, а не тем, сколько текста в нее упаковано. На реальном трафике Claude Code плотный контент (код, JSON, вывод инструментов) укладывается примерно в 3.1 символа на image-токен против ~1 символа на text-токен. Поэтому pxpipe берет громоздкие статичные части каждого запроса — системный промпт, описания инструментов, старую историю — и рендерит их в плотные PNG еще до того, как запрос уйдет с вашей машины. Модель читает их через тот же vision-канал, на который уже опирается computer use от Anthropic. Заявленный результат — счет за вход ниже на ~59–70%, и главная метрика тут — само сокращение токенов, измеряемое на каждом запросе против бесплатного контрфактического счетчика count_tokens.

Это прокси, и — чтобы сразу снять очевидный вопрос — интеграция уже нативная: ни плагина, ни хука, только встроенный в Claude Code ANTHROPIC_BASE_URL.

npm install -g pxpipe-proxy   # or on demand: npx pxpipe-proxy
pxpipe                                            # proxy on 127.0.0.1:47821
ANTHROPIC_BASE_URL=http://127.0.0.1:47821 claude  # point Claude Code at it

Дашборд на 127.0.0.1:47821 показывает сэкономленные токены, каждую конвертацию текст→картинка бок о бок, живой kill switch и пишет каждое событие в ~/.pxpipe/events.jsonl. Сжимается только запрос — ответы стримятся как обычно.

⚠️ Это лоссово, и промахи молчаливые. Точные байтовые значения (hex-строки, ID, хеши, секреты), считанные с картинки, могут быть сконфабулированы, а не выданы как ошибка. Поэтому свежие ходы автоматически остаются текстом, а байт-точную работу стоит уводить в субагента на модели не из allowlist (CLAUDE_CODE_SUBAGENT_MODEL=claude-sonnet-4-6), которая проходит текстом насквозь. Многое зависит и от читателя: на ридере Fable 5 он берет ~100/100 на текстовых иголках, а Opus искажает содержимое картинок — поэтому pxpipe оставляет Opus включаемым только по желанию.

Где он спорит со стеком. Оговорка та же, что у headroom-proxy: pxpipe занимает ANTHROPIC_BASE_URL, поэтому без цепочки не уживается на одном base URL с Clother или headroom-прокси — выбирайте один прокси спереди, а хуковые инструменты (rtk, graphify, caveman) вешайте сверху. Это самый радикальный компрессор входа из всей подборки и тот, что стоит попробовать, когда вас реально убивает именно счет за запрос (системный промпт + описания инструментов + длинная история).

14. Экономия на стороне сервера и API (что Claude Code уже делает — а что нет)

Все, что выше, — это то, что вы навешиваете сами. Но целый слой экономии живет на стороне Anthropic — часть его уже включена за вас в Claude Code, часть доступна только если вы строите на голом API/SDK. Понимание, что есть что, удерживает вас от установки инструмента ради проблемы, которую платформа уже решила, — и от допущения, что фича включена, когда она выключена.

Advanced tool use: Tool Search, Programmatic Tool Calling — уже включены по дефолту

Набор advanced tool use от Anthropic (ноябрь 2025) — крупнейший единичный выигрыш в этом списке, и хорошая новость в том, что вы его не настраиваете:

• Tool Search Tool (defer_loading). Вместо того чтобы вываливать полную схему каждого инструмента в системный промпт на каждом запросе, модели показываются только имена инструментов, а полное определение она подтягивает лишь для тех, что реально нужны. Цифра Anthropic: 77K → 8.7K токенов (~85%) на большом наборе инструментов. В Claude Code это уже активно по дефолту — при куче подключенных MCP-серверов и плагинов лишние инструменты лежат как имена, пока их не вызовут, а модель тянет схему по требованию. Настройки переключать не надо: включается по масштабу — чем больше инструментов подключено, тем больше экономия. Единственный случай, где об этом надо думать, — собственный harness / приложение на Agent SDK: там вы реализуете это сами (помечаете инструменты defer_loading: true) или хотя бы проверяете, что ваш harness делает отложенную загрузку, иначе снова платите за каждую схему на каждом ходе.
• Programmatic Tool Calling. Модель пишет код в исполняемом контейнере, который вызывает инструменты и фильтрует их результаты до того, как они попадут в контекст, — вместо того чтобы каждый сырой результат инструмента гонять через окно. Обычно 20–40% на агентских прогонах с интенсивным использованием инструментов (плюс прирост точности). Это пока API-native (beta) и не автоматизировано в Claude Code.

Вывод: экономия ~85% на схемах инструментов уже ваша в Claude Code — без лишней настройки. Думать об этом стоит только если вы пишете собственный harness.

Context editing (clear_tool_uses) — фича API; Claude Code дает свою версию

Context editing от Anthropic (beta-заголовок context-management-2025-06-27, стратегия clear_tool_uses_20250919) автоматически чистит самые старые результаты инструментов, как только контекст переваливает за порог, заменяя каждый на короткий плейсхолдер. В 100-ходовом eval Anthropic это дало сокращение токенов на 84% на прогоне, который иначе умер бы от исчерпания контекста.

Но: этот сырой рычаг в Claude Code не выведен наружу (есть открытый запрос его добавить). Взамен Claude Code дает microcompact — он автоматически сгружает крупные результаты инструментов на диск и держит только горячий хвост свежих результатов плюс ссылки на пути, — работая молча рядом с /compact и autocompact. То есть само поведение (прунинг устаревшего вывода инструментов) закрыто за вас автоматически; конкретный параметр API доступен только если вы строите прямо на API/SDK Anthropic. Не ищите настройку clear_tool_uses в Claude Code — вы уже получаете домашнюю версию.

Проактивный prompt caching — 90% скидки на чтение из кэша, и в основном автоматически

Prompt caching в GA и фундаментален: чтение из кэша стоит 0.10× input (−90%). Два TTL — 5-минутный (по дефолту) и 1-часовой (extended). Claude Code уже агрессивно кэширует за вас; от вас зависит, попадет ли кэш:

• Держите начало контекста байт-стабильным — системный промпт, определения инструментов и CLAUDE.md не должны меняться между ходами, иначе префиксный кэш промахивается и модель перечитывает с нуля.
• Не переупорядочивайте инструменты и не переписывайте ранний контекст посреди сессии (это ровно та ловушка “сгорающего кэша” из §4).
• Opus 4.8 тут помогает: он позволяет сообщению role:"system" появиться после хода пользователя, так что можно дописывать инструкции без слома кэшированного префикса, и он снизил минимальный кэшируемый промпт до 1024 токенов.

Message Batches API — фиксированные 50% скидки на офлайн-массивы

Для неинтерактивной массовой работы — сценарий “8000 скриптов, по субагенту на каждый” из §2 или массовая суммаризация / классификация / evals — Message Batches API гоняет их асинхронно (результаты за 24ч, обычно гораздо раньше) с фиксированной скидкой 50% на input и output, и это стакается с prompt caching (еще 90% на чтениях из кэша).

Загвоздка: у самого Claude Code нет batch-режима. Это интерактивный REPL — каждый ход это живой запрос по полной цене, нет кнопки “поставить 8000 задач в очередь за полцены”. Скидка 50% живет слоем ниже, на голом API, и добраться до нее можно только выйдя из CLI:

• Anthropic API / SDK напрямую — client.messages.batches.create(...) (Python/TS). Здесь вы сами скриптуете массовый проход или строите его на Claude Agent SDK, а не на интерактивном CLI.
• AWS Bedrock — “Batch Inference”.
• Google Vertex AI — “Batch Prediction”.
• (Тот же паттерн и в других местах: у OpenAI есть эквивалентный Batch API на −50%.)

Отсюда правило: интерактивный кодинг → Claude Code (кэширование тянет основную нагрузку); офлайн-массивы → спуститесь на API/SDK или Bedrock/Vertex и батчите. Попытка протолкнуть массовую разметку через интерактивный CLI оставляет эти 50% на столе.

Дешевая гигиена: /context, поджарый CLAUDE.md и отключение простаивающих MCP-серверов

• /context печатает разбивку токен-за-токеном по тому, что забивает ваше окно, — системный промпт, системные инструменты, MCP-инструменты, memory-файлы (CLAUDE.md), кастомные агенты, сообщения. Запустите, чтобы увидеть, кто обжора.
• Раздутый CLAUDE.md — налог на каждое сообщение: memory-файл на 10K токенов пересылается заново с каждым ходом. Держите его поджарым, а инструкции под конкретную задачу выносите в скиллы (загружаются по требованию).
• Каждый простаивающий MCP-сервер тарифицирует свои определения инструментов на каждом запросе. Отключайте неиспользуемые через /mcp (или тумблер вроде cctoggle). Tool Search это смягчает, но вовсе не использовать сервер все равно дешевле, чем откладывать его загрузку.

Structured Outputs — убираем ретраи и преамбулу

Structured Outputs (beta) использует constrained decoding, чтобы гарантировать схемо-валидный JSON (output_format или strict: true на инструментах). Экономия косвенная, но реальная: нет round-trip-ретраев на невалидном JSON (единственный провалившийся парсинг стоит дороже, чем ~2–3% оверхеда схемы), и это срезает многословное проговоренное рассуждение, которым модель иначе обернула бы ответ.

Две вещи, на которые НЕ стоит тратиться

• Заголовок token-efficient-tools-2025-02-19 — история. Он резал токены вывода tool-call только на Claude 3.7 Sonnet; каждая модель Claude 4+ (включая Opus 4.7/4.8) делает token-efficient tool use по дефолту, так что сегодня заголовок — no-op. Не добавляйте.
• LLMLingua-2 (компрессор промптов от Microsoft, 2–5×) реален и хорош, но это движок, который встает на ту же работу, что уже закрывает headroom (§13), — а не отдельный метод для установки рядом.

Чеклист экономии

Слить можно сколько угодно — и 10 аккаунтов по $200 не предел. Но это не показатель эффективности. Цель — сократить расходы хотя бы в 10 раз, не потеряв в качестве.