O MCP está morto? | Code Mode da Cloudflare explicado | Agentes de IA e tool calling

Autoria: At A Glance! · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Is MCP Dead? | Cloudflare Code Mode Explained | AI Agents & Tool Calling · Canal: At A Glance! · 10:37 · Assistir no YouTube

Tópicos: Agentes de IA, Segurança de IA

Resumo

O vídeo explica que o Code Mode não substitui nem altera o protocolo MCP: ele muda a forma como agentes descobrem e orquestram ferramentas. Em vez de carregar definições de milhares de ferramentas no contexto, o modelo pode localizar operações e gerar JavaScript para executá-las em conjunto. Essa abordagem pode reduzir o espaço ocupado pelas definições de ferramentas e ajudar em workflows com operações dependentes, mas não é necessária para tarefas simples. Em produção, sandbox, permissões, aprovações e auditoria são controles distintos e essenciais; a adoção deve ser avaliada com testes e métricas.

Pontos-chave

O desafio de trabalhar com muitas ferramentas é expor suas capacidades ao modelo sem consumir contexto excessivo com definições.
No Code Mode, o modelo descobre operações e gera um programa que pode combiná-las e processar resultados em uma execução.
A estimativa apresentada pela Cloudflare compara cerca de 1,17 milhão de tokens em definições nativas com aproximadamente 2.000 tokens para a interface do Code Mode; não representa uma redução equivalente no uso total de tokens do workflow.
Há padrões que envolvem uma interface de código sobre um servidor MCP existente ou funções de busca e execução sobre uma especificação de API ampla.
Tool calling tradicional pode ser mais simples para poucas ferramentas e ações diretas; Code Mode pode ser útil em operações dependentes, condições, loops e processamento de resultados.
Executar código em sandbox não basta para garantir segurança: autorização, menor privilégio, controle de rede, validação, aprovações e logs de auditoria também são necessários.
Antes de adotar Code Mode, compare-o com tool calling tradicional usando a mesma tarefa e métricas como tokens, latência, falhas, conclusão, precisão e violações de segurança.
A ideia central é: MCP conecta aplicações a capacidades externas, Code Mode orquestra operações e os controles de segurança definem o que é permitido.

Capítulos

Início	Capítulo	Resumo
00:07	O desafio de expor muitas ferramentas	O vídeo apresenta o problema do consumo de contexto causado pelas definições de catálogos extensos e introduz o Code Mode.
02:12	Execução, exemplo e redução das definições	O modelo pode agrupar operações em um programa executado em ambiente isolado, como no exemplo de atualização de um registro DNS, e o vídeo compara o tamanho das definições.
05:22	Padrões de Code Mode e quando usar	São descritas duas formas de implementar Code Mode e os casos em que ele pode ou não ser preferível ao tool calling tradicional.
07:27	Segurança e avaliação em produção	O vídeo diferencia sandbox de autorização e recomenda salvaguardas e testes comparativos antes de adotar a abordagem.
09:35	Conclusão: MCP conecta, Code Mode orquestra	A conclusão reforça que MCP não está morto e que Code Mode é uma alternativa para orquestrar ferramentas, não uma solução superior em todas as situações.

Citações

O Code Mode muda a forma como os agentes usam ferramentas, não o próprio protocolo MCP. — 00:38

Estamos transferindo parte da orquestração de decisões repetidas do modelo para o código. — 02:12

O sandbox restringe a execução; as permissões determinam o que um agente pode fazer. — 07:58

MCP conecta; Code Mode orquestra. Os controles de segurança definem o que é permitido. — 10:37

Conceitos e entidades

MCP (conceito): Padrão que permite a aplicações de IA se conectarem a capacidades externas.
Code Mode (conceito): Abordagem em que o modelo descobre operações e gera código para combiná-las e executá-las.
Cloudflare (empresa): Empresa cuja abordagem de Code Mode é apresentada no vídeo.
tool calling (conceito): Padrão em que o modelo seleciona ferramentas e as chama, geralmente tomando decisões entre as chamadas.
JavaScript (conceito): Linguagem usada pelo modelo para gerar programas que executam operações no exemplo de Code Mode.
sandbox (conceito): Ambiente isolado que restringe a execução do código, mas não substitui autorização e controles de permissão.

