Code Mode MCP: por que seu agente deveria escrever código em vez de chamar tools

Code Mode MCP é o padrão em que o agente escreve código TypeScript que chama as tools MCP, em vez de fazer uma tool call por vez. O código roda num sandbox e só o resultado final volta pro modelo.

Parece detalhe. Não é.

Você conecta seis servidores MCP no agente. GitHub, banco, Slack, Drive, CRM, deploy.

Antes de ler a primeira pergunta do usuário, ele já queimou dezenas de milhares de tokens só com descrição de tool.

E quando começa a trabalhar, cada resultado de tool passa pelo modelo inteiro, só pra ser copiado pro argumento da próxima chamada.

O Code Mode MCP é a resposta a esse desperdício. A ideia, publicada pela Cloudflare e explorada em paralelo pela Anthropic, é simples: em vez de expor as tools MCP direto pro modelo, você converte essas tools numa API TypeScript e pede pro modelo escrever código que chama essa API. O código roda num sandbox. Só o resultado final volta pro contexto.

Neste post você vai entender por que isso funciona, como a Cloudflare implementou por dentro, como plugar o servidor MCP deles no seu agente e onde o padrão te morde.

TL;DR

• O que é: padrão em que o agente escreve TypeScript que chama MCP, em vez de fazer tool call por tool call.
• Stack/Modelos: Cloudflare Agents SDK (@cloudflare/codemode), Worker Loader (Dynamic Workers), isolates V8. Funciona com qualquer modelo que escreva código decente.
• Custo/Acesso: SDK open-source no repositório cloudflare/agents. O Worker Loader em produção começou em beta fechado. O servidor MCP da Cloudflare em https://mcp.cloudflare.com/mcp é aberto pra quem tem conta.
• Números: a Cloudflare mediu de 1,17 milhão para cerca de 1.000 tokens de input (99,9%) no MCP da própria API. A Anthropic, num exemplo, foi de 150 mil para 2 mil tokens (98,7%).
• Link útil: Code Mode: the better way to use MCP

Code Mode MCP: os dois impostos do tool calling

Tool calling tradicional cobra dois impostos. A Anthropic descreve os dois sem rodeio.

Primeiro imposto: definição de tool ocupa contexto. A maioria dos clientes MCP carrega todas as definições de uma vez. Agente com milhares de tools pode processar centenas de milhares de tokens antes de ler o pedido.

Segundo imposto: resultado intermediário passa pelo modelo. No exemplo da Anthropic, copiar a transcrição de uma reunião de 2 horas do Google Drive pro Salesforce faz o texto inteiro atravessar o modelo duas vezes. São uns 50 mil tokens a mais, só de "copia daqui, cola ali".

Agora a parte interessante. Por que código resolve isso?

O argumento da Cloudflare, no post de Kenton Varda e Sunil Pai, é de treino. LLM viu uma quantidade absurda de TypeScript real. Tool call, ele viu pouco, e quase tudo sintético, feito pra fine-tuning. A analogia deles: pedir tool call pro modelo é como pedir pro Shakespeare escrever uma peça em mandarim depois de um mês de aula.

E tem o encadeamento. Com tool call, cada saída volta pro modelo, que decide a próxima chamada e copia os dados. Com código, o modelo escreve o encadeamento uma vez, o sandbox executa e só o console.log() final volta.

Os números aparecem depois. A Cloudflare aplicou o padrão no MCP da própria API, que tem mais de 2.500 endpoints. Um servidor MCP convencional pra isso custaria 1,17 milhão de tokens de input, medidos com tiktoken. Com Code Mode, o servidor ocupa cerca de 1.000 tokens fixos, não importa quantos endpoints existam. A Anthropic reportou 150 mil caindo para 2 mil tokens no fluxo Drive → Salesforce.

Isso não é truque de prompt. É decisão de arquitetura: o que o modelo vê, o que fica no sandbox, onde mora a credencial. Esse tipo de decisão, com agente rodando de verdade e não slide, é o que a gente destrincha toda semana, ao vivo, no Clã Beer and Code.

Como o Code Mode funciona por dentro

São quatro peças. Cada uma resolve um problema específico.

1. Schema MCP vira API TypeScript. Quando você conecta um servidor em code mode, o Agents SDK busca o schema do servidor e gera interfaces e declarações de função TypeScript, com doc comments. É isso que o modelo lê.

