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 agentes de IA interagem com 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 dos 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%
Média de Tokens de Entrada	15,417	3,310	-78.5%
Média de Tokens de Saída	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
Execução de código MCP: Abordagem inovadora onde o modelo escreve código que chama ferramentas, mantendo os dados intermediários fora do contexto

Principais conclusões

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
Execução de código precisa apenas de ~3,300 tokens por chamada

Maior quantidade de 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 geralmente mais baratos que tokens de saída
Mas a economia de 78% em tokens de entrada supera em muito o aumento de 2× nos tokens de saída
Estimativa de ~70% de redução de custo com a 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 postagem 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, informe os 5 melhores desempenhos perfeitos (ou seja, os modelos com 100% de precisão top-5)
Acesse https://aimultiple.com/open-source-embedding-models, informe qual modelo tem a maior latência.

Configuração da comparação

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

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

Visite o site

Usamos 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 MCP regular

Na abordagem 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 através da Sessão do 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 Code Execution Agent com um contexto compacto (apenas 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 Code Executor em sandbox, que se comunica com a Sessão do 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ídas 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

Diversidade de consultas: Apenas 2 tipos de consulta testados; os resultados podem variar para outros tipos de tarefa.
Modelo único: Testado apenas com GPT-4.1; outros modelos podem apresentar 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, 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 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. Com cerca de 150 tokens por definição, isso equivale a 150,000 tokens consumidos antes que o agente leia sua primeira solicitação.

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

Tarefa: “Obter 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 documento
O agente o envia para o Salesforce (outros 50,000 tokens)

O modelo lida com mais de 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 drasticamente à medida que o número de ferramentas disponíveis cresce devido ao congestionamento do contexto pelas definições de esquema.³ Expor as ferramentas MCP como funções chamáveis e permitir que o modelo escreva código Python que invoque 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.

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

Adicionar como fonte preferencial

Quando usar 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:

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

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 conjuntos de dados 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 tokens superior a 98% e as economias de custo correspondentes tornam essa abordagem digna de investigação.

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 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 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}
}