Tradução completa (pt-BR)

00:07 Olá, pessoal, sejam bem-vindos de volta ao meu canal do YouTube. Você já se perguntou o que acontece quando um agent de IA precisa trabalhar com centenas ou até milhares de ferramentas? O problema não é necessariamente que o MCP não consiga lidar com essas ferramentas. O desafio é como as expomos ao modelo e como o modelo as usa com eficiência. É aí que entra o Code Mode. Em vez de pedir ao modelo que selecione e chame ferramentas individuais repetidamente, deixamos que ele escreva um programa que combina várias operações. E

00:38 o ponto importante é este: o Code Mode muda a forma como os agents usam ferramentas, não o próprio protocolo MCP. Vamos entender primeiro o problema. Cada ferramenta pode ter um nome, uma descrição, um esquema de entrada, parâmetros e restrições. Quando temos apenas algumas ferramentas, isso é administrável. Vamos imaginar um agent trabalhando com milhares de operações de API; fornecer todas essas definições ao modelo pode consumir uma parte significativa da context window antes mesmo de ele começar a resolver o problema de fato. Mas imagine que esse

01:09 contexto poderia ser usado para a solicitação do usuário, informações úteis e raciocínio. Então, o desafio é simples: como podemos dar a um agent acesso a muitos recursos sem carregar de antemão todas as definições das ferramentas na context window? É aqui que a abordagem Code Mode da Cloudflare fica interessante. Em vez de expor um catálogo enorme de APIs como ferramentas individuais voltadas ao modelo, essa abordagem oferece duas operações principais: search e execute. Pense em search como um mecanismo de descoberta. O modelo usa essa operação para encontrar os recursos de API de que precisa. Depois, execute

01:41 executa código JavaScript que chama esses recursos e processa os resultados. Por exemplo, se um agent precisa encontrar um registro DNS e atualizá-lo, pode descobrir as operações relevantes e escrever um pequeno programa para executar o workflow. O modelo não precisa ter o esquema completo de cada endpoint de API na context window desde o início. Agora, vamos comparar as duas abordagens. Com o tool calling tradicional, o modelo geralmente seleciona uma ferramenta, recebe o resultado e então decide o que fazer em seguida. Se várias operações dependerem umas das outras,

02:12 isso pode exigir várias interações com o modelo. Com o Code Mode, o modelo pode escrever um programa que contenha toda a sequência de operações. Por exemplo, pode recuperar um registro, verificar o valor atual e atualizá-lo somente se uma condição for atendida. O programa controla esse fluxo, de modo que os resultados intermediários podem permanecer no ambiente de execução, em vez de serem enviados de volta ao modelo após cada operação. A principal diferença é que transferimos parte da orquestração de decisões repetidas do modelo para o código. Mas aqui vai uma pergunta importante. Se

02:44 o modelo gera código, onde esse código é realmente executado? Na arquitetura Code Mode do lado do servidor da Cloudflare, o modelo se conecta por meio de um cliente MCP. Ele descobre os recursos e envia o JavaScript gerado para execução. Esse código é executado em um ambiente isolado de worker e acessa a API pelo caminho de execução controlado pelo host. Em seguida, as informações resultantes são devolvidas ao modelo. Observe que o código gerado não recebe simplesmente acesso irrestrito à máquina do usuário. No entanto,

03:15 o isolamento, por si só, não basta. Ainda precisamos de autorização adequada, verificações de permissões e controles sobre quais operações o código pode executar. Vamos tornar isso mais prático com um exemplo simples. Suponha que você peça a um agent de IA: encontre o registro DNS de app.example.com; se ele apontar para o endereço IP antigo, atualize-o para o novo. Primeiro, o agent descobre as operações de DNS relevantes. Em seguida, consulta o nome do host correspondente e verifica o endereço IP atual. Aqui, você pode ver que o endereço IP atual é 192.0.2.10.