2. O agente vê uma tool só. Em vez de 40 tools, ele vê uma: "execute este TypeScript". O código roda no sandbox e o console.log() volta quando o script termina.

3. Isolate descartável, não container. O código roda num isolate V8, criado sob demanda pela Worker Loader API. Isolate sobe em poucos milissegundos com alguns megabytes de memória. É barato o bastante pra criar um por snippet e jogar fora, sem pool e sem pré-aquecimento.

4. Binding no lugar de rede. Aqui está a sacada de segurança. O sandbox não tem internet: fetch() e connect() globais lançam erro. O acesso a cada servidor MCP acontece por um binding, um objeto vivo no env. E o binding já vem autorizado: a chamada passa pelo supervisor do agente, que segura o token e injeta na requisição. O código gerado pelo modelo nunca vê a API key.

Em diagrama:

TOOL CALLING TRADICIONAL
usuário → modelo → tool A → [resultado inteiro no contexto]
               → modelo → tool B → [resultado inteiro no contexto]
               → modelo → tool C → resposta
(N idas e voltas, todo dado intermediário passa pelo modelo)

CODE MODE
usuário → modelo → escreve script TS
               → isolate executa: A → filtra → B → C
               → console.log(resumo) → modelo → resposta
(1 ida e volta, dado intermediário fica no sandbox)

Mão na massa: Code Mode na prática

Três caminhos, do mais pronto ao mais manual.

Passo 1: plugar o MCP da Cloudflare (Code Mode já embutido)

O jeito mais rápido de sentir o padrão é usar o servidor MCP da Cloudflare, publicado em fevereiro de 2026. Ele expõe a API inteira com duas tools, search() e execute(). No Claude Code, Cursor ou qualquer cliente MCP:

{
  "mcpServers": {
    "cloudflare-api": {
      "url": "https://mcp.cloudflare.com/mcp"
    }
  }
}

Ao conectar, você é redirecionado pra Cloudflare pra autorizar e escolher as permissões. O token é reduzido ao que você aprovou. Pra CI/CD, use um API token como bearer no header Authorization.

O fluxo do agente fica assim: primeiro ele roda um search() contra o spec OpenAPI (que nunca entra no contexto), algo como:

async () => {
  const results = [];
  for (const [path, methods] of Object.entries(spec.paths)) {
    if (path.includes("/zones/") && path.includes("rulesets")) {
      for (const [method, op] of Object.entries(methods)) {
        results.push({ method: method.toUpperCase(), path, summary: op.summary });
      }
    }
  }
  return results;
}

Depois, um execute() que chama cloudflare.request(), trata paginação e encadeia operações numa execução só. No exemplo do post, configurar proteção DDoS e WAF de uma zona levou quatro tool calls no total.

Passo 2: Code Mode no seu próprio agente

Se você tem um agente com AI SDK e quer o mesmo efeito com as suas tools, o pacote é o @cloudflare/codemode. Pela referência da API, você cria um executor em cima do Worker Loader e embrulha as tools num único code tool:

import { DynamicWorkerExecutor } from "@cloudflare/codemode";
import { createCodeTool } from "@cloudflare/codemode/ai";

const executor = new DynamicWorkerExecutor({
  loader: env.LOADER,     // binding do Worker Loader
  timeout: 60000,
  globalOutbound: null,   // sem rede: só os bindings
});

const codeTool = createCodeTool({
  tools: myAiSdkTools,    // suas tools atuais do AI SDK
  executor,
});

E no wrangler.jsonc, o binding do loader:

{
  "worker_loaders": [{ "binding": "LOADER" }]
}

Já tem um servidor MCP pronto e quer só embrulhar? Tem o codeMcpServer() em @cloudflare/codemode/mcp, que recebe o McpServer original e devolve um novo com uma tool code.

Dica de ouro: o globalOutbound: null é o default, e é ele que garante que o código gerado não faz requisição pra lugar nenhum além dos bindings. Não troque por conveniência.

Passo 3: a variante da Anthropic, filesystem de tools

A Anthropic chegou no mesmo lugar por outro caminho. Em vez de carregar a API TypeScript inteira, cada servidor MCP vira uma árvore de arquivos: ./servers/google-drive/getDocument.ts, e assim por diante. O agente lista diretórios, lê só o que precisa e escreve o código:

