Resumo Técnico: ROMA (Recursive Open Meta-Agent Framework)

1. O Problema

Os sistemas de agentes baseados em Grandes Modelos de Linguagem (LLMs) enfrentam desafios significativos ao lidar com tarefas de longo horizonte (long-horizon tasks), como geração de código complexa, pesquisa aberta e escrita narrativa extensa. Os principais gargalos identificados são:

• Fragilidade na Orquestração Sequencial: À medida que a profundidade do raciocínio aumenta, a orquestração sequencial torna-se frágil e difícil de manter.
• Limitações de Janela de Contexto: O acúmulo de histórico de execução, ferramentas e raciocínio intermediário excede os limites de contexto dos modelos, degradando o desempenho (fenômeno conhecido como "context rot" ou apodrecimento de contexto).
• Rastros de Execução Opacos: Falhas em sistemas complexos são difíceis de localizar e depurar devido à falta de transparência nas decisões de planejamento e agregação.
• Falta de Padronização: A maioria dos frameworks é construída de maneira ad hoc, com fluxos de controle e padrões de comunicação específicos de cada tarefa, dificultando a reutilização, comparação e transferência de conhecimento entre domínios.

2. Metodologia: A Arquitetura ROMA

O ROMA (Recursive Open Meta-Agents) é um framework agnóstico de domínio projetado para superar essas limitações através de uma estrutura recursiva e modular. Em vez de depender de um único modelo para tudo, o ROMA divide o problema em uma árvore de tarefas hierárquica.

2.1 O Loop de Controle Recursivo

O núcleo do ROMA é um loop de controle uniforme aplicado recursivamente a cada nó na árvore de tarefas, composto por quatro papéis modulares distintos:

1. Atomizer (Atomizador): Decide se uma tarefa atual é atômica (pode ser resolvida diretamente) ou não atômica (requer decomposição).
   • Decisão: Se atômica, passa para o Executor. Se não, passa para o Planner.
2. Planner (Planejador): Decompõe tarefas não atômicas em um grafo de subtarefas MECE (Mutually Exclusive and Collectively Exhaustive - Excludentes e Coletivamente Exaustivas).
   • O grafo é um DAG (Grafo Acíclico Direcionado) que define dependências explícitas entre subtarefas, permitindo execução paralela onde possível.
3. Executor (Executor): Executa tarefas atômicas.
   • Suporta diferentes tipos de tarefas: Search (busca), Think (raciocínio), Write (composição) e Code (manipulação de código).
   • Opera em contexto localizado, evitando o acúmulo desnecessário de dados.
4. Aggregator (Agregador): Sintetiza, verifica e comprime as saídas de todas as subtarefas filhas completas.
   • Gera um artefato consolidado para o nó pai, em vez de apenas concatenar resultados brutos. Isso controla o crescimento do contexto e mitiga a propagação de erros.

2.2 Fluxo de Execução

• Top-Down (Planejamento): A tarefa raiz é decomposta recursivamente até que todas as folhas sejam tarefas atômicas.
• Paralelismo: Subtarefas sem dependências mútuas são executadas em paralelo.
• Bottom-Up (Agregação): Os resultados são combinados de baixo para cima. O Aggregator comprime informações intermediárias, permitindo que o sistema lide com tarefas que excedem a janela de contexto de um único modelo.

2.3 GEPA+: Otimização de Prompts Multi-Componente

Para adaptar o ROMA a tarefas específicas sem fine-tuning, os autores introduzem o GEPA+, uma extensão do método GEPA (Genetic-Evolution Prompt Adaptation).

• Otimização Conjunta: Diferente do GEPA clássico que otimiza um único módulo, o GEPA+ otimiza simultaneamente os prompts do Atomizer, Planner, Executors e Aggregator.
• Mecanismo: Gera múltiplas edições de prompts em paralelo (diversidade), reclassifica-as usando juízes (LLMs) e verificadores (testes unitários/contratos de interface), e funde as melhores ideias em uma única atualização segura.
• Eficiência: Reduz o número de avaliações de métricas necessárias em 3-4x em comparação com o GEPA padrão, mantendo a estabilidade das interfaces entre os módulos.

3. Principais Contribuições

1. ROMA (Framework): Uma arquitetura de meta-agente escalável e agnóstica de domínio baseada em um loop de controle recursivo fixo com quatro papéis definidos. Resolve problemas de orquestração ad hoc, execução opaca e crescimento descontrolado de contexto.
2. GEPA+: Um método de otimização de prompts estruturado para arquiteturas modulares, permitindo adaptação eficiente de tarefas sem necessidade de re-treinamento do modelo base.
3. Desempenho Empírico Líder: Demonstração de que arquiteturas modulares e recursivas podem escalar a profundidade do raciocínio e superar modelos fechados e agentes especializados em benchmarks complexos.

4. Resultados Experimentais

O ROMA foi avaliado em diversos benchmarks de raciocínio e geração de texto longo:

• SEAL-0 (Raciocínio sobre evidências conflitantes):

  • O ROMA (com base GLM-4.6) alcançou 45,9% de precisão.
  • Superou o Kimi-Researcher (agente de pesquisa de RL) em 9,9 pontos percentuais (36,0%) e o Perplexity Deep Research em 14,4 pontos.
  • Insight: A decomposição recursiva isola evidências conflitantes em subtarefas focadas, reduzindo a acumulação de erros.

• FRAMES (Raciocínio Multi-hop):

  • Alcançou 82,3% de precisão, superando todos os baselines (abertos e fechados).
  • O modelo manteve a coerência através de múltiplos passos de raciocínio, superando modelos gerais como DeepSeek-R1 e Llama-3.1-70B.

• EQ-Bench (Escrita de Longo Prazo):

  • O ROMA com DeepSeek-V3 e otimização GEPA+ alcançou 79,8%, igualando o desempenho de modelos fechados de ponta como o Claude Sonnet 4.5.
  • A otimização de prompts melhorou significativamente o planejamento de estrutura narrativa e a consistência dos personagens.

• AbGen (Design de Estudos de Ablação Científica):

  • O ROMA obteve as melhores pontuações em Importância, Solidez e Qualidade Geral, demonstrando capacidade de raciocínio científico complexo e estruturado.

5. Significância e Conclusão

O trabalho ROMA representa um avanço fundamental na engenharia de sistemas de agentes:

• Interpretabilidade: Ao padronizar a decomposição e agregação, o ROMA gera rastros de execução hierárquicos e transparentes, facilitando a depuração de falhas em sistemas complexos.
• Escalabilidade de Contexto: A estratégia de compressão recursiva permite que o sistema opere além das limitações de janela de contexto de modelos individuais, tornando-o viável para tarefas de longo prazo.
• Flexibilidade e Heterogeneidade: O framework permite a atribuição dinâmica de diferentes modelos e ferramentas para diferentes papéis (ex: um modelo barato para busca, um modelo avançado para raciocínio), otimizando custo e latência.
• Generalização: A abordagem não depende de fine-tuning específico de domínio, mas sim de uma estrutura de controle robusta e prompts otimizados, permitindo que sistemas de código aberto (como DeepSeek e GLM) rivalizem com sistemas proprietários fechados.

Em suma, o ROMA demonstra que arquiteturas de agentes recursivas e modulares oferecem uma base principial e prática para construir sistemas de IA interpretáveis, flexíveis e escaláveis, capazes de resolver problemas complexos que modelos de "caixa preta" ou orquestração simples não conseguem abordar eficazmente.