Cloudflare Dynamic Workers: o segredo do sandbox de IA 100 vezes mais rápido que contêineres

Seu AI Agent acabou de gerar um trecho de código para análise de dados. Na hora de executar, o contêiner leva 3 segundos para iniciar, consome 200 MB de memória e a requisição do usuário já estourou o tempo limite. Isso não é um caso isolado: é uma dor comum quando o setor inteiro tenta rodar código de IA dentro de contêineres.

O Dynamic Workers, lançado pela Cloudflare em março de 2026, usa V8 Isolates para reduzir esse tempo de inicialização para poucos milissegundos e comprimir o uso de memória para poucos MB. É um ganho de desempenho de 100 vezes. Por trás disso existe uma filosofia de isolamento completamente diferente.

Resumindo, Dynamic Workers não é apenas um “contêiner mais rápido”. Ele torna o modelo “um sandbox por requisição” viável não só tecnicamente, mas também economicamente. Este texto analisa em profundidade a diferença essencial entre V8 Isolates e contêineres tradicionais, mostra exemplos práticos da API do Dynamic Workers e ajuda você a decidir a arquitetura. Se você está escolhendo um sandbox para AI Agents, este artigo ajuda a fazer essa conta direito.

Por que contêineres viraram gargalo de desempenho para AI Agents

Como isso era feito antes? Contêineres eram a solução dominante. O Kubernetes agenda um Pod, baixa a imagem e prepara o ambiente. O fluxo é maduro, mas pesado. O cenário de AI Agent tem uma característica própria: a execução de código costuma ser instantânea. Talvez seja só um script de análise de dados que roda por alguns segundos, mas o contêiner precisa de mais de 3 segundos para iniciar. A conta não fecha.

Segundo um relatório de 2026 do Zhihu sobre AI Agent Sandbox, um contêiner Docker inicia em cerca de 500 ms, mas isso é apenas a “partida”. Somando download da imagem, configuração de rede e inicialização de dependências, o tempo até ficar realmente utilizável costuma passar de 3 segundos. E a memória? Começa em dezenas de MB; ambientes mais complexos passam facilmente de 200 MB.

Você talvez pense: um pool aquecido resolve, certo? Basta deixar um lote de contêineres já iniciado, esperando uso. Sim, essa é a prática comum. Mas aí surgem três problemas.

Primeiro: custo. Um pool aquecido precisa manter contêineres online o tempo todo, com ou sem requisições. Cem contêineres aquecidos, cada um com 200 MB de memória, já pesam bastante. Ainda existe o risco de segurança da reutilização: dados da requisição anterior podem continuar na memória.

Segundo: complexidade. Um pool aquecido exige gerenciamento de ciclo de vida, health checks e auto scaling. Essa infraestrutura já dá trabalho por si só. Em um projeto anterior, usei um pool aquecido com Kubernetes, e o custo de manutenção ficou maior que o código de negócio.

Terceiro: incompatibilidade com o cenário. A execução de código por AI Agents costuma ser descartável. O usuário envia um CSV, a IA gera código de análise, executa e destrói. Cada requisição precisa de um ambiente isolado. A reutilização de contêineres no pool aquecido quebra exatamente esse isolamento.

Imagine a cena: o AI Agent do usuário A executa um código que processa dados sensíveis. O contêiner volta para o pool. A requisição do usuário B chega e pega o mesmo contêiner. Mesmo com mecanismos de limpeza, o risco de dado residual continua existindo. Isso não é só teoria: em 2025 já houve relatos de vazamento causado por resíduos em contêineres.

Então a contradição do modelo com contêineres no cenário de AI Agents é bem clara: inicialização lenta, memória cara, risco de segurança em pools aquecidos e manutenção complexa. Não significa que contêineres sejam ruins. Significa que a filosofia de projeto deles não combina com o padrão de execução de um AI Agent.

Como V8 Isolates reduz a inicialização para milissegundos

O que são V8 Isolates? O V8 é o motor JavaScript do Chrome, responsável por compilar JS para código de máquina e executá-lo. Um Isolate é a unidade de isolamento do V8: um ambiente de execução independente, com seu próprio heap de memória, cache de compilação e objeto global.

O ponto-chave é este: um Isolate não chama o kernel do sistema operacional hospedeiro.

