# Исполнение кода с MCP: измерьте токены инструментов, прежде чем переписывать агента

> Исполнение кода с MCP может сократить контекст инструментов, но сначала измерьте, какие токены приходят от определений, а какие — от результатов. Вот процедура для Claude Code и Codex, а также таблица решений для прямых вызовов, поиска инструментов и исполнения кода.

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

**Короткий ответ:** Исполнение кода с MCP позволяет агенту вызывать инструменты из сгенерированного кода, чтобы он мог компоновать вызовы и фильтровать промежуточные данные, прежде чем показывать результат модели. Оно нацелено на две разные статьи расхода токенов: определения инструментов, загружаемые в контекст, и результаты инструментов, передаваемые обратно через контекст. Измерьте каждую, прежде чем менять настройку: поиск инструментов откладывает определения, а исполнение кода полезнее всего, когда несколько вызовов можно объединить или большие результаты можно сократить до того, как их увидит модель. [Исходный дизайн Anthropic](https://www.anthropic.com/engineering/code-execution-with-mcp) объясняет паттерн; это руководство измеряет его со стороны агента для кодинга.

## Что меняет исполнение кода с MCP?

Оно меняет то, как агент использует инструменты, а не сам протокол MCP. При прямом паттерне клиент показывает модели имя, описание и схему каждого инструмента, а затем возвращает результат модели после каждого вызова. Исполнение кода ставит перед этими вызовами небольшой кодовый интерфейс: модель пишет скрипт, рантайм вызывает MCP-инструменты, и только выбранный вывод возвращается модели.

MCP-сервер может остаться ровно таким, какой он есть, пока агент меняет способ обнаружения и вызова инструментов сервера. Агенту всё ещё нужно разрешение на доступ к серверу, а кодовому рантайму нужно безопасное место для запуска. [Объяснение Anthropic](https://www.anthropic.com/engineering/code-execution-with-mcp) использует файловую систему из TypeScript-обёрток; более новые возможности API, такие как поиск инструментов и программный вызов инструментов, дают другие способы откладывать инструменты или выполнять вызовы инструментов из кода.

Рабочая граница такова: **агент пишет код → код вызывает MCP-инструменты → песочница удерживает промежуточные данные → модель получает только возвращённое значение.** Если песочницы нет, шаг исполнения — это граница недоверенного кода, а не оптимизация токенов, которую можно включить между делом.

## Куда уходят токены MCP в сессии агента для кодинга?

Они уходят в две корзины: доступные определения инструментов и результаты, возвращаемые модели. На третью проблему — повторную оплату стабильного префикса определений — влияет кэширование промптов, но оно не заставляет этот префикс исчезнуть из окна контекста. [Руководство Anthropic по контексту](https://platform.claude.com/docs/en/agents-and-tools/tool-use/manage-tool-context) разделяет эти механизмы управления по той же причине.

| Корзина токенов                          | Что считать                                                                                        | Первый механизм управления, который стоит попробовать                                                                         |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| Определения, загруженные до задачи       | Имена, описания и схемы аргументов инструментов, которые видит агент                               | Сократите набор инструментов или используйте allowlist; применяйте отложенную загрузку, если большинство нужны редко          |
| Результаты, возвращённые во время задачи | Вывод инструментов плюс любые промежуточные данные, которые модель должна передать в другой вызов  | Фильтруйте, пагинируйте или суммаризируйте на источнике; используйте код для преобразования больших промежуточных результатов |
| Повторная оплата входных данных          | Стабильные определения инструментов и текст промпта, отправляемые снова в последующих API-запросах | Кэширование промптов; оно снижает стоимость повторного ввода, а не размер контекста                                           |

Не отождествляйте количество инструментов сервера с его токеновым следом. Десять многословных схем могут стоить дороже пятидесяти маленьких. А один вызов `get_document`, возвращающий целый архив, может многократно превысить стоимость своего определения.

## Как мне измерить стоимость токенов MCP в Claude Code и Codex?

Используйте представление контекста клиента для показания на уровне сессии, затем изолируйте сервер сравнением со свежей сессией. Для точной префлайт-проверки API посчитайте один и тот же запрос дважды: один раз без инструментов и один раз с массивом `tools` сервера.

**Claude Code:** Начните чистую сессию, выполните `/context` и запишите часть MCP/определений инструментов до выполнения задачи. Выполните ту же задачу с подключённым соответствующим MCP-сервером, затем снова проверьте `/context`. С текущим поиском инструментов Claude Code MCP-инструменты по умолчанию откладываются и обнаруживаются по требованию в поддерживаемых first-party-настройках, поэтому определение может появиться после того, как агент найдёт его через поиск; снимите показания и до, и после задачи. [Справочник команд](https://code.claude.com/docs/en/commands) документирует `/context`, а [справочник MCP](https://code.claude.com/docs/en/mcp) — поведение поиска инструментов по умолчанию и его исключения.

Вот как выглядит первое показание. В чистом тесте 4 октября 2026 года (Claude Code 2.1.289, пустой проект, пять подключённых серверов) `claude -p "/context"` перечислил каждый MCP-инструмент с его оценочным размером определения до запуска какой-либо задачи:

| Сервер                                    | Инструменты | Токены определений | Крупнейший инструмент          |
| ----------------------------------------- | ----------: | -----------------: | ------------------------------ |
| Playwright MCP 0.0.83                     |          25 |              ~6.8k | `browser_take_screenshot`, 578 |
| Octobrain 0.14.4                          |           4 |              ~4.2k | `memorize`, 1.7k               |
| Octocode 0.26.4                           |           4 |              ~3.5k | `structural_search`, 1.8k      |
| Octofs 0.16.0                             |           6 |              ~3.3k | `view`, 1.0k                   |
| MCP reference filesystem server 2026.8.31 |          14 |              ~3.1k | `read_text_file`, 321          |

Все 20.8k токенов этих определений находились в отложенной строке, вне стартовых 12.5k сессии. Два запуска различались на 1–3% по серверам. Количество инструментов — плохой прокси для стоимости здесь: 14 коротких инструментов reference filesystem server стоили меньше, чем 6 инструментов Octofs, а одно длинное описание может перевесить десяток коротких.

Для самой настройки клиента используйте наш [разбор MCP для Claude Code и Codex](/blog/octofs-0-16-faster-filesystem-for-claude-code-and-codex); эта процедура измерения предполагает, что сервер уже подключён.

**Codex:** В новом треде запишите `/status` и `/mcp`, выполните репрезентативную задачу, затем сравните `/status` после запуска нового треда с тем же сервером отключённым или с суженным списком его инструментов. Меняйте по одному серверу за раз.

Codex документирует использование контекста сессии в `/status` и подключённые серверы в `/mcp`; документированный статус — это показатель по всей сессии, и он не атрибутирует токены схем каждому серверу. Считайте разницу между контролируемыми запусками оценкой, потому что инструкции проекта, история промптов и другие инструменты тоже занимают контекст. [Текущий справочник Codex](https://developers.openai.com/codex/cli/slash-commands) перечисляет эти команды.

Для запроса к Messages API используйте эндпоинт Anthropic `POST /v1/messages/count_tokens` с вашим фактическим массивом `tools` и системным промптом. Сделайте один подсчёт с инструментами и второй с тем же запросом минус эти инструменты; вычтите итоги, чтобы оценить накладные расходы определений.

Эндпоинт возвращает количество токенов для сообщений, системного промпта и инструментов вместе и не создаёт ответ модели. Чтобы измерить и стоимость результатов, повторите подсчёт с включённым репрезентативным содержимым `tool_result`. Это префлайт-подсчёт; сверяйте его с фактическими данными об использовании из ответа при настройке реального рабочего процесса. [Справочник Anthropic по подсчёту токенов](https://platform.claude.com/docs/en/api/messages/count_tokens) определяет запрос и возвращаемое поле `input_tokens`.

Запишите четыре числа: начальный контекст до использования MCP, контекст после задачи, загруженные определения и токены возвращённых результатов. Повторите на той же задаче по одному серверу за раз. Это даст базовую линию, которую можно проверить после изменения инструментов.

## Выпустила ли Anthropic поиск инструментов после статьи о MCP 2025 года?

Да. По состоянию на 4 октября 2026 года Anthropic документирует отложенную загрузку инструментов в Messages API и говорит, что Claude Code включает поиск MCP-инструментов по умолчанию в поддерживаемых first-party-настройках. Версия API требует инструмент tool search и помечает подходящие определения `defer_loading`; Claude Code обрабатывает этот путь для подключённых MCP-серверов. [Руководство по API](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool) описывает форму запроса, а [текущая документация Claude Code по MCP](https://code.claude.com/docs/en/mcp) — когда происходит откат к загрузке инструментов заранее.

Это существенное обновление к более старому посту, но поиск инструментов не убирает из запроса каждое определение инструмента: API всё равно получает отложенные определения, чтобы искать и разворачивать их при необходимости. Он держит большую часть определений вне начального контекста модели и обменивает это место на дополнительный шаг обнаружения. [Руководство по поиску инструментов](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool) Anthropic говорит, что обычный вызов инструментов подходит лучше при менее чем 10 инструментах, когда вы используете каждый инструмент в каждом запросе или когда все определения вместе остаются ниже 100 токенов; его [обзор контекста инструментов](https://platform.claude.com/docs/en/agents-and-tools/tool-use/manage-tool-context) размещает поиск инструментов на наборах от 20 и более. Между этими отметками измерьте, прежде чем переключаться.

OpenAI предоставляет похожий путь `tool_search` в Responses API; текущее руководство говорит, что он поддерживается на gpt-5.4 и новее и использует `defer_loading: true` в определении MCP-инструмента. Это возможность API. В Codex CLI используйте `/status`, чтобы осмотреть общий контекст сессии, и сужайте открытые инструменты сервера через его MCP-конфигурацию. [Руководство OpenAI по поиску инструментов](https://developers.openai.com/api/docs/guides/tools-tool-search) описывает возможность API; [справочник конфигурации Codex](https://developers.openai.com/codex/config-reference) перечисляет `enabled_tools`.

## Что мне выбрать: прямые вызовы MCP, поиск инструментов или исполнение кода?

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

| Что выбрать                              | Когда подходит                                                                                                                            | Компромисс, который нужно учесть                                                                                                |
| ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| Прямые вызовы                            | Небольшой стабильный набор инструментов используется почти в каждой задаче, или человек должен проверять каждое отдельное действие        | Определения остаются доступными; большие выводы и поштучные раундтрипы вызовов всё равно используют контекст                    |
| Поиск инструментов / отложенная загрузка | Каталог большой, но каждая задача использует лишь несколько инструментов                                                                  | Один шаг обнаружения; API всё равно получает определения для поиска                                                             |
| Исполнение кода                          | Задача связывает несколько инструментов, проходит циклом по записям или может вернуть компактную сводку вместо сырых промежуточных данных | Требует среды исполнения с песочницей, лимитами и мониторингом; код может сделать несколько вызовов инструментов за один запуск |

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

Исходные числа полезны как примеры, а не прогнозы. Инженерный пост Anthropic 2025 года сообщает о падении со 150,000 до 2,000 токенов (98.7%) в его проектном примере. Пост Cloudflare за февраль 2026 года сообщает примерно о 1,000 токенов для их двух-инструментного Cloudflare API Code Mode против 1.17 миллиона для эквивалентного нативного набора инструментов; Cloudflare говорит, что в этом сравнении использовался tiktoken. Это собственные сообщённые результаты каждого вендора, а сервер, схемы, рантайм и форма задачи различаются. [Пост Anthropic](https://www.anthropic.com/engineering/code-execution-with-mcp) и [пост Cloudflare](https://blog.cloudflare.com/code-mode-mcp/) не устанавливают ожидаемую экономию для вашей настройки.

Отдельный [бенчмарк AIMultiple](https://aimultiple.com/code-execution-with-mcp), обновлённый в августе 2026 года, сообщает о сокращении входных токенов на 78.5% и росте средней задержки на 7% в его тесте Bright Data MCP / GPT-4.1. Выходные токены в этом бенчмарке выросли. Это напоминание отслеживать ввод, вывод, задержку и успешность задач отдельно; «меньше токенов» само по себе — неполный результат.

## Как мне ограничить вывод инструментов, не скрывая полезные данные?

Ограничивайте вывод на том слое, который знает, что нужно задаче. Сервер может пагинировать или возвращать фрагменты; MCP-клиент может ограничить отдельный результат инструмента; модель может попросить код выбрать поля и агрегировать строки перед печатью результата.

Claude Code предупреждает, когда MCP-инструмент возвращает больше 10,000 токенов, и имеет максимум по умолчанию в 25,000 токенов там, где инструмент не объявляет собственный лимит размера результата. Codex предоставляет поинструментный `output_token_limit` и общий `tool_output_token_limit` для выводов, сохраняемых в истории. Эти лимиты ограничивают то, что достигает контекста разговора; они не делают широкую схему инструмента меньше. См. [элементы управления выводом MCP в Claude Code](https://code.claude.com/docs/en/mcp) и [справочник конфигурации Codex](https://developers.openai.com/codex/config-reference).

Пример TOML для Codex с небольшим открытым набором инструментов и поинструментным бюджетом вывода. Чтобы подтвердить, что allow-list вступил в силу, `codex mcp get <server> --json` выводит разрешённые `enabled_tools` (проверено на Codex CLI 0.160.0); он также выводит переменные окружения сервера немаскированными, поэтому держите этот вывод подальше от тикетов и логов чатов:

```toml
[mcp_servers.example]
enabled_tools = ["search", "read"]

[mcp_servers.example.tools.read]
output_token_limit = 2000
```

Настроенный лимит — это бюджет, а не жёсткий потолок и не цель: Codex применяет `output_token_limit` до стандартной 20% надбавки на сериализацию, поэтому сохранённый результат может несколько выйти за него. Держите форму результата полезной: запрашивайте только нужные поля, пагинируйте записи и возвращайте количество или несколько репрезентативных строк, когда полные данные не нужны. [Руководство OpenAI по MCP](https://developers.openai.com/api/docs/guides/tools-connectors-mcp) также поддерживает фильтр `allowed_tools` в Responses API.

## Что исполнение кода меняет в безопасности и одобрениях?

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

API Anthropic теперь предлагает программный вызов инструментов в управляемой песочнице. Для самостоятельно собранной реализации Anthropic предупреждает, что исполнение на стороне клиента запускает недоверенный код вне песочницы и может быть вектором инъекции кода; самоуправляемая песочница добавляет изоляцию, но требует инфраструктурной работы. Code Mode для MCP от Cloudflare на базе Worker по умолчанию запрещает общий сетевой доступ и открывает конкретные сервисы как биндинги. Эти примеры показывают два паттерна: изолируйте исполнение и предоставляйте ему узко ограниченные возможности. См. [руководство Anthropic по программному вызову инструментов](https://platform.claude.com/docs/en/agents-and-tools/tool-use/programmatic-tool-calling) и [исходный дизайн Code Mode от Cloudflare](https://blog.cloudflare.com/code-mode/).

Не маршрутизируйте необратимую запись через широкий кодовый инструмент только ради экономии хода модели. Держите разрешения на запись узкими, сохраняйте границу подтверждения, где человек должен одобрить действие, и логируйте, какие нижележащие инструменты вызывает код. Если вы не можете аудировать кодовый путь или изолировать его песочницей, прямые вызовы с одобрениями проще для рассуждения.

## Как это выглядит для небольшого набора MCP-инструментов?

Небольшой набор всё равно может выиграть от формирования вывода, но исполнение кода ему может быть не нужно. Мы строим [octofs](/blog/introducing-octofs), файловый MCP-сервер с шестью инструментами, среди них `view` и `batch_edit`; `batch_edit` применяет до 50 непересекающихся правок к одному файлу за один вызов и возвращает свежие идентификаторы строк, так что агенту не нужно перечитывать файл. Octocode, наш сервер поиска по коду, по умолчанию открывает четыре инструмента (семантический поиск, структурный поиск, представления сигнатур и граф кода) и добавляет шесть LSP-инструментов, только когда вы настроите языковой сервер. У Octobrain, нашего сервера памяти, их четыре. В измерении выше они дали около 3.3k, 3.5k и 4.2k токенов определений: больше на инструмент, чем у reference filesystem server, и все отложены, пока они не понадобятся задаче. О более широкой границе безопасности при предоставлении агенту доступа к файловой системе см. [наше руководство по безопасности файловых систем](/blog/give-an-ai-agent-a-filesystem-safely).

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

— Don

---

_Попробуйте измерение на одной повторяющейся задаче и держите числа «до и после» рядом с конфигурацией вашего сервера. [Octofs](https://github.com/Muvon/octofs) и [Octocode](https://github.com/Muvon/octocode) — открытый код; если их наборы инструментов стоят больше контекста, чем должны в вашей настройке, откройте issue с вашими числами._