Claude Code тратит 33 000 токенов до вашего промпта — а OpenCode только 7 000

Вы запускаете Claude Code, пишете задачу и нажимаете Enter. Кажется, что работа только начинается. Но на самом деле к модели уже улетело 33 000 токенов системного промпта, схем инструментов и служебного скаффолдинга — прежде чем она успела прочитать хотя бы одно ваше слово.

OpenCode в той же ситуации тратит около 7 000 токенов. Разница — 4,7х. Это не баг и не недоработка. Это архитектурное решение, у которого есть своя логика, свои плюсы и вполне реальная цена.

Давайте разберёмся, откуда берётся этот разрыв, что он означает на практике и как выбрать инструмент под свои задачи.

Как измеряли: прокси на API-границе

Исследование провела команда Systima: они поставили логирующий прокси между агентом (Claude Code или OpenCode) и эндпоинтом Anthropic, перехватили все запросы и ответные блоки с метриками использования.

Оба инструмента тестировались на одной модели, одной машине и одних и тех же задачах. Claude Code использовал примерно 33 000 токенов системного промпта, схем инструментов и инжектируемого скаффолдинга до того, как промпт вообще поступал в обработку. OpenCode использовал около 7 000.

Что именно входит в эти 33k у Claude Code? Три компонента:

1. Системный промпт — детальные инструкции по поведению агента, политики использования инструментов, правила безопасности.
2. Схемы инструментов — JSON-описания всех 27 инструментов, которые агент может вызвать (bash, файловые операции, поиск и т.д.).
3. Инжектируемые блоки — Claude Code добавляет дополнительные <system-reminder> блоки по мере развития разговора: три на первом ходу, четыре к первому вызову инструментов.

Почему Claude Code такой «тяжёлый»

Это не случайность. Это продуктовое решение: Claude Code реализует функцию кросс-сессионной памяти и платит стоимостью промпта, необходимой для её работы. Если вам эта функция не нужна — промпт становится накладными расходами.

Claude Code и OpenCode оба инжектируют примерно 10 КБ политик в единственное описание инструмента. Но цель у этого разная. Взгляните на разницу в подходах:

Повторный запуск на Claude Fable 5 сократил разрыв примерно до 3,3х — потому что Claude Code отправляет новым моделям значительно меньший системный промпт. Инструмент всё равно «прожорливее», но множитель зависит от модели.

Парадокс многоходовых задач: кто тратит больше?

Вот где начинается самое интересное. Интуиция говорит: меньший baseline = дешевле. Но это работает только для коротких задач.

Поскольку baseline пересылается при каждом запросе, количество запросов умножает baseline. OpenCode платил свои ~7k девять раз, Claude Code платил свои ~33k три раза — и итоговые суммы сошлись.

graph LR
    A[Задача: написать и протестировать код] --> B{Стратегия агента}
    B --> C[Claude Code\n3 запроса × 33k = 99k base]
    B --> D[OpenCode\n9 запросов × 7k = 63k base]
    C --> E[Параллельные вызовы\ninstruments за 1 ход]
    D --> F[1 вызов\nза ход]
    E --> G[Итог сопоставим]
    F --> G

Claude Code обрабатывает всю задачу — две записи файлов и два запуска скриптов — как единый параллельный вызов инструментов за один ход. OpenCode делает ровно по одному вызову за ход и занимает девять.

Большой baseline при агрессивном батчинге и маленький baseline при последовательном выполнении могут прийти к одинаковому итогу.

Baseline в 33k токенов означает, что каждый ход начинается уже с заполненной одной шестой 200k-токенного контекстного окна — до того как в разговор вошёл хоть один байт кода.

Subagents: где разрыв становится критичным

Если базовые сценарии более-менее выравниваются, то с субагентами ситуация кардинально другая.

Когда Claude Code запускает субагентов, каждый из них несёт собственный bootstrap: системный промпт агента на 3 554 символа плюс 24 из 27 инструментов. Суммарные входящие токены достигают 513 000 — против 121 000 для той же работы без fan-out. Это множитель 4,2х за один умеренный разворот субагентов, потому что каждый субагент оплачивает свой bootstrap, а его транскрипт затем поглощается родителем.

Дизайн OpenCode здесь заметно легче: запросы его субагентов несут урезанный профиль — системный промпт на 1 379 символов и 5 инструментов.

Prompt Caching: лекарство, которое работает по-разному

Промпт-кэширование — это механизм, при котором повторяющиеся префиксы запросов читаются из кэша по сниженной цене вместо полной обработки. Казалось бы, это должно нивелировать разрыв в baseline. Но нет.

Префикс запроса OpenCode был байт-идентичным в каждом записанном запуске — он платил за кэширование один раз за сессию и читал обратно за копейки. Claude Code, напротив, перезаписывал десятки тысяч токенов кэша промпта в середине сессии, раз за разом, и на одной задаче записывал до 54 раз больше кэш-токенов, чем OpenCode. Запись в кэш, разумеется, тарифицируется с премией — именно этим объясняется рост счётчика расходов при использовании Claude Code.

Почему Claude Code перезаписывает кэш так часто? Из-за динамически инжектируемых <system-reminder> блоков — они меняются от хода к ходу, ломая стабильность префикса и вынуждая API повторно кэшировать расширенный контекст.

MCP-инструменты: ещё один слой накладных расходов

Model Context Protocol (MCP) позволяет агентам подключать внешние инструменты — базы данных, браузеры, API. Но загрузка схем инструментов стоит токенов.

По данным Anthropic, пять серверов с 58 инструментами обходятся примерно в 55 000 токенов до первого промпта, а их самая тяжёлая внутренняя конфигурация достигала 134 000 токенов только на определениях инструментов.