Como um contêiner funciona? Ele inicia um processo e chama o kernel do host por meio de system calls, ou syscalls. O isolamento vem de namespace e cgroup no nível do kernel. O problema é que esse “isolamento” é parcial: contêiner e host compartilham o mesmo kernel. As syscalls passam pelo mesmo caminho do kernel.

V8 Isolates funcionam de outro jeito. O código JavaScript roda dentro do Isolate e não gera syscall. Tudo acontece dentro do processo: alocação de memória, garbage collection, compilação e execução. Isso significa que a fronteira de isolamento fica dentro do processo, não no kernel.

Uma reportagem de 2026 da Tencent News trouxe números concretos: V8 Isolates iniciam em poucos milissegundos e consomem poucos MB de memória. Em comparação com contêineres, a inicialização é 100 vezes mais rápida e a eficiência de memória é 10 a 100 vezes maior.

KiloClaw - OpenClaw gerenciado para empresas: orquestração de agentes IA e roteamento inteligente

Começar →Anúncio

Aqui está uma tabela completa para comparar tecnologias de isolamento e facilitar a escolha:

Essa tabela mostra uma informação importante: nível de segurança e velocidade de inicialização envolvem trade-off. Firecracker é o mais seguro, com kernel virtual independente, mas também inicia mais devagar e consome mais memória. V8 Isolates é o mais rápido e econômico, mas tem segurança intermediária.

Por que V8 Isolates tem só três estrelas em segurança? Porque a fronteira de isolamento fica dentro do processo. Se um Isolate for comprometido, em tese ele pode afetar outros Isolates no mesmo processo. Isso é mais seguro que contêineres, que compartilham o kernel apesar do namespace, mas mais fraco que uma microVM, que tem kernel próprio.

Só que o Dynamic Workers da Cloudflare adiciona várias camadas de segurança e eleva esse nível de “três estrelas” para algo aceitável na prática. Mais abaixo, explico as cinco camadas de defesa.

Voltando ao ponto principal: a vantagem central dos V8 Isolates não é “ser mais seguro”, e sim “ser mais barato”. Iniciar um sandbox independente por requisição e destruí-lo depois do uso é um luxo no mundo dos contêineres. No mundo dos Isolates, é o padrão.

API do Dynamic Workers: a filosofia por trás de load() e get()

Dynamic Workers oferece dois modos de API. A filosofia é simples: um modo para execução instantânea, outro para ciclo de vida mais longo.

load(): execução única, destruição após o uso

O modo load() serve para cenários de execução pontual. O código gerado pela IA chega, o Isolate inicia, executa e é destruído. Tudo acontece em milissegundos.

// Modo load(): execução única
import { DynamicWorkerLoader } from 'cloudflare:sandbox-sdk';

const loader = new DynamicWorkerLoader();

// Carrega código, vincula recursos e define limites
const dynamicWorker = await loader.load({
  code: aiGeneratedCode,  // string de código gerada pela IA
  bindings: {
    db: env.DB,           // binding do banco D1
    kv: env.KV,           // binding do KV Storage
  },
  limits: {
    cpuMs: 100,           // limite de CPU: 100 milissegundos
    memoryMB: 128,        // limite de memória: 128 MB
  }
});

// Executa o código e obtém o resultado
const result = await dynamicWorker.execute();

// Após a execução, o Isolate é destruído automaticamente
console.log(result);

Principais parâmetros:

• code: a string de código a executar, que pode ser gerada dinamicamente pela IA
• bindings: recursos externos vinculados, como banco de dados, storage e APIs
• limits: limites de execução para evitar abuso de recursos

Cenários ideais para load():

• Análise pontual de dados: o usuário envia um CSV, a IA gera código de análise, executa uma vez e destrói
• Execução temporária de código: scripts de transformação ou lógicas de validação geradas pela IA
• Isolamento por requisição: cada requisição tem seu próprio sandbox, sem risco de resíduo

get(): aquecimento em cache para ciclos de vida longos

O modo get() serve para cenários que precisam de estado aquecido. Depois de criado, o Isolate permanece em memória e chamadas posteriores reutilizam o ambiente diretamente.

// Modo get(): aquecimento em cache
const cachedWorker = await loader.get({
  id: 'persistent-analyzer',  // identificador fixo para localizar o cache
  code: analysisCode,         // código pré-carregado
  bindings: {
    vectorize: env.VECTORIZE, // binding do banco vetorial
  }
});

