Benchmark

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

com

atualizado em 24 jun. 2026

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

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

Métrica	MCP Regular	MCP com Execução de Código	Diferença
Taxa de Sucesso	100%	100%	Igual
Latência Média	9.66s	10.37s	+7%
Tokens de Entrada Médios	15.417	3.310	-78.5%
Tokens de Saída Médios	87	192	+120%
Total de Tokens de Entrada	770.852	165.496	-78.5%
Total de Tokens de Saída	4.345	9.585	+120%
Total de Todos os Tokens	775.197	175.081	-77.4%

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

MCP Regular: Abordagem tradicional onde todas as definições de ferramentas são carregadas na janela de contexto do modelo
MCP com execução de código: Abordagem inovadora onde 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):

O MCP regular carrega ~15.400 tokens de definições de ferramentas por chamada
A execução de código precisa apenas 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:

Tokens de entrada são tipicamente mais baratos que tokens de saída
Mas a economia de 78% na entrada supera largamente o aumento de 2× na saída
Estima-se ~70% de redução de custo com execução de código

Ambas alcançaram 100% de taxa de sucesso nestas 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:

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

Configuração da comparação

Utilizámos o servidor MCP da Bright Data com o modo pro ativado, pois foi o que apresentou a maior precisão no nosso benchmark de MCP para navegador.

Bright Data MCP servidor: ferramentas de integração web para IA.

Visite o site

Utilizámos o GPT-4.1 como LLM devido à sua ampla janela de contexto.

Configuração do Ambiente: Limpámos quaisquer dados em cache e garantimos uma nova ligação ao servidor MCP por execução. Cada consulta é executada como um subprocesso separado.

Comparação de arquitetura

Arquitetura MCP regular

Na abordagem MCP regular, o agente segue um fluxo simples: a consulta do utilizador entra num LangGraph ReAct Agent, que tem acesso a todas as 63 definições de ferramentas na sua janela de contexto. O agente seleciona e chama ferramentas através 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 intermédia: a consulta do utilizador vai para um Code Execution Agent com um contexto compacto (apenas nomes de ferramentas, não os esquemas completos). O agente escreve código Python que chama as ferramentas. Este código é executado num ambiente isolado de Code Executor, que comunica com a MCP Client Session. Apenas os resultados finais ou resumos regressam 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 modelo precisa de usar uma ferramenta, escreve código Python que chama uma função assíncrona call_tool() fornecida no ambiente de execução.

Limitações da nossa abordagem

Diversidade de consultas: Apenas 2 tipos de consulta testados; os resultados podem variar para outros tipos de tarefas.
Modelo único: Testado apenas com GPT-4.1; outros modelos podem mostrar padrões diferentes
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 complexas.

Deixe nossa equipe automatizar um dos seus processos de negócio com agentes de IA, gratuitamente.

Automatizar um processo

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 ligado 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 o seu primeiro pedido.

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

Tarefa: "Obter as minhas notas de reunião do Google Drive e adicioná-las ao Salesforce."

O que acontece:

O agente obtém o documento (50.000 tokens)
O modelo lê-o
O agente envia-o para o Salesforce (outros 50.000 tokens)

O modelo processa 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 investigação confirmou que as taxas de sucesso das tarefas diminuem acentuadamente à medida que o número de ferramentas disponíveis cresce, devido à sobrecarga de contexto das 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:

As definições de ferramentas já não sobrecarregam a janela de contexto
Os dados intermediários deixam de fluir desnecessariamente pelo modelo

A abordagem funciona melhor quando:

Tem muitas ferramentas MCP ligadas
Os 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 os seus agentes

Os requisitos de infraestrutura significam que isto não é automaticamente melhor para todos os casos de uso. Implementaçõ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%+ de tokens e as correspondentes poupanças de custos tornam esta abordagem digna de investigação.

Veja mais dos nossos benchmarks e insights baseados em dados na Pesquisa Google.

Adicionar como fonte preferencial

Frameworks e protocolos alternativos

Além do LangGraph, o Agent Development Kit (ADK) da Google oferece suporte nativo a MCP via McpToolset e integra-se com o protocolo Agent2Agent (A2A), que padroniza a comunicação agente-a-agente através de cartões de capacidade publicados em /.well-known/agent-card.json.⁴⁵ Em abril de 2026, a OpenAI atualizou o 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.

Sena Sezer and Şevval Alper (2026) - "Execução de Código com MCP: Uma Nova Abordagem para Eficiência de Agentes de IA". Publicado on-line em AIMultiple.com. Acessado em 24 Junho 2026, em: https://aimultiple.com/code-execution-with-mcp [Recurso on-line]

Sezer, S., & Alper, Ş. (2026, 24 Junho). Execução de Código com MCP: Uma Nova Abordagem para Eficiência de Agentes de IA. AIMultiple. https://aimultiple.com/code-execution-with-mcp

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