Execução de código com MCP: uma nova abordagem para a eficiência de agentes de IA

Anthropic apresentou um método no qual 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 model. 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 criar agentes de IA que interagem com ferramentas externas por meio do MCP:

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

Ferramentas utilizadas

Este benchmark foi realizado usando o servidor MCP do Bright Data com Pro Mode, pois apresentou a maior precisão em nosso benchmark de MCP de navegador.

Principais resultados

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

• 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 model 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 geralmente 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
• Estimado ~70% de redução de custo com a execução de código

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

A abordagem de execução de código é inspirada na publicação do 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 da execução de código com MCP

Tarefas

Executamos cada tarefa 50 vezes para cada abordagem:

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

Configuração da comparação

Para ambas as abordagens, usamos o servidor MCP do Bright Data 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 regular do MCP

Na abordagem regular de MCP, o agente segue um fluxo simples: a consulta do usuário entra em um Agente ReAct do LangGraph, 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 sessão de cliente MCP, e os resultados das ferramentas fluem de volta 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 Agente de Execução de Código 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 de Executor de Código em sandbox, que se comunica com a sessão de cliente MCP. Apenas os resultados finais ou resumos retornam ao contexto do agente, não os dados intermediários brutos.

A implementação da 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 model 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 testados; os resultados podem variar para outros tipos de tarefas.
2. Model único: Apenas testado com o GPT-4.1; outros models 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 model; isso 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 model. 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 cerca de 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 anotações de reunião do Google Drive e adicione-as ao Salesforce.”

O que acontece:

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

O model processa 100.000+ tokens para mover dados de um lugar para outro.
As implementações tradicionais de MCP exigem que o model 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.¹ A pesquisa confirmou que as taxas de sucesso das tarefas caem acentuadamente à medida que o número de ferramentas disponíveis aumenta, devido à inundação de contexto causada pelas definições de esquema.² Expor as ferramentas MCP como funções chamáveis e permitir que o model escreva código Python que invoca ferramentas diretamente aproveita a capacidade existente de geração de código do model, em vez de forçar a seleção a partir de esquemas predefinidos.

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

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

1. As definições de ferramentas não ocupam mais a janela de contexto
2. Os dados intermediários deixam de fluir pelo model 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 de 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 redução de 98%+ nos 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

Além do LangGraph, o Agent Development Kit (ADK) do Google oferece suporte nativo a MCP por meio do McpToolset e integra-se com o protocolo Agent2Agent (A2A), que padroniza a comunicação agente a agente por meio de cartões de capacidade publicados em /.well-known/agent-card.json.³⁴ 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  = aug,
  howpublished    = {\url{https://aimultiple.com/code-execution-with-mcp}},
  note   = {AIMultiple. Acessado em 14 agosto 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: building more efficient AI agents \ Anthropic

2.

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

3.

Developer’s Guide to AI Agent Protocols - Google Developers Blog

4.

MCP tools - Agent Development Kit (ADK)

5.

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