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

Anthropic apresentou um método no qual os agentes de IA interagem com os servidores Model Context Protocol (MCP) escrevendo código executável em vez de fazer chamadas diretas às ferramentas. O agente trata as ferramentas como arquivos em um computador, encontra o que precisa e as utiliza diretamente com código, para que os dados intermediários não precisem 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 versus MCP regular

Comparamos duas abordagens para construir 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 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

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 do que os tokens de saída
• Mas a economia de 78% na entrada supera em muito o aumento de 2× na saída
• Redução de custo estimada em ~70% com a execução de código

Ambas alcançaram taxa de sucesso de 100% nessas consultas com o 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:

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

Configuração da comparação

Usamos o servidor MCP da Bright Data com o modo pro ativado, pois ele teve a maior precisão em nosso benchmark de MCP de navegador.

Usamos o GPT-4.1 como o 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 por execução. Cada consulta é executada como um subprocesso separado.

Comparação de arquitetura

Arquitetura do MCP regular

Na abordagem MCP regular, o agente segue um fluxo simples: a consulta do usuário entra em um Agente LangGraph ReAct, 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 do Cliente MCP, e os resultados das ferramentas retornam 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 (somente nomes de ferramentas, não esquemas completos). O agente escreve código Python que chama as ferramentas. Esse código é executado em um ambiente de Executor de Código em sandbox, que se comunica com a Sessão do Cliente MCP. Somente os resultados finais ou resumos retornam ao contexto do agente, e não os dados intermediários brutos.

A implementação da execução de código usa divulgação progressiva. Somente 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 consultas testados; os resultados podem variar para outros tipos de tarefas.
2. Modelo único: Testado apenas com o 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; isso pode causar reduçõ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 cerca de 150 tokens por definição, isso representa 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 modelo lê o documento
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.¹ A pesquisa confirmou que as taxas de sucesso das tarefas caem acentuadamente à medida que o número de ferramentas disponíveis cresce devido à inundação do contexto por 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 de geração de código já existente do modelo, 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 lotam mais a janela de contexto
2. Os dados intermediários deixam de passar 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 grandes ou datasets 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 redução de 98%+ de tokens e a economia de custos correspondente fazem com que valha a pena investigar essa abordagem.

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 via McpToolset e integra-se ao 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.^{3 4} Em abril de 2026, a OpenAI atualizou seu Agents SDK para adicionar capacidades nativas de execução em sandbox, fornecendo espaços de trabalho isolados com acesso restrito a arquivos e código.⁵

Cite esta pesquisa

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

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

Links de referência

1.

Code execution with MCP: building more efficient AI agents \ Anthropic

2.

https://arxiv.org/pdf/2603.20313

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

Sena Sezer

Analista do setor

Siga-nos

Sena é analista do setor na AIMultiple. Ela concluiu sua graduação na Universidade Bogazici.

Ver perfil completo

Pesquisado por

Şevval Alper

Pesquisador de IA

Siga-nos

Şevval é analista da AIMultiple, especializada 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