03:49 E o endereço IP de destino é 192.0.2.25. O programa gerado verifica se o valor atual corresponde ao endereço antigo esperado. Ele só tenta fazer a atualização se essa condição for atendida. Por fim, retorna o resultado. Em vez de orquestrar cada etapa por meio de uma decisão separada do modelo, o agent pode expressar as operações dependentes em um único programa. Um detalhe importante: uma implementação real precisa aplicar a autorização e qualquer aprovação necessária antes de executar uma operação de gravação.

04:20 O código mostrado aqui é ilustrativo, não é um script da Cloudflare pronto para execução. Agora, vamos analisar os números apresentados na comparação. Para o catálogo de APIs mostrado aqui, a Cloudflare relata aproximadamente 1,17 milhão de tokens para a quantidade de tokens ocupada pelas definições nativas das ferramentas, em comparação com cerca de 2.000 tokens para a interface do Code Mode. Isso representa uma redução de aproximadamente 99,9% na quantidade de tokens ocupada pelas definições de ferramentas, segundo os números apresentados. Mas há uma distinção importante: isso não é uma

04:51 redução de 99,9% em todos os tokens usados pelo workflow inteiro do agent. A comparação diz respeito à quantidade de tokens ocupada pelas definições de ferramentas e pela interface. O uso real de tokens vai depender da tarefa, do código gerado, do resultado retornado e das interações com o modelo envolvidas. Ainda assim, quando um modelo precisa acessar um catálogo de APIs muito grande, reduzir as definições que precisa processar de antemão pode fazer uma diferença significativa. Isso diz respeito à quantidade de tokens ocupada pelas definições de ferramentas e pela interface. O uso real de tokens

05:22 vai depender da tarefa, do código gerado, do resultado retornado e das interações com o modelo envolvidas. O Code Mode não é uma arquitetura única que funcione da mesma forma em todos os lugares. A apresentação destaca dois padrões principais. O primeiro é uma interface única, voltada a código, que envolve um servidor MCP existente; em vez de expor cada ferramenta upstream separadamente ao modelo, a interface permite que o código gerado trabalhe com os métodos tipados disponíveis. Isso pode ser útil quando você já tem um servidor MCP e quer simplificar a forma como o modelo interage com ele.

05:53 O segundo padrão usa funções de search e funções de execute em uma especificação de API extensa. Nesse caso, o modelo descobre as operações de que precisa e as executa por meio do código gerado. Essa abordagem é especialmente útil quando um catálogo de APIs contém milhares de endpoints. Portanto, a diferença é que um padrão envolve ferramentas existentes, enquanto o outro descobre e executa operações a partir de uma superfície de API extensa. A esta altura, você talvez pense que deveríamos substituir todas as ferramentas tradicionais pelo Code Mode, mas

06:25 essa não é necessariamente a decisão certa. Se um agent tiver apenas algumas ferramentas e precisar executar uma ação simples, o tool calling tradicional pode ser uma solução mais simples. O Code Mode se torna mais atraente quando um workflow envolve várias operações dependentes, lógica condicional, loops, filtragem ou processamento de resultados grandes. No entanto, também precisamos considerar a segurança e a complexidade. Podemos restringir com segurança o código gerado? Podemos inspecionar e auditar suas ações? O código realmente reduz o uso da context window ou melhora o workflow? Se a resposta for

06:57 não, introduzir o Code Mode pode criar mais complexidade do que valor. Escolha o padrão de interação de acordo com o problema. Se a resposta for não, introduzir o Code Mode pode criar mais complexidade do que valor. Escolha o padrão de interação de acordo com o problema, não simplesmente porque a abordagem mais nova parece mais avançada. Agora, vamos falar de uma das considerações mais importantes para produção: a segurança. Executar código gerado em um sandbox ajuda a isolar a execução, mas isso não torna automaticamente segura toda e qualquer ação.

