Code Mode MCP: el modelo escribe código en lugar de llamar tools

Code Mode MCP es un patrón en el que el modelo no llama a las tools de un servidor MCP una por una. Escribe un fragmento de código que las llama, ese código se ejecuta en un sandbox y al modelo solo vuelve el valor final. Cloudflare le puso el nombre de Code Mode en septiembre de 2025. Anthropic describió la misma idea en noviembre como «code execution with MCP» y la ofrece en su API como Programmatic Tool Calling.

Este artículo sustituye a la versión que publicamos en noviembre de 2025. Aquella mezclaba los dos enfoques, daba cifras que no hemos podido encontrar en ninguna fuente y mostraba configuraciones que no existen. Esta versión sale de las páginas oficiales de Cloudflare y Anthropic, que consultamos el 8 de octubre de 2026. El código es literal de la documentación de Cloudflare, tal como lo recoge la referencia del curso.

¿Qué problema resuelve Code Mode?

Cuando un agente usa tools de la forma habitual, paga en dos sitios. El primero son las definiciones. El host mete en el contexto del modelo la descripción y el esquema de cada tool, y con muchos servidores eso ocupa mucho. Anthropic lo resume así: «Tool descriptions occupy more context window space, increasing response time and costs».

El segundo son los resultados intermedios. Si el agente lee un documento con una tool y lo pasa a otra, el documento entero atraviesa el modelo dos veces. Cloudflare lo describe como una salida que «must feed into the LLM’s neural network, just to be copied over to the inputs of the next call». Anthropic pone un ejemplo con la transcripción de una reunión: «For a 2-hour sales meeting, that could mean processing an additional 50,000 tokens.»

Con Code Mode, el modelo escribe un programa corto que hace las dos llamadas y devuelve solo lo que importa. El documento se queda dentro del sandbox. Además, varias llamadas encadenadas caben en una sola petición al modelo. Anthropic lo cuenta así: «When Claude orchestrates 20+ tool calls in a single code block, you eliminate 19+ inference passes». Es un razonamiento, no una medición.

¿Es lo mismo Code Mode que la ejecución de código de Anthropic?

La idea es la misma y las dos empresas lo reconocen. Anthropic escribe que «Cloudflare published similar findings, referring to code execution with MCP as “Code Mode.”». Cloudflare, por su parte, dice que el patrón está implementado en el SDK de Claude como Programmatic Tool Calling. Lo que cambia es dónde corre el código y quién lo monta.

En Cloudflare, el modelo escribe TypeScript contra una API generada a partir de los esquemas de las tools MCP, «complete with doc comments based on the schema». Ese código corre en un Dynamic Worker, un isolate de V8 en la infraestructura de Cloudflare. La librería actual es @cloudflare/codemode y puede envolver un servidor MCP para que cualquier cliente lo use: «A Code Mode MCP server lets any Model Context Protocol (MCP) client use model-written code without providing its own sandbox.»

En Anthropic hay dos cosas distintas. La entrada «Code execution with MCP» (4 de noviembre de 2025) describe un patrón, no un producto. Propone presentar los servidores MCP como ficheros de código (servers/google-drive/getDocument.ts, servers/salesforce/updateRecord.ts) para que el agente explore el árbol y lea solo las definiciones que necesita. No publica un SDK ni un sandbox para hacerlo.

La segunda es Programmatic Tool Calling, una función de la API de Claude que Anthropic presentó en beta el 24 de noviembre de 2025. Claude escribe el código de orquestación en Python y se ejecuta en el entorno de Code Execution de Anthropic, no en un sandbox que montes tú. Se activa con la tool code_execution_20250825, el campo allowed_callers y la cabecera beta advanced-tool-use-2025-11-20. No hemos comprobado su estado actual en la plataforma de Claude.

Por eso no conviene decir que Programmatic Tool Calling «es» Code Mode. Comparten el patrón, pero uno vive en tu servidor MCP y el otro en la API de un proveedor de modelos.

¿Cuánto ahorra de verdad?