// Múltiplas chamadas preservam o estado aquecido
const result1 = await cachedWorker.execute({ input: data1 });
const result2 = await cachedWorker.execute({ input: data2 });
const result3 = await cachedWorker.execute({ input: data3 });

// Não é preciso destruir manualmente; a Cloudflare gerencia o ciclo de vida

Cenários ideais para get():

• Processamento em lote: a mesma lógica de análise aplicada a vários conjuntos de dados
• Agents de longa duração: tarefas de análise que precisam manter estado
• Aquecimento para reduzir latência: menor atraso na primeira execução útil

A diferença essencial entre os dois modos é esta: load() é como “alugar um quarto por uma noite e ir embora”; get() é como “alugar um quarto para estadia longa”. O primeiro combina com execução instantânea; o segundo, com cenários contínuos.

O tutorial AI Code Executor do Sandbox SDK oficial da Cloudflare traz exemplos mais completos. Vale ler este texto primeiro e depois partir para a prática.

As cinco camadas de defesa do Dynamic Workers

Como vimos, o nível de segurança básico dos V8 Isolates é só intermediário. Mas a Cloudflare sobrepôs várias defesas no Dynamic Workers e levou a segurança prática para um nível viável em produção.

Uma análise da InfoQ de abril de 2026 detalhou essas cinco camadas.

Primeira camada: distribuição automática de patches de segurança do V8

O motor V8 tem vulnerabilidades de segurança. Isso é inevitável em qualquer software complexo. Quando a equipe do Chrome encontra uma falha e publica um patch, a Cloudflare o distribui para todos os nós globais em poucas horas.

Compare com uma abordagem tradicional: patches de segurança em ambientes de contêiner dependem do sistema host, e o ciclo de atualização pode levar semanas ou até meses. A resposta a patches do V8 acontece em escala de horas, não de semanas.

Segunda camada: tenant cordoning dinâmico por risco

Se um Dynamic Worker apresenta comportamento anormal, como explosão de memória ou CPU disparada, a Cloudflare o marca como “alto risco” e o move para nós de isolamento específicos.

Isso é tenant cordoning: o tenant arriscado fica separado para não afetar outros Workers normais.

Terceira camada: proteção de hardware via MPK

MPK, ou Memory Protection Keys, é um mecanismo de isolamento de memória no nível do hardware Intel. Cada Isolate recebe permissões independentes de acesso à memória, e o hardware bloqueia acessos fora do limite.

É uma proteção física, mais difícil de quebrar que isolamento puramente por software.

Quarta camada: varredura de código

Antes da execução, o código é analisado. Padrões maliciosos, como loops infinitos, bombas de memória e chamadas a APIs sensíveis, são bloqueados automaticamente.

Essa camada mira código malicioso gerado por IA. Prompt injection pode levar a IA a gerar código perigoso; a varredura impede isso antes da execução.

Quinta camada: isolamento de rede

Por padrão, o Dynamic Worker bloqueia completamente acesso externo à rede. Quando precisa acessar uma API externa, o tráfego passa pelo egress proxy da Cloudflare, e o mecanismo de injeção de credenciais garante que o Worker só acesse APIs autorizadas.

Vultr - Servidor cloud NVMe de alto desempenho, 32 locais globais, deploy Docker com um clique

Ver preços →Anúncio

Um desenho simples da arquitetura de segurança:

Código gerado pela IA
     |
     v
+-------------------------------------------+
| Dynamic Worker (V8 Isolate)               |
| +---------------------------------------+ |
| | Primeira camada: varredura de código  | |
| +---------------------------------------+ |
| | Segunda camada: patches de segurança  | |
| | do V8                                 | |
| +---------------------------------------+ |
| | Terceira camada: tenant cordoning     | |
| +---------------------------------------+ |
| | Quarta camada: proteção de hardware   | |
| | via MPK                               | |
| +---------------------------------------+ |
|         |                                 |
|         v                                 |
|   Ponte Cap'n Web RPC                     |
|         |                                 |
|         v                                 |
|   Quinta camada: egress proxy com         |
|   injeção de credenciais                  |
+-------------------------------------------+

Essa defesa em camadas torna o nível “três estrelas” dos V8 Isolates confiável o bastante para produção. Não quer dizer segurança absoluta. Nenhum sistema é absolutamente seguro. Quer dizer que o risco chega a um patamar aceitável.

