💬 NLP

OpenForgeRL: Train Harness-native Agents in Any Environment

O OpenForgeRL é um framework de código aberto que permite o treinamento de ponta a ponta de agentes de IA nativos de harness em diversos ambientes ao desacoplar a inferência do treinamento por meio de um proxy leve e um orquestrador Kubernetes, alcançando desempenho de estado da arte em benchmarks complexos de ferramentas e GUI enquanto fornece insights sobre como as escolhas de harness e o aprendizado por reforço moldam o comportamento do agente.

Autores originais: Xiao Yu, Baolin Peng, Ruize Xu, Hao Zou, Qianhui Wu, Hao Cheng, Wenlin Yao, Nikhil Singh, Zhou Yu, Jianfeng Gao

Publicado 2026-08-10

📖 8 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Xiao Yu, Baolin Peng, Ruize Xu, Hao Zou, Qianhui Wu, Hao Cheng, Wenlin Yao, Nikhil Singh, Zhou Yu, Jianfeng Gao

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine um mundo onde os computadores não apenas respondem perguntas, mas realmente fazem coisas por você. Eles podem escrever código, reservar voos ou organizar seus arquivos digitais. Para fazer isso acontecer, cientistas construíram "agentes de IA" — programas inteligentes que podem pensar, planejar e usar ferramentas. Mas aqui está a parte complicada: esses agentes não trabalham no vácuo. Eles precisam de um "harness" (suporte/sistema de controle), que é como uma sala de controle complexa ou um cockpit especializado. Esse harness gerencia a memória do agente, conecta-o à internet e o ajuda a usar ferramentas como uma calculadora ou um navegador web. Pense no harness como o assento do piloto e no agente como o piloto; você não pode simplesmente treinar um piloto em um videogame e esperar que ele pilote um 747 real. O avião real tem botões específicos, protocolos de emergência e um layout de cockpit que o videogame nunca mostrou.

Por muito tempo, houve um grande problema: os "videogames" (ambientes de treinamento simples) não correspondiam aos "aviões reais" (os harnesses complexos usados no mundo real). Pesquisadores conseguiam treinar agentes facilmente, mas quando os colocavam nos harnesses reais e caóticos, os agentes ficavam confusos ou falhavam. Este artigo, intitulado "OpenForge RL", aborda exatamente esse descompasso. Ele introduz uma nova maneira de treinar pilotos digitais diretamente dentro dos cockpits reais que eles eventualmente voarão, usando um sistema que permite que eles pratiquem em milhares de "aviões" diferentes ao mesmo tempo sem derrubar toda a instalação de treinamento.

O Problema: Treinar em um Videogame vs. Voar o Avião Real

Imagine que você está tentando ensinar um robô a consertar um carro. Se você o treinar em um videogame simples onde o motor é apenas um botão vermelho e o pneu é um quadrado azul, o robô aprende a apertar o vermelho e pegar o azul. Mas quando você coloca esse robô em uma garagem real com um motor real, um pneu real e um milhão de outras ferramentas, ele trava. Ele não sabe como lidar com a complexidade real.

É isso que tem acontecido com os agentes de IA. Os agentes modernos são poderosos, mas dependem de "harnesses" sofisticados (como o Claude Code ou Codex) para gerenciar seus pensamentos e ferramentas. Esses harnesses são como o cockpit real: possuem memória de estado (lembrando o que aconteceu cinco passos atrás), fluxos de trabalho de múltiplos processos (executando várias coisas ao mesmo tempo) e conexões de ferramentas complexas. No entanto, as formas padrão pelas quais os pesquisadores treinam a IA (usando Aprendizado por Reforço) geralmente assumem um ambiente simples e plano. Eles tentam treinar o agente em uma versão simplificada do harness, o que cria um "descompasso entre treinamento e implantação". É como treinar um piloto em um simulador que não possui os freios de emergência reais e depois esperar que ele pouse um avião real quando os freios falharem.

A Solução: OpenForge RL (A Garagem na Nuvem)

Os autores deste artigo construíram o OpenForge RL, um framework que atua como uma enorme garagem baseada na nuvem. Em vez de tentar forçar o harness real e complexo para dentro de uma caixa de treinamento simples, o Opencede OpenForge RL faz o oposto: ele pega a caixa de treinamento e a envia para o harness real.

Veja como funciona, usando uma analogia lúdica:

Os Pods Remotos (A Garagem na Nuvem): Imagine que você tem uma frota de pequenas garagens autônomas na nuvem. Cada garagem é um container que contém um "harness" específico (como um modelo de carro específico). O OpenForge RL usa um "orquestrador Kubernetes" (pense nele como um gerente de garagem super eficiente) para levantar milhares dessas garagens remotas instantaneamente.
O Proxy (O Espelho de Duas Vias): Dentro de cada garagem, o agente de IA tenta resolver uma tarefa. Um "proxy leve" atua como um espelho de duas vias. Ele permite que o agente fale com o harness real e com o ambiente real (como um computador real ou navegador web), mas grava secretamente cada movimento, pensamento e clique de ferramenta.
O Ciclo de Treinamento: O proxy envia esses "registros de voo" gravados de volta para o cérebro de treinamento principal (que usa ferramentas padrão como o veRL). O cérebro aprende com esses registros do mundo real, atualiza o cérebro do agente e envia a nova versão de volta para as garagens remotas para tentar novamente.

A magia é que o treinamento acontece dentado no harness real, no ambiente real, mas o trabalho pesado de gerenciar todos esses ambientes diferentes é tratado pela nuvem. Isso significa que os pesquisadores podem treinar agentes em "ZeroClaw", "OpenClaw", "Codex" ou até mesmo agentes de GUI visual (agentes que usam mouse e teclado) todos de uma vez, sem precisar reescrever seu código de treinamento para cada nova ferramenta.

O Que Eles Descobriram: O Treinamento Real Funciona Melhor

A equipe testou este sistema com dois tipos de agentes: Agentes Claw (que usam texto e ferramentas para fazer coisas como pesquisar e-mails ou gerenciar arquivos) e Agentes GUI (que olham para uma tela e usam um mouse para clicar em botões em um navegador ou computador).

Eles treinaram esses agentes usando apenas algumas centenas a alguns milhares de tarefas — muito menos do que alguns modelos massivos que usam milhões. Os resultados foram impressionantes:

Para Agentes Claw: Seu modelo, OpenForge-Claw, obteve uma pontuação de 31.7 (pass@3) no benchmark ClawEval e 33.7 no QwenClawBench. Isso foi significativamente melhor do que outros modelos de código aberto de tamanho semelhante (cerca de 30 bilhões de parâmetros). De fato, teve um desempenho melhor do que alguns modelos que são várias vezes maiores.
Para Agentes GUI: O modelo deles, OpenForge-GUI, alcançou uma pontuação de 37.7 no OSWorld-Verified, 63.0 no Online-Mind2Web e 72.3 no WebVoyager. Isso é um grande feito porque as tarefas de GUI são incrivelmente difíceis; o agente tem que "ver" a tela e descobrir onde clicar. O OpenForge-GUI igualou ou até superou modelos muito maiores que haviam sido treinados com muito mais dados.

A Lição do "Harness": Nem Todos os Cockpits São Iguais

Uma das descobertas mais interessantes não foi apenas que o treinamento funcionou, mas como diferentes harnesses afetaram o aprendizado. Os autores testaram seus agentes em quatro harnesses diferentes: ReACT (um loop simples), ZeroClaw (leve), OpenClaw e Codex (muito complexo).

Eles descobriram que alguns harnesses são muito mais difíceis de aprender do que outros.

Harnesses mais simples e bem alinhados (como o ZeroClaw) permitiram que os agentes aprendessem mais rápido e tivessem um desempenho melhor.
Harnesses mais complexos (como o Codex) foram mais difíceis de dominar. Os agentes tiveram mais dificuldade e, embora o Aprendizado por Reforço (RL) tenha ajudado, os ganhos foram menores em comparação com os harnesses mais simples.

Isso sugere que o design do "cockpit" importa tanto quanto o treinamento do piloto. Um harness bem projetado torna o agente mais inteligente e confiável.

O Que o RL Realmente Ensinou aos Agentes

Os autores também observaram de perto o que os agentes realmente aprenderam quando adicionaram o Aprendizado por Reforço (RL) sobre o treinamento básico (SFT). Eles descobriram que o RL não apenas tornou os agentes "mais inteligentes" em um sentido geral; ele melhorou especificamente a confiabilidade:

Autoverificação: Os agentes começaram a verificar seu próprio trabalho. Por exemplo, se criassem um arquivo, eram mais propensos a lê-lo de volta para garantir que estava correto.
Cobertura de Ferramentas: Eles começaram a usar uma variedade maior de ferramentas em vez de se prenderem a apenas uma ou duas que conheciam bem.
Recuperação de Erros: Esta foi a parte difícil. Embora o RL tenha ajudado os agentes a se recuperarem de pequenos erros, a recuperação de erros permaneceu fraca. Mesmo após o treinamento, se um agente cometesse um erro grande, muitas vezes não conseguia corrigi-lo e simplesmente desistia. Os autores sugerem que essa habilidade específica pode precisar de dados especiais ou métodos de treinamento diferentes para ser dominada.

A Conclusão

O OpenForge RL prova que você não precisa simplificar o mundo real para treinar agentes de IA. Ao usar um sistema baseado em nuvem que desacopla o treinamento do ambiente, você pode treinar agentes diretamente nos harnesses complexos e reais que eles realmente usarão.

O artigo sugere que esta abordagem permite que pesquisadores construam agentes que não são apenas mais capazes, mas também mais confiáveis em seus trabalhos específicos. Embora os agentes ainda tenham dificuldades com a recuperação de erros complexos, a capacidade de treiná-los no "cockpit real" em vez de um "videogame" é um grande passo à frente. Isso significa que, no futuro, poderemos ver agentes de IA que estão verdadeiramente prontos para trabalhar ao nosso lado, não apenas em simulações, mas nas ferramentas digitais que usamos todos os dias.

Resumo Técnico: OPENFORGE RL

Declaração do Problema

Os agentes de IA modernos dependem cada vez mais de infraestruturas de inferência sofisticadas (ex: Claude Code, Codex, OpenClaw) para gerenciar o estado, o raciocínio de múltiplos turnos e o vínculo de contexto com sistemas externos. Embora essas infraestruturas aumentem significativamente o desempenho dos agentes, elas criam uma barreira crítica para a pesquisa de código aberto:

Desajuste Arquitetônico: As stacks de RL abertas existentes (ex: veRL, Slime) assumem rollouts simples de processo único. Elas não conseguem expressar nativamente a natureza de múltiplos processos e estados complexos que envolvem chamadas de ferramentas aninhadas e subagentes.
Incompatibilidade de Infraestrutura: Executar infraestruturas em escala requer ambientes dedicados e conteinerizados com recursos específicos de CPU/memória que não podem ser co-localizados nos nós de treinamento. A maioria das estruturas abertas assume que os rollouts ocorrem localmente dentro do treinador, impedindo o uso de ambientes de implantação do mundo real.
Lacuna Treinamento-Implantação: Consequentemente, a pesquisa aberta frequentemente reimplementa infraestruturas simplificadas para o treinamento, criando um desajuste entre as condições de treinamento e a implantação no mundo real, deixando os sistemas proprietários à frente da pesquisa aberta.

Metodologia: OPENFORGE RL

Para enfrentar esses desafios, os autores introduzem o OPENFORGE RL, uma estrutura de código aberto projetada para treinar agentes baseados em infraestrutura de ponta a ponta em qualquer ambiente, desacoplando o treinamento da inferência. O sistema consiste em dois componentes leves primários:

Proxy Leve e Reconstrução de Trajetória:
- Um servidor proxy envolve o servidor de inferência, interceptando todas as requisições de geração emitidas pelos containers da infraestrutura.
- Ele roteia essas requisições para motores de inferência de RL padrão (ex: vLLM) e registra os pares prompt-resposta.
- Ao completar o rollout, o proxy coleta a recompensa terminal e reconstrói a trajetória completa como uma amostra de treinamento padrão: $\tau = \{(s^H_0, a_0, r_0), \dots, (s^H_T, a_T, r_T)\}$ , onde $s^H$ representa a observação processada pela infraestrutura. Isso permite que qualquer infraestrutura execute sua própria inferência arbitrária enquanto alimenta bases de código de RL padrão como a veRL.
Orquestrador Kubernetes:
- Seguindo o design do Orchard (Peng et al., 2026), a estrutura utiliza um orquestrador Kubernetes para lançar cada rollout como um container remoto em provedores de nuvem (ex: Microsoft Azure).
- Isso permite o escalonamento elástico para milhares de ambientes simultâneos sem sobrecarregar os nós de treinamento.
- Mecanismos de Robustez: Para lidar com a falta de confiabilidade de rollouts remotos, o sistema implementa timeouts de tempo de relógio (terminando trabalhos não responsivos em vez de bloquear o lote) e estratégias de tratamento de erros (descartando trajetórias que falham devido a problemas de infraestrutura em vez de erros de política).
Pipeline de Síntese de Dados:
- Reconhecendo a escassez de tarefas prontas para RL em domínios não relacionados à codificação (ex: GUI, uso diário de ferramentas), os autores construíram um pipeline para sintetizar tarefas de SFT e RL.
- O pipeline imita a curadoria humana: agentes propõem candidatos a tarefas baseados em ativos de referência, eliminam duplicatas de baixa qualidade, constroem ambientes Docker executáveis com verificadores e refinam iterativamente as tarefas até que passem em verificações de ponta a ponta.