07:27 Imagine um agent que tem permissão para ler registros DNS, mas não deveria ter permissão para excluí-los. Mesmo que o modelo gere código que tente excluir um registro, a camada de permissões deve rejeitar essa operação. É por isso que sistemas de produção precisam de várias salvaguardas. Use permissões de privilégio mínimo, isole a execução do código, controle o acesso à rede, valide entradas e saídas, exija aprovações para ações sensíveis e mantenha logs de auditoria. Lembre-se de que o sandbox e a autorização resolvem

07:58 problemas diferentes. É por isso que sistemas de produção precisam de várias salvaguardas. Use permissões de privilégio mínimo, isole a execução do código, controle o acesso à rede, valide entradas e saídas, exija aprovação para ações sensíveis e mantenha logs de auditoria. Lembre-se de que o sandbox e a autorização resolvem problemas diferentes. Um sandbox restringe a execução; as permissões determinam o que um agent pode fazer. Ambos são essenciais quando o código gerado pode interagir com sistemas reais. Espero que você tenha entendido esse

08:30 aspecto da segurança. Então, se você está desenvolvendo agents de IA para produção, como deve começar a usar o Code Mode? Não substitua imediatamente sua arquitetura atual de tool calling. Primeiro, identifique um workflow que exija várias chamadas de ferramentas dependentes. Estabeleça uma linha de base usando o tool calling convencional. Depois, implemente o mesmo workflow usando o Code Mode. Agora compare as duas abordagens na mesma tarefa. Meça os tokens de entrada e saída, o número de interações com o modelo, a latência de ponta a ponta, as falhas de API, a conclusão da tarefa, a precisão e as violações de segurança. Além disso,

09:03 teste o que acontece quando uma chamada de API falha, quando o código gerado se comporta de forma inesperada ou quando uma operação não está autorizada. Por fim, compare os resultados; se o Code Mode reduzir a sobrecarga e melhorar o workflow sem comprometer a correção ou a segurança, talvez valha a pena adotá-lo. O objetivo não é usar o Code Mode em todos os lugares. O objetivo é comprovar que ele realmente oferece valor mensurável para a sua carga de trabalho específica. Vamos juntar tudo. Pense no MCP como um padrão que permite que aplicativos de IA

09:35 se conectar a recursos externos. O modo de código muda a forma como o modelo usa esses recursos. Em vez de orquestrar manualmente cada chamada de ferramenta, o modelo pode escrever um programa que descobre, combina e executa várias operações. O programa é executado em um ambiente controlado. Embora a autorização e outras políticas de segurança determinem o que ele realmente pode fazer, o resultado é uma maneira diferente de orquestrar ferramentas, especialmente quando os workflows envolvem muitas operações ou grandes catálogos de APIs. E lembre-se: o modo de código não é

10:05 automaticamente melhor em todas as situações; o tool calling tradicional continua sendo útil para ações simples e diretas. Então, para concluir: o MCP está morto? Não. O que está mudando é a forma como disponibilizamos e orquestramos ferramentas para agents de IA. O modo de código demonstra uma alternativa a oferecer um grande número de ferramentas individuais. Se você está criando agents de IA, não se concentre apenas nas ferramentas que disponibiliza. Considere também como o modelo as descobre, combina e executa. O MCP conecta; o modo de código orquestra.

10:37 Os controles de segurança determinam o que é permitido. Esse é o modelo mental que você deve lembrar. Espero que você tenha entendido todos os conceitos envolvidos neste vídeo. Se tiver alguma dúvida, pode escrevê-la diretamente na seção de comentários; terei prazer em esclarecer. Para ver mais vídeos como este, curta, compartilhe e se inscreva no meu canal. Além disso, clique no ícone do sino e não se esqueça de me seguir no Instagram. Junte-se a mim no Telegram. Obrigado por assistir. Tenha um bom dia.

Transcrição original