const rows = await gdrive.getSheet({ sheetId: 'abc123' });
const pending = rows.filter(r => r.Status === 'pending');
console.log(pending.length, pending.slice(0, 5));

Planilha de 10 mil linhas, e o modelo vê cinco. Isso é progressive disclosure: tool carregada sob demanda, não tudo de cara.

Dois bônus que valem o post. O primeiro é privacidade: dado intermediário fica no sandbox, e o cliente MCP pode tokenizar PII (trocar e-mail por placeholder) antes de qualquer coisa chegar no modelo. O segundo é reuso: o agente pode salvar código que funcionou como função e colocar um SKILL.md do lado. Se você já usa skills no Claude Code, reconheceu o padrão.

Erro comum nos três caminhos: o modelo escreve código que não roda. Tipo errado, campo inexistente, promise sem await. O ciclo é o de sempre: o erro volta pro modelo e ele corrige. A diferença é que a doc comment gerada do schema é o que evita metade desses erros. Schema MCP mal descrito vira código mal escrito.

Limitações e pontos de atenção

Code Mode não é almoço grátis.

• Você precisa de sandbox de verdade. A própria Anthropic avisa: rodar código gerado exige isolamento, limite de recurso e monitoramento. É overhead operacional que tool call direto não tem. Na Cloudflare isso vem pronto. No seu servidor, é problema seu.
• Os números são dos vendors. 99,9% e 98,7% são medições da Cloudflare e da Anthropic, em cenários escolhidos por elas, com muitas tools e muito dado intermediário. O 98,7% da Anthropic é um fluxo de exemplo, não benchmark geral. O ganho depende do tamanho das definições, do volume das respostas e do comprimento da cadeia de chamadas. Agente com três tools e respostas curtas ganha bem menos. Meça no seu caso.
• O post original da Cloudflare não tem benchmark nenhum. As afirmações sobre qualidade são qualitativas. O ganho medido veio depois, e é de tokens, não de taxa de acerto.
• Prompt injection não some. O sandbox impede vazar a key, mas o código ainda pode fazer, com as permissões que você deu, coisa que você não queria. Downscope de token e aprovação humana em operação destrutiva continuam obrigatórios. O createCodeTool() inclusive exclui tools marcadas com needsApproval: aprovação durável exige outro fluxo.
• Debug fica diferente. Em vez de ler uma sequência de tool calls, você lê um script. Log do que foi executado no sandbox é obrigatório.

Se você vai botar MCP em produção, o checklist de OAuth, schema e gateway continua valendo por baixo disso tudo.

FAQ rápido

Code Mode substitui o MCP? Não. O MCP continua sendo o contrato: schema, auth, descoberta. O Code Mode muda só a interface entre o modelo e esse contrato. Em vez de o modelo chamar tool, ele escreve código que chama tool. O servidor MCP não muda nada.

Funciona fora da Cloudflare? O padrão, sim. A Anthropic descreve a mesma ideia sem amarrar a provedor, e qualquer sandbox seguro serve (container, Firecracker, Deno com permissões fechadas). O SDK @cloudflare/codemode é que depende do Worker Loader. Localmente, ele roda com Wrangler e workerd.

Qual modelo funciona melhor? Qualquer um que escreva TypeScript bem. A tese inteira é que modelo é melhor em código do que em tool call. Modelos menores ganham proporcionalmente mais, porque erram mais no formato de tool call.

E no meu app Laravel? O agente pode viver em PHP e delegar só a execução pra um Worker com Code Mode, ou você monta o próprio sandbox. O que importa é a ideia: o modelo não precisa ver o dado intermediário. Isso vale em qualquer stack.

Conclusão

Code Mode é uma mudança pequena de interface com efeito grande. O modelo para de ser roteador de JSON e passa a fazer o que ele mais viu no treino: escrever código. O MCP continua sendo o contrato. O sandbox vira o lugar onde o dado pesado mora.

O próximo passo já está desenhado: a Cloudflare quer Code Mode de primeira classe pra qualquer servidor MCP via MCP Server Portals, com footprint de tokens fixo não importa quantos serviços estejam atrás do gateway.

Se você ainda está montando a base, comece por o que é MCP e depois crie um servidor MCP do zero. Aí volte aqui e embrulhe ele em Code Mode.