Как сэкономить токены в 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. У вас не один путь (“написать еще сообщение”), а пять:

Ситуация	Что использовать	Почему
Та же задача, контекст еще нужен	Continue	Все в окне еще работает, не платите за пересборку
Claude пошел не туда	/rewind (Esc Esc)	Сохраняет полезные file reads, выкидывает провалившуюся попытку
Сессия раздулась устаревшим debug/exploration	/compact	Дешево; Claude сам решит что важно (можно подсказать)
Начинаете реально новую задачу	/clear	Ноль rot; вы сами контролируете, что переносится
Следующий шаг даст много мусорного output, а нужен только итог	Subagent	Шум остается в детском контексте, в родительский — только результат

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

• Новая задача = новая сессия. Это базовый 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 рекомендует так:

Уровень	Когда использовать
low / medium	Cost-/latency-sensitive, узкие задачи. На том же уровне 4.7 уже сильнее 4.6 — и low-effort 4.7 ≈ medium-effort 4.6 по качеству. Прямая экономия.
high	Параллельные сессии или хочется снизить расход без большой просадки качества.
xhigh (дефолт)	Лучшее для большинства кодинга и агентских задач. Сильная автономия + интеллект, без runaway-токенов, которые дает max на длинных прогонах.
max	Не используйте по умолчанию. Diminishing returns, склонен к overthinking. Anthropic пишут прямо: “use it deliberately for tasks like testing the model’s maximum ceiling in evals and for extremely intelligence-sensitive and non-cost-sensitive uses”.

Ключевой тезис. Если вы апгрейдились с 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)? Зависит от режима:

С чем	Вердикт
Clother / любая обертка на ANTHROPIC_BASE_URL	⚠️ Конфликт в прокси-режиме: и headroom-proxy, и Clother хотят занять ANTHROPIC_BASE_URL. Два прокси на один base URL не повесить (без цепочки). Выбирайте один — либо гоняйте headroom как wrap/MCP/библиотеку, а не как прокси.
rtk	Дублирование, не поломка. Оба сжимают вывод команд, но на разных слоях: rtk — легкий хук на Rust (<10 мс, без LLM), headroom — тяжелее (AST/модель), зато шире. Разумно развести: rtk на команды, headroom на файлы/код/RAG. Включить оба на одно и то же можно, но headroom будет повторно жевать уже ужатый rtk-вывод — не страшно, но бессмысленно.
graphify	✅ Не пересекаются. graphify режет input от “прочитай весь репозиторий”, headroom — tool-output и файлы. Дополняют друг друга.
caveman	✅ Не пересекаются. caveman жмет output модели, headroom — input. Разные стороны баррикад.

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

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

Подход	Экономия
Субагенты с короткими контекстами	2–5x на длинных сессиях
Китайские модели для рутины	5–10x по цене ($30 vs $200)
Скиллы вместо постоянного MCP	1.5–2x
Хуки для фильтрации вывода	1.5–3x на задачах с тестами/логами
Компактные скриншоты (особенно с 4.7)	2–3x на задачах с визуалом
Графы/RAG вместо полного контекста	до 3–5x
Снижение effort у Opus 4.7 (low/medium вместо high)	1.5–3x при сопоставимом качестве
Отказ от max в пользу xhigh по дефолту	до 2x на длинных агентских прогонах
/rewind вместо “попробуй иначе”	1.3–2x: выкидывает мусор, оставляет file reads
/compact проактивно (до autocompact)	сохраняет качество, меньше повторных проходов
Полное ТЗ на первом ходе (Opus 4.7)	1.3–1.7x: меньше ходов, меньше reasoning overhead
--bare режим для субагентов	1.5–2x на каждом запуске
Adaptive thinking-промпт “отвечай быстро”	1.2–1.5x на простых задачах
Task budgets (API)	защита от runaway-токенов на длинных run
Фреймворки с одобрением плана	косвенно, через меньшее число переделок
rtk — сжатие вывода команд (PreToolUse-хук)	1.5–3x на git/docker/pytest/логах
graphify — граф вместо полного контекста (семантика на OpenRouter)	до 10x на навигации по большому репо; сборка ~$0.10, не токены Claude
Суммаризация /compact на дешевой модели (прокси / внешний агент типа opencode)	сжатие по цене Haiku вместо Opus, без сноса кэша основной сессии
headroom — сжатие всего входа (tool-output/файлы/код/RAG)	60–95% на входе; CacheAligner бережет KV-кэш, CCR обратим
mcp-compressor — сжатие поверхности MCP (схема по требованию)	режет tool-definition оверхед от MCP-серверов

---

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