Aquí está la parte que más se repite y la que peor se cita. Cada cifra publicada mide una cosa distinta en un caso distinto, así que no se pueden comparar entre sí.

Cifra	Quién	Qué mide
99,9 %	Cloudflare	Definiciones de tools de su propia API (más de 2.500 endpoints): unos 1.000 tokens frente a 1,17 millones, contados con tiktoken
81 %	Cloudflare	Convertir un servidor MCP en API TypeScript. El enlace de la cifra lleva a un vídeo, sin método escrito
«up to 80%»	Cloudflare	Tokens y coste de inferencia con Dynamic Workers, sin método
98,7 %	Anthropic	150.000 → 2.000 tokens en un ejemplo calculado (Google Drive → Salesforce), no medido
37 %	Anthropic	43.588 → 27.297 tokens de media con Programmatic Tool Calling en tareas de investigación complejas

El 99,9 % es la única cifra de Code Mode con método, y mide solo el peso de las definiciones. No mide una tarea completa ni la precisión del agente. Su servidor expone dos tools, search() y execute(): «Two tools, roughly 1,000 tokens, and coverage of every endpoint in the API.»

Importante: la propia Cloudflare no se pone de acuerdo sobre lo que costaría esa API sin Code Mode. El resumen de la entrada del 20 de febrero de 2026 dice «over 2 million tokens». El cuerpo de la misma entrada dice 1,17 millones. La documentación dice «over 1 million» y su tabla da unos 1.170.000. Nosotros usamos 1,17 millones porque es la que viene con método.

La entrada original de Code Mode, la de septiembre de 2025, no da ningún porcentaje. Solo dice «The results are striking».

Anthropic publica más cifras en su entrada de noviembre, pero son de otras funciones y conviene no mezclarlas. La reducción de 72.000 a 8.700 tokens (un 85 %) es de Tool Search, que carga las definiciones bajo demanda. La mejora de precisión del 72 % al 90 % en parámetros complejos es de Tool Use Examples. Para Programmatic Tool Calling, la precisión pasó del 25,6 % al 28,5 % en recuperación de conocimiento interno y del 46,5 % al 51,2 % en GIA.

Tampoco hay cifras de latencia o coste en porcentaje para Code Mode. Si lees que es un 70 % más rápido o un 97 % más barato, no hemos encontrado esos datos en ninguna fuente oficial.

¿Cómo se monta un servidor MCP con Code Mode en Cloudflare?

Cloudflare documenta dos patrones. El primero es una tool única, code, que expone métodos tipados por cada tool del servidor original (codemode.*). Encaja cuando ya tienes un servidor MCP con un conjunto manejable de tools. El segundo es buscar y ejecutar (search y execute) sobre un documento OpenAPI, pensado para APIs grandes cuyo esquema no debe entrar en el contexto.

La configuración de Wrangler declara el binding Worker Loader y el flag nodejs_compat:

{
  "$schema": "./node_modules/wrangler/config-schema.json",
  "name": "codemode-mcp-server",
  "main": "src/server.ts",
  // Set this to today's date
  "compatibility_date": "2026-10-02",
  "compatibility_flags": [
    "nodejs_compat"
  ],
  "worker_loaders": [
    {
      "binding": "LOADER"
    }
  ]
}

Fuente: guía «Build a Code Mode MCP server» de Cloudflare, literal en la referencia del curso (plataformas-y-ecosistema.md, §A4).

El servidor envuelve otro servidor MCP con codeMcpServer() y le pasa un ejecutor que usa ese binding:

import { DynamicWorkerExecutor } from "@cloudflare/codemode";
import { codeMcpServer } from "@cloudflare/codemode/mcp";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { createLegacyMcpHandler } from "agents/mcp";
import { z } from "zod";

export default {
	async fetch(request, env, ctx): Promise<Response> {
		const upstream = createOrderServer();
		const executor = new DynamicWorkerExecutor({ loader: env.LOADER });
		const server = await codeMcpServer({
			server: upstream,
			executor,
		});

		return createLegacyMcpHandler(server, { route: "/mcp" })(
			request,
			env,
			ctx,
		);
	},
} satisfies ExportedHandler<Env>;

