RLM - Recursive Language Models no OmniFlow

Sumario Executivo

Paper: "Recursive Language Models" (arXiv 2512.24601v1) Autores: Alex L. Zhang, Tim Kraska, Omar Khattab (MIT CSAIL)

Ideia Central

RLMs permitem que LLMs processem inputs de 10M+ tokens (duas ordens de magnitude alem da janela de contexto) tratando prompts como variaveis de ambiente em vez de inputs diretos.

Como Funciona

1. Documentos longos sao carregados como variaveis string em um ambiente Python REPL
2. O modelo examina e decompoe o conteudo programaticamente
3. O modelo invoca a si mesmo recursivamente em trechos menores
4. Permite manipulacao simbolica de strings arbitrariamente longas

Resultados Reportados

• 28.4% de melhoria no benchmark OOLONG
• 58% F1 no OOLONG-Pairs
• Custos comparaveis ou reduzidos vs baselines de sumarizacao
• Degradacao graceful em tarefas complexas (vs colapso de modelos base)

Limitacoes Identificadas

• Alta variancia nos custos de inferencia
• Sub-chamadas sincronas criam overhead
• Comportamento dependente do modelo (requer ajustes de prompt por provider)

---

Analise de Compatibilidade com OmniFlow

Pontos de Integracao Natural

Conceito RLM	Equivalente OmniFlow	Compatibilidade
Python REPL environment	Python Sandbox (python_sandbox_exec)	Excelente
Prompts como variaveis	inputs dict no contexto do sandbox	Excelente
Operacoes em strings	Modulos built-in (re, json, etc.)	Boa
Auto-invocacao recursiva	AI Tool com dual-mode	Boa
Composicao de output	ctx.set_result() para agregacao	Excelente
Chunking inteligente	Requer implementacao	Nova feature

Vantagens do OmniFlow para RLM

1. Python Sandbox ja existe - Ambiente REPL pronto
2. Execucao paralela - Ate 30 tools concorrentes (mitiga overhead de sub-calls)
3. Dual-mode tools - Ferramentas podem ser chamadas diretamente ou via sandbox
4. Multi-provider - Suporte a OpenAI, Anthropic, Gemini, Ollama
5. Observabilidade - Metricas e tracing ja implementados

---

Componentes Implementados

Fase 1: Infraestrutura Core

RLMConfig (omni_flow_engine/configs/rlm.py)

Schema Pydantic para configuracao RLM:

from omni_flow_engine.configs.rlm import RLMConfig

config = RLMConfig(
    max_total_tokens=500000,
    max_depth=3,
    default_chunk_strategy="semantic",
    max_parallel_invocations=5,
    token_budget_percentile=90,
    enable_trajectory_logging=True
)

RLMContextManager (omni_flow_engine/entities/ai_agent/rlm/context_manager.py)

Gerenciador de variaveis e chunks:

from omni_flow_engine.entities.ai_agent.rlm import RLMContextManager

ctx_mgr = RLMContextManager(config)

# Carregar documento
var_id = ctx_mgr.load_variable("document_content", source="file.txt")

# Criar chunks
chunks = ctx_mgr.chunk_variable(var_id, strategy="semantic", chunk_size=4000)

# Acessar variavel
content = ctx_mgr.get_variable(var_id)

CostTracker (omni_flow_engine/entities/ai_agent/rlm/cost_tracker.py)

Controle de orcamento de tokens:

from omni_flow_engine.entities.ai_agent.rlm import CostTracker

tracker = CostTracker(budget=500000)

# Registrar uso
tracker.record_usage(tokens_in=1000, tokens_out=500)

# Verificar orcamento
remaining = tracker.get_remaining_budget()
can_proceed = tracker.can_proceed(estimated_cost=2000)

Fase 2: Ferramentas de Chunking

rlm_load_var (omni_flow_engine/tools/rlm_tools/rlm_load_var_tool.py)

Carrega documentos como variaveis:

# Uso via sandbox
result = await ctx.call_tool("rlm_load_var",
    content="<documento longo>",
    name="doc1"
)
# Retorna: {"var_id": "doc1", "token_count": 15000, "char_count": 60000}

rlm_chunk (omni_flow_engine/tools/rlm_tools/rlm_chunk_tool.py)

Decompoe variaveis em chunks:

# Estrategias disponveis: fixed, semantic, regex, sliding
result = await ctx.call_tool("rlm_chunk",
    var_id="doc1",
    strategy="semantic",
    chunk_size=4000,
    overlap=200
)
# Retorna: {"chunks": [...], "total_chunks": 15, "strategy": "semantic"}

