Execução de Código com MCP: Uma Nova Abordagem para a Eficiência de Agentes de IA

Anthropic introduziu um método em que os agentes de IA interagem com Model Context Protocol (MCP) servidores escrevendo código executável em vez de fazer chamadas diretas a ferramentas. O agente trata as ferramentas como arquivos em um computador, encontra o que precisa e as utiliza diretamente com código, de modo que os dados intermediários não precisam passar pela memória do modelo. Testamos essa abordagem para ver se ela reduz o custo de tokens mantendo a mesma taxa de sucesso.

Execução de código com MCP vs MCP regular

Comparamos duas abordagens para construir agentes de IA que interagem com ferramentas externas via MCP:

• MCP regular: Abordagem tradicional em que todas as definições de ferramentas são carregadas na janela de contexto do modelo
• Execução de código MCP: Abordagem inovadora em que o modelo escreve código que chama ferramentas, mantendo os dados intermediários fora do contexto

Ferramentas utilizadas

Este benchmark foi conduzido usando o Bright Data MCP Server com Pro Mode, pois teve a maior precisão em nosso benchmark de navegador MCP.

Principais descobertas

Economia de tokens de entrada: a execução de código usa 78,5% menos tokens de entrada (165K vs 771K):

• A abordagem regular carrega ~15.400 tokens de definições de ferramentas por chamada
• A execução de código só precisa de ~3.300 tokens por chamada

Mais tokens de saída: a abordagem de execução de código usa 2.2× mais tokens de saída porque o modelo escreve código + explicações

Economia líquida de tokens: 77,4% de redução total de tokens (175K vs 775K)

Implicação de custo:

• Os tokens de entrada normalmente são mais baratos que os tokens de saída
• Mas a economia de 78% nos tokens de entrada supera em muito o aumento de 2× na saída
• Redução de custo estimada de ~70% com execução de código

Ambas alcançaram 100% de taxa de sucesso nessas consultas com GPT-4.1.

A abordagem de execução de código é inspirada na publicação da Anthropic sobre o uso de execução de código com MCP para reduzir o uso da janela de contexto mantendo a capacidade do agente.¹

Metodologia da comparação de execução de código com MCP

Tarefas

Executamos cada tarefa 50 vezes para cada abordagem:

• Acesse https://aimultiple.com/open-source-embedding-models e me diga os 5 melhores desempenhos perfeitos (ou seja, os modelos com 100% de precisão no top-5)
• Acesse https://aimultiple.com/open-source-embedding-models e me diga qual modelo tem a maior latência.

Configuração da comparação

Para ambas as abordagens, usamos o Bright Data MCP Server com Pro Mode e o GPT-4.1 como LLM devido à sua grande janela de contexto.

Configuração do ambiente: Limpamos todos os dados em cache e garantimos uma nova conexão com o servidor MCP a cada execução. Cada consulta é executada como um subprocesso separado.

Comparação de arquitetura

Arquitetura de MCP regular

Na abordagem de MCP regular, o agente segue um fluxo direto: a consulta do usuário entra em um LangGraph ReAct Agent, que tem acesso a todas as 63 definições de ferramentas em sua janela de contexto. O agente seleciona e chama ferramentas por meio da MCP Client Session, e os resultados das ferramentas voltam pela janela de contexto para informar a próxima ação do agente.

Arquitetura de execução de código MCP

A abordagem de execução de código adiciona uma camada intermediária: a consulta do usuário vai para um Code Execution Agent com um contexto compacto (apenas nomes de ferramentas, não esquemas completos). O agente escreve código Python que chama ferramentas. Esse código é executado em um ambiente Code Executor em sandbox, que se comunica com a MCP Client Session. Somente os resultados finais ou resumos retornam ao contexto do agente, não os dados intermediários brutos.

A implementação de execução de código usa divulgação progressiva. Apenas nomes de ferramentas e descrições truncadas (60 caracteres) são incluídos no prompt do sistema. Quando o modelo precisa usar uma ferramenta, ele escreve código Python que chama uma função assíncrona call_tool() fornecida no ambiente de execução.

Limitações da nossa abordagem

1. Diversidade de consultas: Apenas 2 tipos de consulta foram testados; os resultados podem variar para outros tipos de tarefa.
2. Modelo único: Testado apenas com GPT-4.1; outros modelos podem apresentar padrões diferentes
3. Qualidade do código: O sucesso da execução de código depende da capacidade de geração de código do modelo, o que pode causar diminuições nas taxas de sucesso em tarefas mais complicadas.

Por que o MCP tradicional desperdiça recursos

Problema 1: As definições de ferramentas consomem contexto excessivo

Cada ferramenta precisa de instruções na memória do modelo. Um exemplo básico:

gdrive.getDocument
Gets a file from Google Drive
Needs: document ID
Returns: the file content

Exemplo: Um agente conectado a 50 servidores com 20 ferramentas cada significa 1.000 definições de ferramentas. A aproximadamente 150 tokens por definição, são 150.000 tokens consumidos antes de o agente ler sua primeira solicitação.

Problema 2: Os dados são processados várias vezes

Tarefa: “Obtenha minhas notas de reunião no Google Drive e adicione-as ao Salesforce.”

O que acontece:

1. O agente obtém o documento (50.000 tokens)
2. O modelo o lê
3. O agente o envia para o Salesforce (outros 50.000 tokens)

O modelo lida com 100.000+ tokens para mover dados de um lugar para outro.
As implementações tradicionais de MCP exigem que o modelo selecione ferramentas a partir de definições JSONSchema carregadas na janela de contexto, o que degrada a precisão à medida que o número de ferramentas aumenta.¹ Pesquisas confirmaram que as taxas de sucesso das tarefas caem acentuadamente à medida que o número de ferramentas disponíveis cresce devido à inundação de contexto causada pelas definições de esquema.² Expor as ferramentas MCP como funções chamáveis e permitir que o modelo escreva código Python que invoca ferramentas diretamente aproveita a capacidade existente de geração de código do modelo, em vez de forçar a seleção a partir de esquemas predefinidos.

Quando usar execução de código com MCP?

A execução de código com MCP resolve duas ineficiências fundamentais nas implementações tradicionais de MCP:

1. As definições de ferramentas não lotam mais a janela de contexto
2. Os dados intermediários param de fluir pelo modelo desnecessariamente

A abordagem funciona melhor quando:

• Você tem muitas ferramentas MCP conectadas
• Seus fluxos de trabalho envolvem processamento de dados em várias etapas
• Documentos ou datasets grandes se movem entre ferramentas
• Os limites da janela de contexto afetam seus agentes

Os requisitos de infraestrutura significam que isso não é automaticamente melhor para todos os casos de uso. Implantações em pequena escala com poucas ferramentas podem não justificar a complexidade operacional.

Para organizações que já executam agentes com catálogos extensos de ferramentas MCP, o potencial de 98%+ de redução de tokens e as economias de custo correspondentes fazem essa abordagem valer a pena investigar.

Não perca os nossos benchmarks e insights baseados em dados. O botão abre o Google; selecionar a AIMultiple confirma que deseja ver a AIMultiple com mais frequência nos resultados de pesquisa do Google.

Adicionar como fonte preferencial

Frameworks e protocolos alternativos

Equipes que desejam uma camada de execução de código separada de seu framework de agente podem usar serviços autônomos de sandbox, como CoreWeave Sandboxes, que oferece SDKs de Python e TypeScript e permite restringir o acesso de saída de cada sandbox por endereço IP, porta e nome de host HTTPS.³ Em abril de 2026, a OpenAI atualizou seu Agents SDK para adicionar recursos nativos de execução em sandbox, fornecendo espaços de trabalho isolados com acesso restrito a arquivos e código.⁴

Cite este benchmark

Escolha o formato adequado ao local onde você vai publicar. Colar a versão com link no seu CMS preserva o backlink.

@misc{alper2026,
  author = {Alper, Şevval},
  title  = {{Execução de Código com MCP: Uma Nova Abordagem para a Eficiência de Agentes de IA}},
  year   = {2026},
  month  = oct,
  howpublished    = {\url{https://aimultiple.com/code-execution-with-mcp}},
  note   = {AIMultiple. Acessado em 16 outubro 2026}
}

Registro de alterações

2 atualizações

20262025

1. 22 jan

   Removida a seção "Comparação: UTCP vs MCP vs Execução de Código MCP".

Links de referência

1.

Code execution with MCP for efficient agents \ Anthropic

Anthropic

2.

Semantic Tool Discovery for Large Language Models: A Vector-Based Approach to MCP Tool Selection

3.

CoreWeave Sandboxes | CoreWeave Forge

4.

OpenAI updates its Agents SDK to help enterprises build safer, more capable agents | TechCrunch

TechCrunch

Şevval Alper

Pesquisadora de IA

Siga-nos

Şevval é pesquisadora de IA na AIMultiple. Ela tem experiência anterior de pesquisa em geração de números pseudoaleatórios usando sistemas caóticos.
Şevval se concentra em ferramentas de codificação de IA, agentes de IA e tecnologias quânticas.

Ver perfil completo

Seja o primeiro a comentar

Seu endereço de e-mail não será publicado. Todos os campos são obrigatórios. Os comentários são deixados em seu idioma original.

Nome

Endereço de email

Comentário

0/450

Postar comentário