Fuente: la misma guía (extracto), literal en la referencia del curso, §A4.

Lo que escribe el modelo dentro de la tool code es una función que llama a las tools originales y devuelve solo lo necesario:

async () => {
	const order = await codemode.get_order({ orderId: "order-123" });
	return { id: order.id, status: order.status };
};

Fuente: la misma guía, literal en la referencia del curso, §A4.

Fíjate en que el pedido completo no vuelve al modelo, solo el identificador y el estado. Ahí está el ahorro de los resultados intermedios.

El sandbox no da acceso a la red por defecto. Según Cloudflare, «DynamicWorkerExecutor configures globalOutbound: null unless you provide another value». El código generado tampoco ve las credenciales: «The generated code never receives the connector credentials or client objects.» Solo llega a sistemas externos a través de las tools originales. La ejecución tiene un tiempo máximo configurable, de 30 segundos por defecto.

Hay un límite que conviene conocer. El publicador corta la respuesta MCP final en unos 6.000 tokens estimados y añade el marcador --- TRUNCATED ---. Cloudflare aclara que eso «does not reduce work already performed by upstream tools».

Importante: el patrón de tool única no siempre ahorra en definiciones. Cloudflare dice que funciona bien «when the generated type declarations fit comfortably in the code tool description». En la lección de rendimiento y coste de contexto lo medimos con tres tools de Nortia, y la descripción de code pesaba más que las tres definiciones directas. La ganancia llegó por los resultados intermedios. Con pocas tools, Cloudflare recomienda lo contrario: «Use direct tool calls for simple tasks with a small, fixed tool set.»

¿Encaja con MCP 2026-07-28?

La especificación no define la ejecución de código ni Code Mode. Es un patrón construido encima de tools/list y tools/call: un servidor expone una tool genérica y, dentro del sandbox, el código llama a las tools reales.

El detalle importante es la versión del protocolo. Según la guía de Cloudflare, «codeMcpServer() currently returns an SDK v1 server. Serve it through the explicit legacy createLegacyMcpHandler API.» Es decir, un servidor montado con estos helpers va por el camino heredado con handshake, no por el protocolo sin estado de 2026-07-28. En cambio, el servidor de la API de Cloudflare sí declara soportar la versión nueva: «The servers support the new MCP 2026-07-28 Specification».

Hay una consecuencia menos visible. En la especificación de tools, las anotaciones como readOnlyHint o destructiveHint son pistas, no garantías, y el cliente debe tratarlas como no fiables salvo que vengan de servidores de confianza. Detrás de una única tool code, el host solo ve una llamada a code. Las anotaciones de las tools reales no llegan a su diálogo de aprobación. Si no conoces bien estos términos, el glosario de MCP los explica.

¿Qué riesgos reconocen Cloudflare y Anthropic?

Anthropic avisa: «Running agent-generated code requires a secure execution environment with appropriate sandboxing, resource limits, and monitoring. These infrastructure requirements add operational overhead and security considerations that direct tool calls avoid.» Es decir, la llamada directa a una tool no necesita sandbox. Es el código generado el que añade el riesgo.

Cloudflare reconoce que su sandbox tiene límites: «security bugs in V8 are more common than security bugs in typical hypervisors. When using isolates to sandbox possibly-malicious code, it’s important to have additional layers of defense-in-depth.» Por eso no hablaríamos de «aislamiento completo». Cloudflare enumera sus capas extra, como parches de V8 en horas y un segundo sandbox propio.

El tercer aviso es de autorización: «Code execution does not replace authorization. Enforce permissions and any required approval inside upstream tool handlers or the host request callback before applying side effects.» Y en la guía del servidor: «codeMcpServer() does not provide durable approval for each upstream tool call.» Si una tool original borra o paga algo, la comprobación tiene que vivir en su handler.