Preço do Dynamic Workers: por que um sandbox por requisição vira realidade

“Um sandbox por requisição” soa caro. Mas, no modelo de custo do Dynamic Workers, isso se torna viável.

Primeiro, a estrutura de preços da Cloudflare, gratuita durante o beta e com preço formal indicado assim:

• US$ 0,002 per unique Worker loaded per day: US$ 0,002 por dia para cada Worker independente
• Mais a taxa padrão de tempo de CPU: US$ 0,02 por milhão de milissegundos de CPU
• Mais a taxa de invocation: US$ 0,50 por milhão de requisições

Uma reportagem da VentureBeat de abril de 2026 trouxe a comparação: E2B, baseado em Firecracker microVM, custa US$ 0,01+ por requisição, enquanto Dynamic Workers fica em US$ 0,002.

Um comparativo concreto de custos:

Vamos fazer a conta: suponha 1 milhão de requisições por dia, cada uma executando um código diferente, ou seja, um unique Worker.

Solução com pool aquecido de contêineres:

• 100 contêineres aquecidos, cada um com 200 MB de memória: US$ 500/mês só em memória
• Manutenção da infraestrutura do pool: pelo menos US$ 1.500/mês em custo de equipe
• Custo total: US$ 2.000+, ainda com risco de segurança

Solução E2B:

• US$ 0,01 por requisição: 1 milhão de requisições = US$ 10.000/mês. Mas essa conta direta não considera descontos por volume.
• Na prática, o custo mensal fica em torno de US$ 1.000+, com latência de inicialização de 150 ms.

Solução Dynamic Workers:

• Taxa de unique Worker: 1 milhão * US$ 0,002 = US$ 2.000/mês. Também não é a conta correta, porque unique Worker é diário.
• Cálculo correto: suponha 1.000 unique Workers por dia. US$ 0,002 * 1.000 * 30 = US$ 60/mês.
• Somando invocation e tempo de CPU, o custo mensal fica por volta de US$ 200.

O insight importante é este: o preço do Dynamic Workers não é por “número de requisições”, e sim por “unique Worker”. Se o código executado pelo seu AI Agent é baseado em templates, como scripts fixos de análise, a quantidade de unique Workers fica muito menor que o número de requisições. O custo cai junto.

É por isso que “um sandbox por requisição” fica economicamente viável:

• Inicialização rápida, em milissegundos, sem pool aquecido
• Baixo uso de memória, em poucos MB, sem reserva grande
• Cobrança por unique Worker, não por requisição

Compare com as dores do modelo tradicional:

• Pool aquecido é complexo de manter e custa gente
• Reutilização de contêiner traz risco de segurança e exige limpeza extra
• Latência de 3 segundos afeta a experiência do usuário

Dynamic Workers resolve esses três pontos e ainda reduz custo. Agora a conta faz sentido.

Dynamic Workers vs E2B vs gVisor: como escolher

Depois de todas essas vantagens, vale deixar claro: Dynamic Workers não é solução universal. Cada cenário pede uma escolha diferente.

Comparação completa:

Quando escolher Dynamic Workers?

Cenários adequados:

• Seu AI Agent usa JavaScript ou TypeScript
• Execução instantânea e frequente, com isolamento independente por requisição
• Sensibilidade a custo e pouca vontade de manter infraestrutura de pool aquecido
• Stack já baseada em Cloudflare, como Workers, KV e D1

Cenários inadequados:

• O AI Agent precisa executar código Python, Rust ou Go
• O requisito de segurança é máximo, por exemplo em dados financeiros
• Você precisa de estado persistente sem configurar Durable Objects

Quando escolher E2B?

E2B usa Firecracker microVM, tem o maior nível de segurança e inicializa em cerca de 150 ms.

Cenários adequados:

• Necessidade de executar Python, como análise de dados ou machine learning
• Requisito de segurança no nível mais alto
• Aceitação de uma latência de inicialização de 150 ms
• Processamento de dados sensíveis, como finanças ou saúde

Quando escolher gVisor?

gVisor é um kernel em user space desenvolvido pelo Google, com boa compatibilidade com contêineres.

Railway - Plataforma de deploy moderna, sem ops complexas, no ar em minutos

Começar agora →Anúncio

Cenários adequados:

• Você precisa manter compatibilidade com contêineres e imagens Docker existentes
• Quer equilibrar segurança e desempenho
• Não quer trocar de stack, apenas subir o nível de segurança

