# Ejecución de código con MCP: mide los tokens de herramientas antes de reescribir tu agente > La ejecución de código con MCP puede reducir el contexto de herramientas, pero primero mide qué tokens vienen de las definiciones y cuáles de los resultados. Aquí tienes un procedimiento para Claude Code y Codex, más una tabla de decisión para llamadas directas, búsqueda de herramientas y ejecución de código. Añades un servidor porque una tarea lo necesita. Luego otro. Pronto el agente de programación empieza cada sesión cargando un mapa de herramientas que quizá nunca llame, y cada resultado largo se empaqueta en la conversación de todos modos. **Respuesta corta:** la ejecución de código con MCP permite que un agente llame a herramientas desde código generado, de modo que puede componer llamadas y filtrar datos intermedios antes de mostrar un resultado al modelo. Ataca dos costes de tokens distintos: las definiciones de herramientas cargadas en el contexto y los resultados de herramientas devueltos a través del contexto. Mide cada uno antes de cambiar tu configuración: la búsqueda de herramientas difiere definiciones, mientras que la ejecución de código resulta más útil cuando varias llamadas pueden unirse o los resultados grandes pueden reducirse antes de que el modelo los vea. [El diseño original de Anthropic](https://www.anthropic.com/engineering/code-execution-with-mcp) explica el patrón; esta guía lo mide desde el lado de un agente de programación. ## ¿Qué cambia la ejecución de código con MCP? Cambia cómo un agente usa las herramientas, no el protocolo MCP en sí. En el patrón directo, el cliente muestra al modelo el nombre, la descripción y el esquema de cada herramienta, y devuelve el resultado al modelo después de cada llamada. La ejecución de código coloca una pequeña interfaz de código delante de esas llamadas: el modelo escribe un script, el runtime invoca las herramientas MCP y solo la salida seleccionada vuelve al modelo. Un servidor MCP puede quedarse exactamente como está mientras el agente cambia cómo descubre y llama a las herramientas del servidor. El agente sigue necesitando permiso para llegar al servidor, y el runtime de código necesita un lugar seguro donde ejecutarse. [La explicación de Anthropic](https://www.anthropic.com/engineering/code-execution-with-mcp) usa un sistema de archivos de wrappers de TypeScript; funciones más recientes de la API como la búsqueda de herramientas y la llamada programática de herramientas ofrecen otras formas de diferir herramientas o ejecutar llamadas de herramientas desde código. El límite operativo es: **el agente escribe código → el código llama a herramientas MCP → el sandbox conserva los datos intermedios → el modelo recibe solo el valor devuelto.** Si no hay sandbox, el paso de ejecución es una frontera de código no confiable, no una optimización de tokens que se active a la ligera. ## ¿A dónde van los tokens de MCP en una sesión de un agente de programación? Van a dos cubos: las definiciones de herramientas disponibles y los resultados devueltos al modelo. Un tercer asunto, la facturación repetida de un prefijo estable de definiciones, se ve afectado por el prompt caching pero no hace que ese prefijo desaparezca de la ventana de contexto. [La guía de contexto de Anthropic](https://platform.claude.com/docs/en/agents-and-tools/tool-use/manage-tool-context) separa estos controles por la misma razón. | Cubo de tokens | Qué contar | El primer control que probar | | ---------------------------------------- | ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------- | | Definiciones cargadas antes de una tarea | Nombres, descripciones y esquemas de argumentos de las herramientas que el agente puede ver | Poda las herramientas o usa una allowlist; usa carga diferida si la mayoría se necesitan rara vez | | Resultados devueltos durante una tarea | Salida de las herramientas, más cualquier dato intermedio que el modelo deba pasar a otra llamada | Filtra, pagina o resume en el origen; usa código para transformar resultados intermedios grandes | | Facturación repetida de entrada | Definiciones estables de herramientas y texto de prompt enviados de nuevo en peticiones posteriores a la API | Prompt caching; esto reduce el coste de entrada repetido, no el tamaño del contexto | No equipares el número de herramientas de un servidor con su huella de tokens. Diez esquemas verbosos pueden costar más que cincuenta pequeños. Y una sola llamada a `get_document` que devuelva un archivo completo puede costar muchas veces más que su definición. ## ¿Cómo puedo medir el coste de tokens de MCP en Claude Code y Codex? Usa la vista de contexto del cliente para una lectura a nivel de sesión y luego aísla un servidor con una comparación de sesión nueva. Para un preflight exacto de la API, cuenta la misma petición una vez sin herramientas y otra vez con el array `tools` del servidor. **Claude Code:** inicia una sesión limpia, ejecuta `/context` y registra la porción de MCP/definiciones de herramientas antes de hacer la tarea. Ejecuta la misma tarea con el servidor MCP relevante conectado y vuelve a comprobar `/context`. Con la búsqueda de herramientas actual de Claude Code, las herramientas MCP se difieren y se descubren bajo demanda por defecto en las configuraciones first-party compatibles, así que una definición puede aparecer después de que el agente la busque; toma una lectura tanto antes como después de la tarea. [La referencia de comandos](https://code.claude.com/docs/en/commands) documenta `/context`, y [la referencia de MCP](https://code.claude.com/docs/en/mcp) documenta el comportamiento por defecto de la búsqueda de herramientas y sus excepciones. Así se ve la primera lectura. En una prueba limpia el 4 de octubre de 2026 (Claude Code 2.1.289, un proyecto vacío, cinco servidores conectados), `claude -p "/context"` listó cada herramienta MCP con su tamaño de definición estimado antes de ejecutar ninguna tarea: | Servidor | Herramientas | Tokens de definición | Herramienta más grande | | ----------------------------------------- | -----------: | -------------------: | ------------------------------ | | 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 | Los 20.8k tokens de esas definiciones se situaban en la fila de diferidas, fuera del total inicial de 12.5k de la sesión. Dos ejecuciones difirieron entre un 1 y un 3% por servidor. El número de herramientas es un mal indicador del coste aquí: las 14 herramientas cortas del servidor de sistema de archivos de referencia cuestan menos que las 6 de Octofs, y una descripción larga puede pesar más que una docena de cortas. Para la configuración del cliente en sí, usa nuestra [guía de MCP para Claude Code y Codex](/blog/octofs-0-16-faster-filesystem-for-claude-code-and-codex); este procedimiento de medición asume que el servidor ya está conectado. **Codex:** en un hilo nuevo, registra `/status` y `/mcp`, ejecuta una tarea representativa y luego compara `/status` tras iniciar un hilo nuevo con el mismo servidor desactivado o su lista de herramientas reducida. Cambia un servidor cada vez. Codex documenta el uso de contexto de la sesión en `/status` y los servidores conectados en `/mcp`; el estado documentado es una cifra de toda la sesión y no atribuye tokens de esquema a cada servidor. Trata la diferencia entre ejecuciones controladas como una estimación, porque las instrucciones del proyecto, el historial de prompts y otras herramientas también ocupan contexto. [La referencia actual de Codex](https://developers.openai.com/codex/cli/slash-commands) lista esos comandos. Para una petición a la Messages API, usa el endpoint `POST /v1/messages/count_tokens` de Anthropic con tu array `tools` real y tu system prompt. Haz un conteo con las herramientas y un segundo conteo con la misma petición menos esas herramientas; resta los totales para estimar el overhead de definiciones. El endpoint devuelve el conteo de tokens de los mensajes, el system prompt y las herramientas juntos, y no crea una respuesta del modelo. Para medir también el coste de los resultados, repite el conteo incluyendo contenido `tool_result` representativo. Esto es un conteo de preflight; compáralo con el uso real de la respuesta al ajustar un flujo de trabajo real. [La referencia de conteo de tokens de Anthropic](https://platform.claude.com/docs/en/api/messages/count_tokens) define la petición y el campo `input_tokens` devuelto. Anota cuatro números: el contexto inicial antes de usar MCP, el contexto después de la tarea, las definiciones cargadas y los tokens de resultados devueltos. Repite con la misma tarea, un servidor cada vez. Eso te da una línea base que puedes comprobar después de cambiar herramientas. ## ¿Ha lanzado Anthropic la búsqueda de herramientas desde el artículo de MCP de 2025? Sí. A 4 de octubre de 2026, Anthropic documenta la carga diferida de herramientas en la Messages API y afirma que Claude Code activa la búsqueda de herramientas MCP por defecto en las configuraciones first-party compatibles. La versión de la API requiere la herramienta de búsqueda de herramientas y marca las definiciones elegibles con `defer_loading`; Claude Code gestiona esa vía para los servidores MCP conectados. [La guía de la API](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool) describe la forma de la petición, mientras que [la documentación actual de MCP de Claude Code](https://code.claude.com/docs/en/mcp) describe cuándo recurre a cargar las herramientas por adelantado. Es una actualización significativa respecto al artículo anterior, pero la búsqueda de herramientas no elimina todas las definiciones de herramientas de la petición: la API sigue recibiendo las definiciones diferidas para poder buscarlas y expandirlas cuando sea necesario. Mantiene la mayoría de las definiciones fuera del contexto inicial del modelo y cambia ese espacio por un paso extra de descubrimiento. La [guía de búsqueda de herramientas](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool) de Anthropic dice que la llamada simple de herramientas encaja mejor con menos de 10 herramientas, cuando usas todas las herramientas en cada petición, o cuando todas las definiciones juntas se mantienen por debajo de 100 tokens; su [resumen de contexto de herramientas](https://platform.claude.com/docs/en/agents-and-tools/tool-use/manage-tool-context) sitúa la búsqueda de herramientas en conjuntos de 20 o más. Entre esas marcas, mide antes de cambiar. OpenAI expone una vía `tool_search` similar en la Responses API; la guía actual dice que es compatible con gpt-5.4 y posteriores y usa `defer_loading: true` en la definición de la herramienta MCP. Eso es una función de la API. En el CLI de Codex, usa `/status` para inspeccionar el contexto general de la sesión y reduce las herramientas expuestas del servidor con su configuración de MCP. [La guía de búsqueda de herramientas de OpenAI](https://developers.openai.com/api/docs/guides/tools-tool-search) describe la función de la API; [la referencia de configuración de Codex](https://developers.openai.com/codex/config-reference) lista `enabled_tools`. ## ¿Cuál debería elegir: llamadas MCP directas, búsqueda de herramientas o ejecución de código? Elige según dónde encontró el coste tu medición y cuánto control necesitas sobre cada acción. Estos enfoques también pueden combinarse: la búsqueda puede mantener fuera del contexto los esquemas que se usan rara vez, y el código puede filtrar el resultado de un flujo de trabajo de varias llamadas. | Elige | Cuándo encaja | Contrapartida que planificar | | ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | | Llamadas directas | Un conjunto pequeño y estable de herramientas se usa en casi todas las tareas, o un humano debería revisar cada acción individual | Las definiciones siguen disponibles; las salidas grandes y los ida y vuelta llamada a llamada siguen usando contexto | | Búsqueda de herramientas / carga diferida | El catálogo es grande pero cada tarea usa solo unas pocas herramientas | Un paso de descubrimiento; la API sigue recibiendo definiciones para buscarlas | | Ejecución de código | Una tarea encadena varias herramientas, itera sobre registros o puede devolver un resumen compacto en lugar de datos intermedios en bruto | Requiere un entorno de ejecución con sandboxing, límites y monitorización; el código puede hacer varias llamadas de herramientas en una sola ejecución | Una regla rápida: si la sección de MCP de la línea base es grande, prueba primero la carga diferida. Si la línea base es pequeña pero los resultados de las tareas dominan, reduce o resume las salidas. Si un flujo de trabajo copia un resultado grande de una herramienta a otra, prototipa una vía de código y compara la tarea real — no solo el número de esquemas. Mantén las llamadas directas para las acciones que necesiten una decisión o aprobación humana aparte. Las cifras de origen son útiles como ejemplos, no como pronósticos. El artículo de ingeniería de Anthropic de 2025 reporta una caída de 150,000 a 2,000 tokens (98.7%) en su ejemplo de diseño. El artículo de Cloudflare de febrero de 2026 reporta unos 1,000 tokens para su Cloudflare API Code Mode de dos herramientas, frente a 1.17 millones para su conjunto de herramientas nativo equivalente; Cloudflare dice que esa comparación usó tiktoken. Son los resultados reportados por cada proveedor, y el servidor, los esquemas, el runtime y la forma de la tarea difieren. [El artículo de Anthropic](https://www.anthropic.com/engineering/code-execution-with-mcp) y [el artículo de Cloudflare](https://blog.cloudflare.com/code-mode-mcp/) no establecen un ahorro esperado para tu configuración. Un [benchmark de AIMultiple](https://aimultiple.com/code-execution-with-mcp) independiente, actualizado en agosto de 2026, reporta un 78.5% menos de tokens de entrada y un 7% más de latencia media en su prueba con Bright Data MCP / GPT-4.1. Los tokens de salida subieron en ese benchmark. Esto es un recordatorio de que hay que seguir por separado la entrada, la salida, la latencia y el éxito de la tarea; "menos tokens" por sí solo no es un resultado completo. ## ¿Cómo limito la salida de las herramientas sin ocultar datos útiles? Limita la salida en la capa que sabe qué necesita la tarea. Un servidor puede paginar o devolver extractos; un cliente MCP puede limitar el resultado de una herramienta individual; el modelo puede pedir al código que seleccione campos y agregue filas antes de imprimir un resultado. Claude Code avisa cuando una herramienta MCP devuelve más de 10,000 tokens y tiene un máximo por defecto de 25,000 tokens cuando la herramienta no declara su propio límite de tamaño de resultado. Codex expone `output_token_limit` por herramienta y un `tool_output_token_limit` general para las salidas almacenadas en el historial. Estos límites acotan lo que llega al contexto de la conversación; no hacen más pequeño un esquema de herramienta amplio. Consulta [los controles de salida de MCP de Claude Code](https://code.claude.com/docs/en/mcp) y [la referencia de configuración de Codex](https://developers.openai.com/codex/config-reference). Un ejemplo de TOML de Codex con un conjunto pequeño de herramientas expuestas y un presupuesto de salida por herramienta. Para confirmar que la allowlist surtió efecto, `codex mcp get --json` imprime los `enabled_tools` resueltos (comprobado en Codex CLI 0.160.0); también imprime las variables de entorno del servidor sin enmascarar, así que mantén esa salida fuera de tickets y registros de chat: ```toml [mcp_servers.example] enabled_tools = ["search", "read"] [mcp_servers.example.tools.read] output_token_limit = 2000 ``` El límite configurado es un presupuesto, no un techo rígido ni un objetivo: Codex aplica `output_token_limit` antes de un margen estándar de serialización del 20%, así que un resultado almacenado puede pasarse algo de él. Mantén la forma del resultado útil: pide solo los campos necesarios, pagina los registros y devuelve un conteo o unas pocas filas representativas cuando no se necesiten los datos completos. La [guía de MCP](https://developers.openai.com/api/docs/guides/tools-connectors-mcp) de OpenAI también admite el filtro `allowed_tools` de la Responses API. ## ¿Qué cambia la ejecución de código en cuanto a seguridad y aprobaciones? Mueve parte del trabajo de llamadas de herramientas visibles, una a una, a un programa que el modelo escribe y un runtime ejecuta. Eso puede mantener los datos intermedios privados fuera del contexto del modelo, pero también significa que el entorno de código forma parte de tu frontera de seguridad. La API de Anthropic ofrece ahora llamada programática de herramientas en un sandbox gestionado. Para una implementación propia, Anthropic advierte de que la ejecución del lado del cliente corre código no confiable fuera de un sandbox y puede ser un vector de inyección de código; el sandboxing autogestionado añade aislamiento pero requiere trabajo de infraestructura. El Code Mode basado en Workers de Cloudflare para MCP deniega el acceso general a la red por defecto y expone servicios específicos como bindings. Estos ejemplos muestran dos patrones: aísla la ejecución y concédele capacidades de alcance estrecho. Consulta [la guía de llamada programática de herramientas de Anthropic](https://platform.claude.com/docs/en/agents-and-tools/tool-use/programmatic-tool-calling) y [el diseño original de Code Mode de Cloudflare](https://blog.cloudflare.com/code-mode/). No enrutes una escritura irreversible a través de una herramienta de código amplia solo para ahorrar un turno del modelo. Mantén estrechos los permisos de escritura, conserva una frontera de confirmación donde un humano deba aprobar una acción y registra qué herramientas subyacentes invoca el código. Si no puedes auditar ni poner en un sandbox la vía de código, las llamadas directas con aprobaciones son más fáciles de razonar. ## ¿Qué pinta tiene esto para una superficie pequeña de herramientas MCP? Una superficie pequeña puede beneficiarse igualmente de dar forma a la salida, pero puede que no necesite ejecución de código. Nosotros construimos [octofs](/blog/introducing-octofs), un servidor MCP de sistema de archivos con seis herramientas, entre ellas `view` y `batch_edit`; `batch_edit` aplica hasta 50 ediciones que no se solapan a un archivo en una sola llamada y devuelve ids de línea nuevos, así que el agente no tiene que volver a leer el archivo. Octocode, nuestro servidor de búsqueda de código, expone cuatro herramientas por defecto (búsqueda semántica, búsqueda estructural, vistas de firmas y un grafo de código) y añade seis herramientas LSP solo cuando configuras un servidor de lenguaje. Octobrain, nuestro servidor de memoria, tiene cuatro. En la medición anterior sumaron unos 3.3k, 3.5k y 4.2k tokens de definición: más por herramienta que el servidor de sistema de archivos de referencia, y todas diferidas hasta que una tarea las necesite. Para la frontera de seguridad más amplia al dar a un agente acceso al sistema de archivos, consulta [nuestra guía de seguridad de sistemas de archivos](/blog/give-an-ai-agent-a-filesystem-safely). La medición decide el siguiente paso. Si dominan las definiciones, expón menos herramientas o difiérelas. Si dominan las salidas, fíltralas más cerca del servidor. Si los datos intermedios dominan a lo largo de una cadena, prototipa la ejecución de código detrás de un sandbox y compárala con la misma tarea bajo llamadas directas. — Don --- _Prueba la medición en una tarea recurrente y guarda los números de antes y después junto a la configuración de tu servidor. [Octofs](https://github.com/Muvon/octofs) y [Octocode](https://github.com/Muvon/octocode) son de código abierto; si sus superficies de herramientas cuestan más contexto del que deberían en tu configuración, abre un issue con tus números._