También hay límites de recursos. Un Dynamic Worker admite límites propios de tiempo de CPU y de número de subpeticiones, por ejemplo limits: { cpuMs: 10, subRequests: 5 }. No hay un límite de memoria configurable documentado.

Cubrimos el modelo de amenazas general de los servidores en seguridad en servidores MCP, y la lección de seguridad avanzada entra en defensas en profundidad.

¿En qué estado está y cuánto cuesta?

Code Mode es experimental. La documentación lo dice sin rodeos: «Code Mode is experimental and may introduce breaking changes. Use caution in production.»

El sandbox se llama hoy Dynamic Workers. El binding se llama Worker Loader (worker_loaders, normalmente env.LOADER). Está en beta abierta desde el 24 de marzo de 2026 y solo para planes de pago: «Dynamic Workers are now in open beta for all paid Workers users.» No hemos encontrado ninguna fuente oficial que diga que haya salido de la beta.

El precio tiene una contradicción. La entrada de marzo decía que el cargo de 0,002 USD se eximía durante la beta. La página de precios dice: «Starting May 26, 2026, Dynamic Workers created daily are billed as part of Dynamic Workers pricing.» Como no consta que haya salido de la beta, hoy se factura estando en beta abierta. Cada mes incluye 1.000 Dynamic Workers únicos, y a partir de ahí cuesta 0,002 USD por Dynamic Worker y día. A diferencia de un Worker normal, también se factura el tiempo de CPU de arranque.

Los portales MCP de Cloudflare también ofrecen Code Mode: con la política por defecto se activa añadiendo ?codemode=search_and_execute a la URL del portal. Sobre pasarelas MCP en general, mira nuestro análisis del MCP Gateway de Uber.

¿Cuándo te conviene y cuándo no?

Nuestra recomendación, con lo que dicen las fuentes:

• Prueba Code Mode cuando tu agente encadena muchas llamadas y los resultados intermedios son grandes, porque ahí está el ahorro que no depende del número de tools.
• Considera el patrón buscar y ejecutar cuando el catálogo es tan grande que sus definiciones no caben bien en el contexto, como la API de Cloudflare.
• Quédate con las llamadas directas cuando tienes pocas tools y tareas simples, que es lo que recomienda la propia Cloudflare.
• No lo pongas delante de tools con efectos sin autorización y aprobación en cada handler, porque el host no verá sus anotaciones.

Antes de llegar al código, revisa el diseño. A veces el contexto se llena porque las tools están mal repartidas, y eso lo tratamos en tools, resources y skills en MCP.

¿Qué cambia respecto a la versión anterior de este artículo?

Si leíste la versión de noviembre de 2025, esto es lo que no debes usar:

• El ejemplo con import { getDocument } from "./servers/google-drive" es de Anthropic, no de Cloudflare. Cloudflare usa un objeto codemode.*.
• env.CODE_MODE.createWorker y la sección [code_mode] en wrangler.toml no existen. La configuración real es el binding worker_loaders que has visto arriba.
• Programmatic Tool Calling no se activa con tool_choice: "programmatic" ni ejecuta Python en tu equipo con RestrictedPython. Corre en el entorno de Code Execution de Anthropic.
• El campo de ejemplos se llama input_examples, no examples.
• El 95 % de Anthropic es el contexto que se conserva con Tool Search, no el que se gasta.
• La mejora del 72 % al 90 % es de Tool Use Examples, no de Programmatic Tool Calling.
• El «caso de estudio real» del 99,9 % y los «benchmarks oficiales» de 95-98 %, 70 % y 97 % no aparecen en ninguna fuente oficial.
• El enlace a la documentación ya no funciona. La actual está en developers.cloudflare.com/agents/tools/codemode.

¿Por dónde sigo?

La lección de rendimiento y coste de contexto compara con datos de Nortia ajustar definiciones, cargarlas bajo demanda y ejecutar código con Code Mode. El despliegue en Workers está en la lección de despliegue con Cloudflare.