[00:07] Hello everyone, welcome back to my YouTube channel. Have you ever wondered what happens when an AI agent needs to work with hundreds or even thousands of tools? The problem isn’t necessarily that MCP can’t handle these tools. The challenge is how we expose them to the model and how the model uses them efficiently. That’s where Code Mode comes in. Instead of asking the model to select and call individual tools repeatedly, we let it write a program that combines multiple operations. And

[00:38] the important point is this. Code Mode changes how agents use tools, not the MCP protocol itself. Let’s understand the problem first. Every tool can have a name, description, input schema, parameters, and constraints. When we have just a few tools, this is manageable. Let’s imagine an agent working with thousands of API operations; providing all those definitions to the model can consume a significant amount of its context before it even starts solving the actual problem. But imagine that

[01:09] context could otherwise be used for the user’s request. Useful information and reasoning. So, the challenge is simple. How can we give an agent access to many capabilities without loading every tool definition into its context up front? This is where Cloudflare’s Code Mode approach becomes interesting. Instead of exposing a massive API catalog as individual model-facing tools. This approach provides two primary operations: search and execute. Think of search as a discovery mechanism. The model uses it to find the API capabilities it needs. Then, execute

[01:41] runs JavaScript code that calls those capabilities and processes the results. For example, if an agent needs to find a DNS record and update it, it can discover the relevant operations and write a small program to perform the workflow. The model doesn’t need every API endpoint’s full schema in its context from the beginning. Now let’s compare the two approaches. With traditional tool calling, the model typically selects a tool, receives its result, and then decides what to do next. If several operations depend on

[02:12] one another, this can require multiple model turns. With Code Mode, the model can write a program containing the entire sequence of operations. For example, it can retrieve a record, check its current value, and update it only if a condition is satisfied. The program handles that control flow, so intermediate results can remain within the execution environment instead of being returned to the model after every operation. The key difference is that we are moving some of the orchestration from repeated model decisions into code . But here is an important question. If

[02:44] the model generates code, where does that code actually execute? In Cloudflare’s server-side Code Mode architecture, the model connects through an MCP client. It discovers the capabilities and submits the generated JavaScript for execution. That code runs in an isolated worker environment and accesses the API through the host-controlled execution path. The resulting information is then returned to the model. Notice that the generated code isn’t simply given unrestricted access to the user’s machine. However,

[03:15] isolation alone isn’t enough. We still need proper authorization, permission checks, and controls over which operations the code can perform. Let’s make this practical with a simple example. Suppose you ask an AI agent. Find the DNS record for app.example.com ; if it points to the old IP address, update it to the new one. The agent first discovers the relevant DNS operations. It then queries the matching host name and checks the current IP address. Here you can see the current IP address is 192.0.2.10.

[03:49] And the target IP address is 192.0.2.25 . The generated program checks whether the current value matches the expected old address. Only if that condition is satisfied does it attempt the update. Finally, it returns the result. Instead of orchestrating every step through a separate model decision, the agent can express the dependent operations in one program. One important detail: a real implementation must enforce authorization and any required approval before performing a write operation.

[04:20] The code which is shown here is illustrative, not a ready-to-run Cloudflare script. Now let’s look at the numbers presented in the comparison . For the API catalog shown here, Cloudflare reports approximately 1.17 million tokens for the native tool definition footprint, compared with roughly 2,000 tokens for the code mode interface. That’s a reduction of approximately 99.9%in the reported tool definition footprint. But there is an important distinction: this is not a

[04:51] 99.9%reduction in every token used by the entire agent workflow. The comparison concerns the tool definition and interface footprint. Actual token usage will depend on the task, the generated code, the returned result, and the model interactions involved. Still, when a model needs access to a very large API catalog, reducing the definitions it must process upfront can make a substantial difference. This concerns the tool definition and interface footprint. Actual token usage

[05:22] will depend on the task, the generated code, the returned result, and the model interactions involved. Code mode isn’t a single architecture that works identically everywhere. The presentation highlights two major patterns. The first is the single code-oriented interface wrapped around an existing MCP server; instead of exposing every upstream tool separately to the model, the interface lets generated code work with the available typed methods. This can be useful when you already have an MCP server and want

