Como Gerar Vídeos em Paralelo com Swarm de Agentes IA

# Como Gerar Vídeos em Paralelo com Swarm de Agentes IA

Na Stream 8, Laschuk fez algo que parecia impossível em tempo real: lançou quatro agentes de IA simultaneamente, cada um escrevendo um roteiro diferente, e os quatro vídeos foram renderizados ao mesmo tempo — tudo enquanto ele explicava o processo ao vivo.

Isso é o que um swarm de agentes faz por você. Em vez de gerar um vídeo, esperar terminar, ajustar, gerar outro — você lança todos de uma vez e vai tomar um café.

Este guia mostra como replicar exatamente esse pipeline.

O Que É um Swarm de Agentes?

Um swarm (enxame) é um grupo de agentes de IA trabalhando em paralelo, cada um com uma tarefa independente. Eles não se falam, não esperam um pelo outro — simplesmente executam ao mesmo tempo.

Para geração de vídeos, cada agente do swarm recebe: - Um prompt descrevendo o vídeo que deve criar - Acesso às mesmas ferramentas (Remotion, sistema de arquivos, modelo de IA) - Um identificador único para não sobrescrever o trabalho dos outros

O resultado: N vídeos rodando em N processos simultâneos. Se cada render leva 3 minutos, com swarm você gera 4 vídeos em 3 minutos — não em 12.

Na Stream 7, o Laschuk construiu a base do pipeline com Remotion, gerando o primeiro vídeo de produto com IA. Na Stream 8, ele escalou esse mesmo pipeline para rodar em swarm.

O Que Você Precisa

Antes de lançar o swarm, seu ambiente precisa estar preparado:

Ferramentas base: - Node.js 18+ instalado - Remotion configurado no projeto (ver guia de Remotion) - API da Anthropic ou OpenAI com créditos disponíveis - Claude Code (ou qualquer agente que suporte múltiplas instâncias)

Estrutura de projeto: %%CODEBLOCK_0%%

Modelo recomendado: Claude Sonnet (mais barato que Opus, mais rápido, qualidade suficiente para roteiros de vídeo). Na Stream 8, Laschuk usou Sonnet para todos os 4 agentes — custo total foi inferior a R$ 2,00 para a sessão completa.

Passo 1: Preparar o Pipeline de Vídeo

O pipeline de cada agente é sempre o mesmo, em sequência:

A chave para o swarm funcionar é que cada etapa seja idempotente e use caminhos únicos. Se dois agentes rodarem ao mesmo tempo e gravarem no mesmo arquivo, você perde um vídeo.

typescript// Cada agente recebe um ID único na inicialização
const agentId = `agent_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`
const outputPath = `renders/${agentId}.mp4`
const scriptPath = `scripts/${agentId}.json`

Configure seu componente Remotion para aceitar props dinâmicas — assim o mesmo template serve para todos os vídeos do swarm, só mudando o conteúdo.

Passo 2: Definir os Prompts de Cada Vídeo

Cada agente precisa de um prompt claro e diferente. Na Stream 8, os quatro prompts eram variações de estilo narrativo para o mesmo produto.

Exemplos de prompts que funcionaram bem:

Prompt 1: "Crie um vídeo estilo trailer de cinema para EmailHacker.ai. 
Tom: urgente, épico. Duração: 60 segundos. 5 cenas."

Prompt 2: "Crie um vídeo tutorial passo a passo mostrando como 
configurar o primeiro funil em 3 cliques. Tom: didático, calmo."

Prompt 3: "Crie um vídeo de prova social com depoimentos fictícios 
de gestores que economizaram 10h/semana. Tom: confiante."

Prompt 4: "Crie um vídeo explicando o conceito de email marketing 
autônomo com metáfora visual. Tom: criativo, inteligente."

Cada prompt define: o que mostrar, o tom, e a duração. Quanto mais específico, melhor o resultado — a IA não precisa adivinhar.

Salve cada prompt em um arquivo separado em prompts/video_1.txt, prompts/video_2.txt, etc. O orquestrador do swarm vai carregar esses arquivos e distribuir para os agentes.

Passo 3: Lançar o Swarm (Agentes Paralelos)

Este é o momento central. O orquestrador lança todos os agentes ao mesmo tempo usando Promise.all:

typescriptimport { readdir, readFile } from "fs/promises"
import { generateScript } from "./lib/ai-script-generator"
import { renderVideo } from "./lib/remotion-renderer"

async function launchSwarm() {
  // Carrega todos os prompts da pasta
  const promptFiles = await readdir("./prompts")
  
  console.log(`Lançando swarm com ${promptFiles.length} agentes...`)
  
  // Lança todos em paralelo — sem await individual
  const results = await Promise.all(
    promptFiles.map(async (file, index) => {
      const agentId = `agent_${index + 1}`
      const prompt = await readFile(`./prompts/${file}`, "utf-8")
      
      console.log(`[${agentId}] Iniciando...`)
      
      try {
        // 1. IA gera o roteiro
        const script = await generateScript(prompt, agentId)
        console.log(`[${agentId}] Roteiro pronto (${script.scenes.length} cenas)`)
        
        // 2. Remotion renderiza o vídeo
        const outputPath = await renderVideo(script, agentId)
        console.log(`[${agentId}] Vídeo renderizado: ${outputPath}`)
        
        return { agentId, status: "success", outputPath }
      } catch (error) {
        console.error(`[${agentId}] Falhou:`, error)
        return { agentId, status: "error", error }
      }
    })
  )
  
  const successful = results.filter(r => r.status === "success")
  console.log(`Swarm concluído: ${successful.length}/${results.length} vídeos prontos`)
  return results
}

launchSwarm()