Principais Contribuições

Infraestrutura Escalável: O OPENFORGE RL é a primeira estrutura a parear flexivelmente qualquer infraestrutura de inferência com qualquer ambiente, conectando ecossistemas reais de infraestrutura e sandboxes remotas a poderosas bases de código de RL sem o desajuste treinamento-implantação.
Estudo Empírico Abrangente: Os autores treinaram e avaliaram agentes em diversos cenários:
- Agentes Claw (Texto/Uso de Ferramentas): Treinados em ReACT, ZeroClaw, OpenClaw e Codex.
- Agentes GUI (Computador/Uso de Navegador): Treinados em infraestruturas modificadas de Kimi-Agent e Molmo-Web.
Análise Comportamental: Viabilizada pelo treinamento em infraestruturas reais de implantação, o estudo analisa como a escolha da infraestrutura e o RL moldam o comportamento do agente, uma questão anteriormente difícil de ser abordada pela pesquisa aberta.

Resultados Experimentais

A estrutura foi validada em seis benchmarks nos domínios de uso de ferramentas e GUI.

Agentes Claw (OpenForge-Claw, 30B-A3B MoE):

ClawEval: Alcançou 31.7 (pass@3) e 55.9 (pass@3). Nota: O artigo reporta 31.7 como a pontuação pass@3 e 55.9 como a pontuação pass@3 para o OpenForge-Claw, enquanto o baseline Qwen3-32B alcançou 31.7 no pass@1.
QwenClawBench: Atingiu 33.7 (pass@1).
MCPAtlas: Alcançou 28.1 (pass@1).
Observação: O treinamento de RL (SFT+RL) proporcionou ganhos significativos sobre o SFT sozinho, particularmente em robustez e taxas médias de sucesso.

Agentes GUI (OpenForge-GUI, 8B):

OSWorld-Verified: 37.7 (pass@1).
Online-Mind2Web: 63.0 (pass@1).
WebVoyager: 72.3 (pass@1).
Comparação: Apesar de usar apenas ~2.5k tarefas (comparado a 200k+ para MolmoWeb), o OpenForge-GUI superou modelos especializados de tamanho similar (OpenCUA, UI-TARS) e igualou ou superou modelos várias vezes maiores.

Análise da Escolha de Infraestrutura e Impacto do RL

O artigo fornece insights específicos sobre como as infraestruturas e o RL afetam o comportamento do agente:

Dificuldade da Infraestrutura: Infraestruturas mais simples e melhor alinhadas (ex: ReACT, ZeroClaw) são mais fáceis de aprender e rendem maior desempenho do que infraestruturas de loop fechado mais complexas (ex: Codex), que exigem mais contexto e mostram menores ganhos de RL.
Generalização: Treinar em uma única infraestrutura generaliza para infraestruturas não vistas, mas treinar em múltiplas infraestruturas simultaneamente produz o melhor desempenho entre diferentes infraestruturas.
Capacidades de RL: O RL melhora significativamente a confiabilidade do agente, incluindo:
- Autoverificação: Agentes têm maior probabilidade de ler novamente suas próprias escritas para confirmar ações.
- Cobertura de Ferramentas: Agentes utilizam um conjunto mais amplo de ferramentas necessárias em vez de recorrer a shells genéricos.
- Recuperação de Erros: Embora o RL melhore a capacidade de recuperar de alguns erros, essa capacidade permanece fraca mesmo após o treinamento, sugerindo que pode exigir dados ou métodos dedicados além do RL padrão.

Significância

Os autores afirmam que o OPENFORGE RL reduz a barreira para treinar e estudar agentes nas exatas infraestruturas e ambientes onde são implantados. Ao permitir o treinamento de ponta a ponta com infraestrutura do mundo real, a estrutura permite que pesquisadores vão além de simulações simplificadas e investiguem diretamente como as arquiteturas de inferência e o aprendizado por reforço interagem para moldar as capacidades dos agentes. O lançamento do código, dados e modelos visa democratizar o acesso ao treinamento de agentes nativos de infraestrutura.