В реальном тестировании запуск семи активных серверов «съедал» 25% 200k-токенного окна ещё до ввода первого промпта. При ценах Claude Opus 4.5 это около $1.25 за сессию на инструменты, которые вы можете даже не использовать.

# Экспериментальный флаг для lazy-loading инструментов в Claude Code
export ENABLE_EXPERIMENTAL_MCP_CLI=true
# Инструменты загружаются по требованию, а не все сразу

Если установить ENABLE_EXPERIMENTAL_MCP_CLI=true, инструменты загружаются лениво вместо одновременной загрузки всех сразу. Это существенно помогает с накладными расходами.

OpenCode решает задачу иначе — декларативно:

// opencode.jsonc
{\n  \"mcp\": {\n    \"servers\": {\n      \"database\": {\n        \"match\": \"src/db/**\",  // инструмент доступен только в этой директории\n        \"command\": \"npx db-mcp-server\"\n      }\n    }\n  }\n}\n```\n\nOpenCode обращается с инструментами как с зависимостями в package.json: вы описываете их в opencode.jsonc и используете glob-паттерны, чтобы контролировать, кто и что видит. Такой декларативный подход держит контекст чистым.\n\n---\n\n## Кому и что выбирать: практический гайд\n\n



  
💡 Правило выбора
  
\nКороткие задачи, частые запросы → преимущество у OpenCode (меньший baseline × больше запросов не накапливается).\n\nДлинные многоэтапные задачи → Claude Code может сравняться или выиграть за счёт батчинга.\n\nFan-out субагенты → считайте токены вручную перед запуском.\n

\n\n| Сценарий | Рекомендация | Почему |\n|---|---|---|\n| Рефакторинг одного файла | OpenCode | Меньше baseline-токенов на короткий диалог |\n| Полный цикл write-run-test-fix | Claude Code или OpenCode — сопоставимо | Батчинг выравнивает разрыв |\n| Параллельные субагенты | OpenCode | 5 инструментов vs 24 у Claude Code |\n| Работа с 10+ MCP-серверами | OpenCode (glob-паттерны) | Декларативный контроль видимости |\n| Нужна глубокая интеграция с Claude | Claude Code | Модель-специфичная оптимизация |\n| Приватное окружение / локальные модели | OpenCode | Поддержка любого провайдера, нет утечки кода |\n\nOpenCode был построен с нуля как провайдер-агностичный harness. Абстракционный слой — это и есть продукт, а не afterthought. Интерфейс вызова инструментов, управление сессиями, маршрутизация конфигурации — всё предполагает, что вы будете менять модели.\n\n



  
📝 Используете Claude в OpenCode?
  
\nOpenCode прекрасно работает с моделями Anthropic. Добавьте ваш Anthropic API-ключ, выберите claude-sonnet-4-6 или claude-opus-4-6 — и OpenCode ведёт себя как Claude Code, но вы владеете harness’ом и платите за токены без subscription-надбавки.\n

\n\n---\n\n## Как снизить token overhead прямо сейчас\n\nToken overhead — это стоимость, задержка и бюджет контекста одновременно. Каждый токен harness-пейлоада — это токен рабочего контекста, который вы не можете потратить на код, и baseline пересылается (или перечитывается из кэша) при каждом ходу.\n\nПрактические шаги для обоих инструментов:\n\n1. **Ограничьте MCP-серверы** — подключайте только те, что нужны в текущем проекте.\n2. **Разбивайте длинные сессии** — новая сессия = чистый кэш, без накопленного транскрипта.\n3. **Используйте CLAUDE.md / agents.md аккуратно** — ограничивайте инжектирование контекста только необходимыми файлами, избегая широкого включения репозитория.\n4. **Включите lazy-loading** для Claude Code: `ENABLE_EXPERIMENTAL_MCP_CLI=true`.\n5. **Мониторьте токены** — отслеживание потребления токенов на каждую задачу даёт критически важные инсайты для оптимизации расходов и эффективности.\n\n---\n\n## Выводы\n\nРазрыв в 33k vs 7k токенов — не повод кричать «Claude Code плохой». Это повод понять, за что именно вы платите.\n\nClaude Code платит токенами за:\n- кросс-сессионную память,\n- детальные политики использования инструментов,\n- глубокую специализацию под семейство моделей Anthropic.\n\nOpenCode платит меньше токенов, но:\n- выполняет задачи последовательно (больше ходов → baseline × количество ходов),\n- требует ручной настройки для сложных сценариев,\n- теряет в части model-specific оптимизаций.\n\nНа многошаговой задаче итоговое суммарное потребление Claude Code может оказаться ниже, чем у OpenCode, — потому что он батчит вызовы инструментов в меньшее число запросов, пока OpenCode снова и снова платит меньший baseline. Счётчик стартует выше; дальнейшее развитие сессии определяет, кто потратит больше.\n\n> Токены — не просто деньги. Это контекст, время ответа и ограничение рабочего окна. Понимание того, куда они уходят, — первый шаг к осознанной работе с AI-агентами.\n\nВыбирайте инструмент осознанно, измеряйте реальные расходы на своих задачах — и не доверяйте «folklore», когда есть возможность поставить прокси и посмотреть на данные.","image_prompt":"Split-screen visualization of two AI coding agents sending tokens to a language model API. Left side shows a heavy stream of 33,000 colorful token particles labeled 'Claude Code' before reaching a chat bubble. Right side shows a lean stream of 7,000 tokens labeled 'OpenCode'. Background is dark with a modern terminal aesthetic, neon blue and purple accents, floating JSON schemas and system prompts as translucent layers. Technical, clean, futuristic style."}