---
title: "Code Mode: agentes de IA funcionam melhor escrevendo código do que chamando ferramentas"
description: "A Cloudflare mostrou que, em vez de chamar ferramentas MCP uma a uma, o agente rende mais quando escreve um programa que usa essas ferramentas. Explicamos a ideia e o que muda para quem constrói agentes."
date: "2026-11-13"
lang: "pt-BR"
canonical: "https://www.meyje.com.br/pt/blog/code-mode-agentes-escrevem-codigo"
---
Em setembro de 2025, Kenton Varda e Sunil Pai publicaram no blog da Cloudflare um texto com uma provocação: estamos usando o MCP do jeito errado. A proposta, chamada de **Code Mode**, é simples de enunciar. Em vez de pedir para o modelo chamar ferramentas uma por uma, você entrega a ele uma API em TypeScript e pede que ele **escreva um programa** que use essa API. O programa roda num ambiente isolado, e só o resultado final volta para a conversa.

Neste post explicamos a ideia com as nossas palavras, mostramos por que ela faz sentido na prática e o que muda para quem, como a gente, constrói agentes de IA para clientes. O artigo original está nas fontes, no fim da página, e vale a leitura completa.

## O que é o MCP, em uma frase

O [Model Context Protocol](https://modelcontextprotocol.io/) é um padrão aberto para conectar modelos de linguagem a sistemas externos: um banco de dados, um CRM, uma agenda, um repositório de código. Cada sistema expõe um **servidor MCP** com uma lista de ferramentas, e cada ferramenta tem nome, descrição e o formato dos parâmetros.

O ganho do MCP é a uniformidade. Uma vez que o agente sabe falar MCP, ele consegue usar qualquer servidor que siga o protocolo, com o mesmo jeito de descobrir ferramentas, autenticar e ler a documentação.

### Como uma chamada de ferramenta funciona hoje

No modo tradicional, o modelo recebe a lista de ferramentas no contexto e, quando decide usar uma, gera um trecho especial com o nome da ferramenta e os argumentos. O aplicativo intercepta esse trecho, executa a chamada e devolve o resultado para o modelo, que lê tudo e decide o próximo passo.

Se a tarefa exige cinco chamadas encadeadas, são cinco idas e voltas. E **cada resultado intermediário passa pelo contexto do modelo**, mesmo quando ele só precisa de um número que está no meio de uma resposta enorme.

## Onde esse modelo trava

O argumento central da Cloudflare é sobre treinamento. Os tokens especiais de chamada de ferramenta quase não aparecem em textos reais. Os modelos aprendem a usá-los com **dados de treino sintéticos**, criados especificamente para isso. Já código TypeScript que chama APIs aparece aos milhões em repositórios públicos.

Na prática, isso gera três problemas que qualquer equipe que já colocou um agente em produção reconhece:

- **Ferramentas demais confundem.** Com dezenas de ferramentas no contexto, o modelo erra a escolha ou inventa parâmetros.
- **Encadear é caro.** Cada passo intermediário gasta tokens de entrada e de saída e adiciona latência.
- **O contexto enche de lixo.** Uma consulta que devolve 2.000 linhas ocupa a janela de contexto inteira, mesmo quando o agente só precisava somar uma coluna.

![Comparação entre o fluxo tradicional, em que cada resultado volta ao modelo, e o Code Mode, em que o programa encadeia as chamadas dentro da caixa isolada](/blog/code-mode-agentes-escrevem-codigo/fluxo.pt.svg "Tradicional: cada resultado passa pelo modelo. Code Mode: o programa encadeia as chamadas e só o resultado final volta.")

## Como o Code Mode resolve

A ideia tem duas partes.

### 1. Transformar as ferramentas MCP em uma API TypeScript

O esquema de cada ferramenta vira uma função tipada, com a descrição da ferramenta como comentário de documentação. O modelo passa a enxergar algo parecido com isto:

```ts
/** Busca clientes pelo nome ou e-mail. Retorna no máximo 50 resultados. */
declare function buscarClientes(input: { termo: string }): Promise<Cliente[]>;

/** Lista as faturas de um cliente em um período. */
declare function listarFaturas(input: {
  clienteId: string;
  de: string; // AAAA-MM-DD
  ate: string;
}): Promise<Fatura[]>;
```

Em vez de dezenas de ferramentas, o modelo recebe **uma única ferramenta**: "execute este código".

### 2. Rodar o código do modelo numa caixa isolada

O modelo escreve um programa curto que faz o trabalho todo de uma vez:

```ts
const clientes = await buscarClientes({ termo: "Fazenda Boa Vista" });
const faturas = await listarFaturas({
  clienteId: clientes[0].id,
  de: "2026-10-01",
  ate: "2026-10-31",
});

const emAberto = faturas.filter((f) => f.status === "aberta");
return {
  quantidade: emAberto.length,
  total: emAberto.reduce((soma, f) => soma + f.valor, 0),
};
```

As duas consultas, o filtro e a soma acontecem dentro da caixa. O modelo recebe de volta só `{ quantidade, total }`. As centenas de faturas nunca passam pelo contexto.

## Por que a caixa isolada é o ponto central

Executar código escrito por um modelo exige cuidado. A resposta da Cloudflare foi usar os isolates do V8, a mesma base dos Cloudflare Workers. Segundo o artigo, um isolate inicia em poucos milissegundos e usa poucos megabytes de memória. Por isso dá para criar um isolate novo para cada trecho de código e descartá-lo logo depois, sem reaproveitar ambiente.

Para isso eles lançaram uma API, chamada no artigo de Worker Loader, que carrega código sob demanda dentro de um isolate. Dois detalhes de segurança se destacam:

- **Sem internet por padrão.** O código do agente pode ter o acesso externo bloqueado por completo. Ele só alcança o que você conectou de forma explícita.
- **Sem chave de API exposta.** O acesso aos servidores MCP chega ao código como uma conexão já autorizada (o que a Cloudflare chama de *binding*). O programa usa a conexão, mas nunca vê o token. Se o modelo for enganado por um texto malicioso, não há segredo para vazar.

## A ideia se espalhou

Em novembro de 2025, a Anthropic publicou um texto de engenharia na mesma linha, citando o trabalho da Cloudflare. No exemplo deles, apresentar as ferramentas como arquivos de código, que o agente lê só quando precisa, reduziu o consumo de **150.000 para 2.000 tokens**, uma economia de 98,7%. Os números variam conforme o caso, mas a direção é a mesma: deixar o modelo escrever código costuma ser mais barato e mais confiável do que fazê-lo chamar ferramentas uma a uma.

## O que isso muda para quem constrói agentes

Na MEYJE construímos agentes que conversam com sistemas reais, como o assistente financeiro do RuralZap e o agente de orientação de carreira do IESGO. Três lições do Code Mode já entram no nosso jeito de projetar:

1. **Ferramentas bem tipadas valem ouro.** Nome claro, descrição curta e parâmetros com tipos fortes ajudam o modelo, seja chamando a ferramenta, seja escrevendo código.
2. **Agregue perto dos dados.** Se a resposta final é um total, a soma deve acontecer antes de o dado voltar ao modelo. Menos contexto significa menos custo e menos erro.
3. **Isolamento não é opcional.** Código gerado por IA roda sem rede, sem segredos e com tempo limite. As credenciais ficam do lado de fora.

O Code Mode não aposenta o MCP. Ele aproveita o melhor do protocolo, que é a padronização, e muda só a forma como o modelo o consome. Para quem constrói agentes, vale testar: comece por uma tarefa que hoje exige várias chamadas encadeadas e compare tokens, tempo e taxa de acerto nos dois modos.

Se você quer colocar um agente de IA para trabalhar com os sistemas da sua empresa, [fale com a gente](/pt#contact).