rlm_filter (omni_flow_engine/tools/rlm_tools/rlm_filter_tool.py)

Filtra conteudo com regex ou queries semanticas:

# Filtro por regex
result = await ctx.call_tool("rlm_filter",
    var_id="doc1",
    filter_type="regex",
    pattern=r"def \w+\("
)

# Filtro semantico
result = await ctx.call_tool("rlm_filter",
    var_id="doc1",
    filter_type="semantic",
    query="funcoes de autenticacao"
)

Fase 3: Invocacao Recursiva

rlm_invoke (omni_flow_engine/tools/rlm_tools/rlm_invoke_tool.py)

Auto-invocacao recursiva:

# Processar chunks em paralelo
result = await ctx.call_tool("rlm_invoke",
    prompt="Resuma este trecho",
    var_ids=["chunk_1", "chunk_2", "chunk_3"],
    parallel=True,
    max_depth=2
)

TrajectoryLogger (omni_flow_engine/entities/ai_agent/rlm/trajectory_logger.py)

Log do caminho de raciocinio:

from omni_flow_engine.entities.ai_agent.rlm import TrajectoryLogger

logger = TrajectoryLogger()
logger.log_step("load", {"var_id": "doc1", "tokens": 15000})
logger.log_step("chunk", {"chunks": 15, "strategy": "semantic"})
logger.log_step("invoke", {"depth": 1, "parallel": True})

trajectory = logger.get_trajectory()

Fase 4: Verificacao e Agregacao

rlm_verify (omni_flow_engine/tools/rlm_tools/rlm_verify_tool.py)

Verifica respostas contra fonte:

result = await ctx.call_tool("rlm_verify",
    answer="A funcao de login esta em auth.py",
    source_var_id="doc1",
    verification_type="factual"
)
# Retorna: {"verified": True, "confidence": 0.95, "evidence": [...]}

ResultAggregator (omni_flow_engine/entities/ai_agent/rlm/result_aggregator.py)

Estrategias de agregacao:

from omni_flow_engine.entities.ai_agent.rlm import ResultAggregator

aggregator = ResultAggregator()

# Concatenar resultados
final = aggregator.aggregate(results, strategy="concat")

# Votacao majoritaria
final = aggregator.aggregate(results, strategy="vote")

# Merge inteligente
final = aggregator.aggregate(results, strategy="merge")

---

Exemplo de Workflow com RLM

{
  "project_properties": {
    "name": "RLM Document Analysis",
    "flow_type": "orchestrator"
  },
  "nodes": [
    {
      "id": "rlm_agent",
      "type": "ai_agent",
      "provider": "anthropic",
      "model": "claude-sonnet-4-20250514",
      "use_python_sandbox": true,
      "rlm_enabled": true,
      "rlm_config": {
        "max_total_tokens": 500000,
        "max_depth": 3,
        "default_chunk_strategy": "semantic",
        "max_parallel_invocations": 5
      }
    }
  ]
}

---

Metricas e Observabilidade

Metricas Prometheus

Metrica	Tipo	Descricao
oktolabs_rlm_variables_loaded	Counter	Variaveis carregadas
oktolabs_rlm_chunks_created	Counter	Chunks criados
oktolabs_rlm_invoke_depth	Histogram	Profundidade de invocacoes
oktolabs_rlm_tokens_consumed	Counter	Tokens consumidos
oktolabs_rlm_trajectory_length	Histogram	Tamanho das trajetorias

Callbacks

Evento	Descricao
RLM_VAR_LOADED	Variavel carregada
RLM_CHUNKING_COMPLETE	Chunking finalizado
RLM_INVOKE_START	Inicio de invocacao recursiva
RLM_INVOKE_COMPLETE	Invocacao finalizada
RLM_BUDGET_WARNING	Orcamento proximo do limite

---

Riscos e Mitigacoes

Risco	Probabilidade	Mitigacao
Alta variancia de custos	Alta	CostTracker com budgets por percentil
Limites de API dos providers	Media	Rate limiting, retry com backoff
Problemas de memoria com vars grandes	Media	Lazy loading, streaming de chunks
Explosao de profundidade recursiva	Baixa	Limite hard de profundidade, monitoramento
Prompts nao funcionam em alguns modelos	Alta	Templates especificos por provider, testes

---

Referencias

• Paper: https://arxiv.org/abs/2512.24601
• Codigo fonte RLM: (pendente link do repositorio)
• Documentacao Python Sandbox: docs/PYTHON_SANDBOX.md
• Documentacao AI Agent: docs/AI_AGENT.md