O segredo está no Promise.all — ele não espera um agente terminar para lançar o próximo. Todos rodam ao mesmo tempo, e o código só avança quando o último terminar.

Passo 4: Monitorar e Coletar os Renders

Com o swarm rodando, você vai ver logs de múltiplos agentes se intercalando no terminal:

[agent_1] Iniciando...
[agent_2] Iniciando...
[agent_3] Iniciando...
[agent_4] Iniciando...
[agent_2] Roteiro pronto (5 cenas)
[agent_1] Roteiro pronto (7 cenas)
[agent_4] Vídeo renderizado: renders/agent_4.mp4
[agent_3] Roteiro pronto (4 cenas)
[agent_2] Vídeo renderizado: renders/agent_2.mp4
...
Swarm concluído: 4/4 vídeos prontos

Isso é normal e esperado — os agentes avançam em ritmos diferentes dependendo do tamanho do roteiro e do tempo de render.

Para monitorar em tempo real, adicione timestamps a cada log:

typescriptconst log = (agentId: string, msg: string) => {
  const time = new Date().toLocaleTimeString("pt-BR")
  console.log(`[${time}] [${agentId}] ${msg}`)
}

Ao final, os vídeos estarão em renders/ prontos para revisar. Nenhum pós-processamento necessário — cada agente já entregou o MP4 final.

Caso Real: O Filme do John Wick por IA

Na Stream 8, o exemplo mais impressionante do swarm foi o vídeo "John Wick" — um curta-metragem narrativo completo gerado 100% por IA.

O prompt era simples: "Crie um vídeo estilo John Wick com narração épica, contador de mortes, efeitos sonoros e cenas de ação descritas em texto."

O que a IA entregou: - 7 cenas com descrições visuais detalhadas - Narração no tom grave e cinematográfico do personagem - Contador de mortes animado aparecendo a cada sequência - Sound effects referenciados (tiro, silêncio, música de tensão) - Transições entre cenas com timing definido

Todo o roteiro foi gerado em menos de 30 segundos. O Remotion renderizou o vídeo em cerca de 2 minutos. O resultado foi assistido ao vivo por centenas de pessoas na stream — e a reação foi de surpresa genuína.

O ponto não é o John Wick em si. É que qualquer narrativa pode ser gerada assim: apresentação de produto, case de cliente, tutorial animado, teaser de evento. O swarm simplesmente multiplica essa capacidade por N.

Escalando: De 4 para 100 Vídeos

O pipeline que você montou nos passos anteriores escala sem mudança de arquitetura. Você só precisa:

1. Mais prompts → mais vídeos Adicione arquivos em prompts/ e o swarm lança um agente para cada um. De 4 para 20 é só copiar arquivos.

2. Rate limiting para não estourar API Com 50+ vídeos simultâneos, você pode atingir o limite de tokens por minuto da API de IA. Adicione um semáforo:

typescriptimport PQueue from "p-queue"

// Máximo 10 chamadas de IA simultâneas
const queue = new PQueue({ concurrency: 10 })

const results = await Promise.all(
  promptFiles.map(file => 
    queue.add(() => processVideo(file))
  )
)

3. Workers distribuídos para renders pesados O render do Remotion é CPU-intensivo. Para 100 vídeos, considere distribuir em múltiplas máquinas usando uma fila de jobs (BullMQ + Redis):

Orquestrador → fila de jobs → 5 workers → renders paralelos

4. Custo estimado Cada vídeo com Claude Sonnet custa aproximadamente R$ 0,20–0,50 em tokens (dependendo do tamanho do roteiro). Para 100 vídeos: R$ 20–50. O render do Remotion é gratuito (CPU local ou servidor próprio).

Na Stream 8, 4 vídeos custaram menos de R$ 2,00 no total — incluindo o John Wick completo.

Próximo Passo

Você tem o pipeline. Tem o swarm. O que fazer agora?

Opção 1 — Vídeos de produto para email marketing Gere variações A/B de vídeos para suas campanhas. Testa 4 ângulos diferentes do mesmo produto, vê qual converte mais, escala o vencedor.

Opção 2 — Série de conteúdo automatizada Crie 10 vídeos educativos de uma vez, cada um cobrindo um tópico diferente da sua área. Uma tarde de setup, semanas de conteúdo pronto.

Opção 3 — Personalização em escala Gere vídeos personalizados por segmento de lista: um para iniciantes, um para avançados, um para quem já comprou. Swarm lança os três ao mesmo tempo.

Acompanhe as próximas streams em /streams — o pipeline está evoluindo a cada live. E se quiser tirar dúvidas ou mostrar o que você construiu, entre no Discord.

Erros Comuns

Agentes sobrescrevendo arquivos um do outro Sempre use caminhos únicos por agente. Nunca output.mp4 fixo — sempre output_${agentId}.mp4.

Swarm travando sem mensagem de erro Um agente pode travar em silêncio se a API de IA não responder. Adicione timeout: %%CODEBLOCK_8%%

Render falhando por memória insuficiente Com muitos renders simultâneos, o processo pode estourar RAM. Limite os renders paralelos com concurrency: 2 no PQueue para o passo de render (mesmo que a geração de roteiros rode com concorrência maior).

Custo explodindo sem querer Defina um limite máximo de tokens por agente no prompt do sistema. Roteiros de 500 palavras são suficientes para vídeos de 60–90 segundos — não precisa de 3.000 palavras.

Vídeos todos parecendo iguais Se os prompts são muito genéricos, a IA tende a gerar conteúdo similar. Seja específico: defina tom, personagem, estrutura narrativa e restrições únicas para cada prompt.

Veja o pipeline completo em ação na Stream 8 e continue o aprendizado com o guia de Remotion para entender como estruturar os templates de vídeo que o swarm vai preencher.