[05:53] to simplify how the model interacts with it. The second pattern uses search functions and execute functions against a large API specification. Here the model discovers the operations it needs and executes them through the generated code. This approach is particularly useful when an API catalog contains thousands of endpoints. So the distinction is that one pattern wraps existing tools while the other discovers and executes operations from a large API surface. At this point you might think we should replace every traditional tool with Code Mode, but

[06:25] that’s not necessarily the right decision. If an agent has only a few tools and needs to perform one simple action, traditional tool calling may be a cleaner solution. Code Mode becomes more attractive when a workflow involves multiple dependent operations, conditional logic, loops, filtering, or processing large results. However, we also need to consider security and complexity. Can we safely constrain the generated code? Can we inspect and audit its actions? Does the code actually reduce context usage or improve the workflow? If the answer is

[06:57] no, introducing Code Mode might create more complexity than value. Choose the interaction pattern based on the problem. If the answer is no, introducing Code Mode might create more complexity than value. Choose the interaction pattern based on the problem, not simply because the newer approach looks more advanced. Now let’s discuss one of the most important production considerations, which is security. Running generated code in a sandbox helps isolate execution, but it doesn’t automatically make every action

[07:27] safe. Imagine an agent that has permission to read DNS records but should not be allowed. To delete them. Even if the model generates code that attempts to delete a record, the permission layer should reject that operation. That’s why production systems need multiple safeguards. Use least-privilege permissions, isolate code execution, control network access, validate inputs and outputs, require approvals for sensitive actions, and maintain audit logs. Remember that sandboxing and authorization solve

[07:58] different problems. That’s why production systems need multiple safeguards. Use least-privilege permissions, isolate code execution, control network access, validate inputs and outputs, require approval for sensitive actions, and maintain audit logs. Remember that sandboxing and authorization solve different problems. A sandbox constrains execution; permissions determine what an agent is allowed to do. Both are essential when generated code can interact with real systems. Hope you have understood this

[08:30] security aspect. So if you are building production-grade AI agents, how should you start using Code Mode? Don’t replace your current existing tool-calling architecture immediately. First, identify a workflow that requires several dependent tool calls. Establish a baseline using conventional tool calling. Then implement the same workflow using Code Mode. Now compare both approaches across the same task. Measure the input and output tokens. The number of model turns, end-to-end latency, API failures, task completion, accuracy, and security violations. Also

[09:03] test what happens when an API call fails. The generated code behaves unexpectedly, or an operation is unauthorized. Finally, compare the results; if code mode reduces overhead and improves the workflow without compromising correctness or security, it may be worth adopting. The goal is not to use code mode everywhere. The goal is to prove that it actually delivers measurable value for your particular workload. Let’s bring everything together. Think of MCP as a standard that allows AI applications to

[09:35] connect with external capabilities. Code mode changes how the model uses those capabilities. Instead of manually orchestrating every individual tool call, the model can write a program that discovers, combines, and executes multiple operations. The program runs within a controlled execution environment. While authorization and other security policies govern what it actually does, the result is a different way of orchestrating tools, particularly when workflows involve many operations or large API catalogs. And remember, code mode isn’t

[10:05] automatically better in every situation ; traditional tool calling remains useful for simple and direct actions. So, to conclude, is MCP dead? No. What’s changing is how we expose and orchestrate tools for AI agents. Code mode demonstrates an alternative to providing large numbers of individual tools. If you are building AI agents, don’t focus only on what tools you expose. Also consider how the model discovers, combines, and executes them. MCP connects; code mode orchestrates.

[10:37] Security controls what is allowed. That’s the mental model to remember. I hope you have understood every single concept involved in this particular video. If you have any single doubt, you can straight away put it in the comment section; I will be happy to solve it. For more such videos, do like , share, and subscribe to my channel. Also, hit the bell icon and don’t forget to follow me on Instagram. Please join me on Telegram. Thanks for watching, have a good day ahead.