NVIDIA Lança Molt: Framework de RL Agentivo com 8.600 Linhas de Código, 7 Vezes Mais Enxuto que o Verl

Por que o Molt importa agora?

Treinar agentes de IA com reinforcement learning (RL) sempre foi um pesadelo de engenharia. Cada mudança no algoritmo — um novo estimador, um pipeline diferente, um esquema de rollout — exige alterações em camadas de trainer, backend distribuído e cola de código. A NVIDIA acaba de lançar o Molt, um framework de RL agentivo nativo em PyTorch com aproximadamente 8.600 linhas de código — sete vezes menor que o verl (62 mil linhas), o framework dominante na área. Para pesquisadores que passam mais tempo lutando com infraestrutura do que testando hipóteses, isso muda o jogo.

O que o Molt entrega

Desenvolvido pelo time NeMo da NVIDIA sob licença Apache 2.0, o Molt foi projetado com uma meta incomum: a base de código deve ser compacta o suficiente para um pesquisador manter na cabeça e para um assistente de código de IA ler e raciocinar por inteiro. As 8.600 linhas foram contadas traçando o grafo de importação a partir do ponto de entrada de RL de cada framework. O mesmo método conta ~62 mil linhas para o verl, ~25 mil para o slime e ~7.200 para o OpenRLHF.

✅ O que você ganha

• Código enxuto e navegável: ~8.600 linhas de RL core — 7× menor que o verl. Um pesquisador consegue ler o código-fonte inteiro em uma tarde
• Agentes como programas Python comuns: Você escreve uma classe Python que exporta um AgentRunner. O resto — reward, ambiente, lógica de rollout — é código Python normal
• SDK OpenAI/Anthropic nativo: Agentes que usam a API do Claude ou ChatGPT podem ser treinados com RL sem adaptação — o Molt abre um servidor loopback que traduz chamadas de API em acumulação token-exata
• Composição sem fork: Ray (orquestração), vLLM (rollout) e NVIDIA AutoModel + FSDP2 (treinamento) são integrados sem fork — atualizações upstream chegam como um pin de container
• Corretude em três invariantes: Identidade de token (IDs amostrados definem a trajetória, não uma re-transcrição), semântica de versão de política (log-probabilidades corrigidas por versão) e consistência forward (rollout e treinamento concordam na semântica do modelo)
• Escala via flag: O mesmo loop treina um modelo denso de 4B e um MoE de 700B — basta mudar --fsdp.ep_size 256

⚠️ O que você NÃO ganha

• Não é um serviço de treinamento em produção: O paper o posiciona como infraestrutura de pesquisa, não como plataforma gerenciada
• Hardware é a barreira real: As receitas publicadas assumem 2 nós com 8 H100 cada (16 GPUs no total), divididos entre treinamento (8) e rollout (8)
• MoE tem caveat: Políticas Mixture-of-Experts exigem “rollout routing replay” — o vLLM retorna os IDs de expert por token e o forward de treinamento os reproduz. Pequenas diferenças numéricas podem inverter escolhas de top-k sem essa correção

Três componentes, um loop

A arquitetura do Molt gira em torno de um pool de agentes, um conjunto de engines vLLM atrás de um roteador de requisições e um único ator de política treinável:

• Ray: Responsável por posicionamento e filas assíncronas entre componentes
• vLLM: Servidor de inferência que executa rollouts em paralelo. Um pool de streaming mantém grupos de prompts em voo para que os engines nunca drenem enquanto o ator treina
• NVIDIA AutoModel + FSDP2: Treinamento distribuído do ator. O Molt faz “partial rollout pause”: pausa os engines, transmite os shards do ator via NCCL diretamente para cada engine, e retoma as requisições mantidas em vez de descartá-las

O agente é um programa comum

Esta é a decisão de design mais radical do Molt. Em frameworks tradicionais, você define o agente dentro da DSL do framework — a lógica de reward, o loop de interação e a política são acoplados. No Molt, uma execução de RL referencia um módulo Python que exporta um AgentRunner. Duas formas são suportadas:

• Env: O framework controla o loop LLM via step() alinhado ao Gymnasium. Ideal para ambientes com estado bem definido.
• ChatAgent: Você controla o loop usando o SDK da OpenAI ou Anthropic. O Molt abre um servidor loopback que fala ambos os protocolos. Cada requisição decodifica server-side em uma acumulação token-exata. Quando um agente de horizonte longo compacta seu contexto e reescreve o prefixo, o servidor sela o segmento atual e abre um novo automaticamente.

Nunca treine em um token que você não gerou

O Molt organiza seu design em torno de três invariantes de corretude:

1. Identidade de token: Os IDs de token amostrados definem a trajetória, não uma re-transcrição do texto. Isso evita erros de discretização quando o mesmo texto pode ser tokenizado de formas diferentes em rollout e treinamento.
2. Semântica de versão de política: Tokens treináveis mantêm suas log-probabilidades da política de comportamento (behavior policy), e o uso assíncrono é corrigido por token atrás de um gate em nível de sequência. Essencial para treinamento off-policy correto.
3. Consistência forward: Rollout e ator precisam concordar na semântica do modelo. Para políticas MoE, o Molt aplica rollout routing replay: o vLLM retorna os IDs de expert por token, e o forward de treinamento os reproduz exatamente.

Quem pode usar

O requisito de hardware (16 H100) coloca o Molt ao alcance de:

• Laboratórios de fronteira e fronteira-adjacente (frontier labs)
• Startups de IA bem financiadas fazendo pós-treinamento
• Grupos empresariais de pesquisa em IA (finanças, saúde, robótica) treinando agentes contra ambientes proprietários
• Laboratórios acadêmicos com acesso a clusters multi-node H100/H200

As aplicações incluem agentes multi-turno com uso de ferramentas, agentes de execução de código, ambientes de visão-linguagem (o recipe geo3k já incluso), loops de reward com LLM como juiz, e destilação on-policy para um modelo menor (student).

O que isso significa para o ecossistema de RL agentivo

O Molt chega num momento em que o RL agentivo — treinar LLMs para usar ferramentas, executar código e raciocinar em múltiplos passos — está se tornando o principal diferenciador competitivo entre modelos. OpenAI, Anthropic, Google e DeepSeek investem pesadamente nessa área. Um framework Apache 2.0 com 8.600 linhas que iguala o throughput de stacks baseadas em Megatron reduz a barreira de entrada para laboratórios menores e grupos de pesquisa acadêmica.

A escolha de não forkear Ray, vLLM ou AutoModel é estratégica: em vez de criar outro ecossistema fragmentado, o Molt se beneficia de melhorias upstream sem custo de rebase. Quando o vLLM ganha suporte a um novo modelo ou otimização de inferência, o Molt herda automaticamente na próxima atualização de container.

Comece agora

O Molt está disponível no GitHub em NVIDIA-NeMo/labs-molt com licença Apache 2.0, scripts de lançamento, receitas Slurm e container pré-construído. O artigo técnico está no arXiv (2607.21653) com um explicador interativo que detalha o loop de treinamento, identidade de token e knobs de escala com números reais do paper.