Quando continuar usando Docker?

Sendo direto, Docker basta em muitos casos.

Cenários adequados:

• Não há necessidade de isolamento independente por requisição
• Serviços de longa duração, e não execução instantânea
• Infraestrutura de contêineres já madura
• Linguagem diferente de JS/TS

Escolha técnica não é sobre “qual é o melhor”, mas sobre “qual encaixa melhor”. Dynamic Workers tem vantagem clara em um cenário específico: AI Agents em JS/TS, execução instantânea frequente e sensibilidade a custo. Fora disso, não substitui tudo.

Ecossistema de Agents da Cloudflare: do sandbox ao estado persistente

Dynamic Workers não é um produto isolado. Ele faz parte do ecossistema de Agents da Cloudflare.

Em abril de 2026, a Cloudflare lançou o Project Think, um framework de orquestração para Agents de longa duração. Com Dynamic Workers e Durable Objects, ele forma uma stack completa para Agents.

Arquitetura em três camadas

Project Think (classe Think - orquestração de Agent)
     |
     +-- Agent Memory (banco SQL - estado persistente)
     |
     +-- Sub-agents (coordenação de sub-agents)
     |
     +-- Dynamic Workers (execução em sandbox)
     |     |
     |     +-- Durable Objects Facets (SQLite independente por sandbox)
     |
     +-- Tools (chamadas de API - injeção de credenciais via egress proxy)

Durable Objects Facets

Durable Objects Facets é um recurso lançado em abril de 2026. Cada Dynamic Worker pode ter seu próprio banco SQLite, com estado persistente que não é perdido quando o sandbox é destruído.

Isso resolve uma dor do Dynamic Workers: depois que o sandbox executa e é destruído, o estado não fica disponível. Facets dá a cada sandbox seu próprio “caderno”, permitindo consultar registros anteriores mesmo após a execução.

Project Think

Project Think é um framework de Agents que oferece a classe base Think. Você pode herdar essa classe e implementar sua própria lógica de Agent, incluindo coordenação de sub-agents, gerenciamento de estado e chamadas a tools.

O exemplo do blog oficial: um Agent de análise de dados usa Dynamic Workers para executar código de análise, Durable Objects Facets para armazenar resultados históricos e Project Think para coordenar vários sub-agents.

Agents SDK

A Cloudflare também fornece o Agents SDK, que encapsula a integração entre Dynamic Workers, Durable Objects e Project Think. Com o SDK, dá para montar rapidamente um AI Agent completo.

// Exemplo do Agents SDK
import { Agent } from 'cloudflare:agents-sdk';

class DataAnalysisAgent extends Agent {
  async analyze(data: string) {
    // Dynamic Workers executa o código de análise
    const worker = await this.sandbox.load({
      code: this.generateAnalysisCode(data),
      bindings: { db: this.memory }
    });

    const result = await worker.execute();

    // Salva o resultado em Facets
    await this.memory.save(result);

    return result;
  }
}

Esse ecossistema transforma Dynamic Workers de um “sandbox isolado” em parte de uma stack de Agents. Se o seu AI Agent precisa de estado persistente, coordenação de sub-agents e chamadas a tools, a solução completa da Cloudflare dá menos trabalho que costurar vários serviços separados.

Conclusão

Dynamic Workers não tenta substituir todos os modelos de sandbox. Ele oferece uma opção com ganho de desempenho de 100 vezes para cenários específicos.

O valor central é permitir que “um sandbox por requisição” passe de viável tecnicamente para viável economicamente.

Se o seu AI Agent usa JavaScript ou TypeScript, precisa oferecer um ambiente isolado para cada requisição de usuário e é sensível a custo, Dynamic Workers é hoje uma das escolhas mais adequadas.

Próximos passos:

• Acesse a documentação oficial do Cloudflare Dynamic Workers
• Use o tutorial AI Code Executor do Sandbox SDK para montar seu primeiro ambiente de sandbox
• Combine com Durable Objects Facets para implementar estado persistente
• Se o seu Agent precisa rodar por longos períodos e coordenar tarefas, explore o framework Project Think

No fim, escolha técnica é fazer a conta direito: velocidade de inicialização, custo de memória, nível de segurança e complexidade de manutenção. Dynamic Workers responde bem nessas quatro dimensões; o restante é avaliar se o seu cenário realmente combina com ele.