OpenSage: Self-programming Agent Generation Engine

O artigo apresenta o OpenSage, o primeiro kit de desenvolvimento de agentes (ADK) que permite que modelos de linguagem generem automaticamente sua própria topologia e conjuntos de ferramentas com suporte a memória estruturada, superando as limitações dos sistemas atuais dependentes de design manual e demonstrando desempenho superior em benchmarks de ponta.

O essencial

Imagine que, até hoje, criar um "agente de IA" (um robô inteligente que faz tarefas para você) era como montar um quebra-cabeça complexo onde você precisava desenhar cada peça, decidir onde ela encaixa e criar as ferramentas que ela usaria. Se você queria um robô que consertasse computadores, você tinha que manualmente programar como ele se conectava a outros robôs, quais chaves de fenda ele tinha e como ele lembrava do que fez ontem.

O OpenSage é como uma nova fábrica de robôs que mudou completamente essa regra. Em vez de você ser o engenheiro que desenha tudo, o OpenSage dá ao próprio robô (a Inteligência Artificial) a capacidade de se programar e se organizar.

Aqui está uma explicação simples, usando analogias do dia a dia:

1. O Problema: A Fábrica de Robôs Antiga

Antes, as ferramentas de criação de agentes (chamadas ADKs) eram como um kit de ferramentas manual.

• O Arquiteto (Humano): Você tinha que desenhar a estrutura da equipe. "Robô A fala com Robô B".
• As Ferramentas: Você tinha que comprar e instalar as ferramentas. Se o robô precisasse de uma furadeira nova, você tinha que ir à loja, comprar e ensinar ele a usar.
• A Memória: Era como um caderno de anotações linear. Se o robô fizesse 100 tarefas, o caderno ficava gigante e difícil de ler.

Isso limitava muito o robô. Se a tarefa mudasse, você tinha que reescrever o código manualmente. Era lento e exigia muito conhecimento técnico.

2. A Solução: O OpenSage (O "Gerente de Robôs" Autônomo)

O OpenSage é como dar um kit de construção de Lego infinito e inteligente para o robô. Agora, o robô pode:

A. Criar sua Própria Equipe (Topologia Auto-gerada)

Imagine que você pede a um gerente de projeto para resolver um problema gigante.

• No modelo antigo: O gerente tinha que usar a mesma equipe de sempre, mesmo que não fosse a melhor para aquela tarefa específica.
• Com o OpenSage: O gerente (a IA) olha para o problema e diz: "Preciso de um especialista em segurança para esta parte e um especialista em código para aquela". Ele cria instantaneamente novos robôs (sub-agentes) para essas tarefas específicas e os organiza em uma equipe.
  • Analogia: É como se você pedisse para um cozinheiro fazer um banquete. Em vez de ele tentar fazer tudo sozinho, ele contrata instantaneamente um padeiro, um açougueiro e um sobremesista, coordena eles e depois junta o resultado.

B. Inventar suas Próprias Ferramentas (Síntese Dinâmica de Ferramentas)

Imagine que você está em uma oficina e precisa de uma chave de fenda que nunca existiu antes.

• No modelo antigo: Você ficava preso às ferramentas que já tinha na caixa.
• Com o OpenSage: Se o robô precisa de uma ferramenta específica para uma tarefa, ele escreve o código dessa ferramenta na hora, a cria e a usa.
  • Analogia: É como se o robô tivesse uma impressora 3D mágica. Se ele precisa de uma chave para um parafuso estranho, ele projeta e imprime a chave, usa-a e depois descarta ou guarda para outra vez. O OpenSage também cria "salas de isolamento" (sandbox) para que essas novas ferramentas não quebrem o computador do robô.

C. Uma Memória que se Organiza Sozinha (Memória Hierárquica)

Imagine tentar lembrar de tudo o que aconteceu em um ano de trabalho apenas lendo um diário de 500 páginas. É impossível.

• No modelo antigo: O robô tentava guardar tudo em uma lista longa, o que confundia a IA.
• Com o OpenSage: O robô tem um bibliotecário inteligente (um agente de memória).
  • Ele não guarda tudo em uma lista. Ele organiza as informações como um mapa de conexões (um gráfico). Se você pergunta sobre um projeto, o bibliotecário sabe exatamente onde está a informação, quem trabalhou nela e como ela se conecta a outras coisas.
  • Ele separa o que é "agora" (memória de curto prazo) do que é "conhecimento geral" (memória de longo prazo), garantindo que o robô não esqueça o que aprendeu no passado, mas também não fique sobrecarregado com detalhes inúteis.

3. O Resultado: Por que isso é incrível?

Os autores testaram o OpenSage em três desafios muito difíceis (como consertar bugs em softwares complexos e resolver problemas de segurança cibernética).

• O Resultado: Os robôs feitos com OpenSage venceram os robôs feitos com as melhores ferramentas atuais (como as da Google, OpenAI e Anthropic).
• O Segredo: Eles venceram porque conseguiram se adaptar. Se a tarefa era difícil, eles criavam mais ajudantes. Se precisavam de uma ferramenta nova, eles a criavam. Se precisavam lembrar de algo, o bibliotecário ia buscar.

Resumo Final

O OpenSage muda o jogo de "Humanos programando Robôs" para "Robôs programando a si mesmos".

É a diferença entre você ter que montar um carro peça por peça com um manual, e ter um carro que, ao ver uma estrada de terra, decide sozinho montar rodas de trator e um sistema de suspensão reforçado para passar pelo terreno.

Isso abre caminho para uma nova era onde a Inteligência Artificial não apenas segue ordens, mas projeta sua própria estrutura de trabalho para resolver problemas complexos de forma mais eficiente, barata e inteligente.

Resumo técnico

1. O Problema

Os Agent Development Kits (ADKs) atuais (como LangChain, OpenHands, Google ADK, etc.) fornecem plataformas para construir agentes de IA, mas apresentam limitações críticas:

• Paradigma Centrado no Humano: A topologia do agente (estrutura e interações), as ferramentas e os sistemas de memória devem ser projetados manualmente por especialistas humanos. Isso exige grande esforço e limita a escalabilidade.
• Falta de Adaptabilidade Dinâmica: As estruturas de agentes são estáticas. Um agente "pai" só pode atribuir tarefas a sub-agentes pré-definidos, e as ferramentas são limitadas a um conjunto fixo, o que restringe o espaço de ação e a capacidade de generalização para tarefas complexas.
• Gestão de Memória Ineficiente: Os sistemas existentes geralmente dependem de listas lineares ou embeddings simples, sem uma gestão estruturada que permita ao próprio agente decidir o que persistir ou como recuperar conhecimento de longo prazo de forma eficiente.

O artigo propõe que a próxima geração de desenvolvimento de agentes deve mudar de um paradigma centrado no humano para um centrado na IA, onde o próprio sistema de IA constrói e gerencia sua arquitetura.

2. Metodologia: OpenSage

O OpenSage é o primeiro ADK projetado para permitir que Grandes Modelos de Linguagem (LLMs) criem agentes com topologia, ferramentas e memória geradas automaticamente. O sistema é composto por três pilares técnicos principais:

A. Topologia de Agente Auto-gerada

• Criação Dinâmica: O agente principal pode criar instâncias de sub-agentes em tempo de execução, especificando metadados (modelo, instruções, ferramentas).
• Gerenciamento de Pool: Todos os sub-agentes são gerenciados em um "pool" unificado, permitindo reutilização, busca e clonagem para execução paralela.
• Topologias Flexíveis:
  • Vertical: Decomposição de tarefas complexas em subtarefas sequenciais executadas por sub-agentes especializados.
  • Horizontal (Ensemble): Múltiplos sub-agentes executam a mesma tarefa com planos distintos, cujos resultados são integrados posteriormente.
• Comunicação: Mecanismos para sincronização entre sub-agentes paralelos através de quadros de mensagens compartilhados.

B. Síntese e Gestão Dinâmica de Ferramentas

• Criação de Ferramentas: O agente pode escrever novas ferramentas (scripts Python, Bash, etc.) usando "meta-ferramentas" e registrá-las dinamicamente.
• Estrutura Hierárquica: As ferramentas são organizadas em um sistema de arquivos hierárquico com metadados, facilitando a descoberta e reduzindo o overhead de contexto.
• Isolamento e Estado: Utiliza containers Docker isolados para cada conjunto de ferramentas, permitindo dependências conflitantes e gerenciamento de estado (salvar e reutilizar estados de execução).
• Execução Assíncrona: Ferramentas de longa duração são executadas em segundo plano, permitindo que o agente continue raciocinando enquanto aguarda resultados.
• Kit de Ferramentas Específico: Inclui um conjunto de ferramentas otimizadas para engenharia de software (análise estática e dinâmica).

C. Sistema de Memória Hierárquico e Dirigido por IA

• Memória de Curto Prazo: Baseada em grafos (Neo4j), rastreia o histórico de execução, chamadas de ferramentas e estados de sub-agentes, permitindo compressão e recuperação de detalhes.
• Memória de Longo Prazo: Também baseada em grafos, armazena conhecimento de alto nível sobre o domínio (ex: estruturas de código, conceitos) que pode ser compartilhado entre tarefas.
• Agente de Memória Dedicado: Um agente especial gerencia a leitura, escrita e atualização da memória. Ele decide o que persistir, evita redundância e realiza buscas híbridas (baseadas em grafos e similaridade de embeddings).

3. Contribuições Principais

1. Primeiro ADK Centrado na IA: OpenSage é a primeira ferramenta que permite a criação autônoma de topologias de agentes, ferramentas e sistemas de memória pelo próprio modelo de IA.
2. Mecanismo de Topologia Dinâmica: Suporte nativo para criação, execução e terminação de sub-agentes em tempo real, permitindo arquiteturas verticais e horizontais adaptativas.
3. Síntese de Ferramentas: Capacidade de gerar, registrar e gerenciar ferramentas heterogêneas com isolamento de ambiente, superando a limitação de ferramentas estáticas.
4. Memória Estruturada por IA: Um sistema de memória que combina grafos de curto e longo prazo, gerenciado por um agente dedicado, otimizando o uso do contexto e a recuperação de conhecimento.

4. Resultados Experimentais

O OpenSage foi avaliado em três benchmarks de ponta (SOTA) com diversos modelos base:

• CyberGym (Vulnerabilidades C/C++): O agente SageAgent (OpenSage) alcançou 60.2% de taxa de resolução, superando significativamente o OpenHands (39.4%) e agentes da Anthropic (50.6%).
• Terminal-Bench 2.0: Com o modelo GPT-5.3-Codex, o SageAgent atingiu 78.4%, superando o Claude Code (58.0%) e o OpenHands (51.9%).
• SWE-Bench Pro (Engenharia de Software): O SageAgent alcançou 59.0%, superando o SWE-agent (40.2%) e o Agentless (9.4%).
• DevOps-Gym: O SageAgent foi o único a resolver tarefas de pipeline de ponta a ponta (17.7% vs 0% dos outros).

Estudos de Ablação:

• A remoção da topologia auto-gerada (NoVertical) causou uma queda drástica de desempenho devido ao esgotamento do contexto e perda de detalhes.
• A remoção do sistema de ferramentas (NoTools) reduziu a taxa de resolução de 64.0% para 50.3%, provando a importância da criação dinâmica de ferramentas.
• A remoção da memória hierárquica (NoMem) diminuiu o desempenho em tarefas de longo prazo, enquanto soluções de memória estáticas (Mem0g) não ofereceram melhoria significativa sem a gestão dirigida por IA.

5. Significado e Impacto

O OpenSage representa uma mudança de paradigma fundamental no desenvolvimento de agentes de IA:

• Escalabilidade: Remove a necessidade de engenheiros humanos projetarem manualmente a arquitetura para cada nova tarefa, permitindo que a IA se adapte dinamicamente.
• Desempenho Superior: A capacidade de criar ferramentas específicas e gerenciar memória complexa resulta em agentes mais robustos e capazes de resolver problemas de longo prazo e alta complexidade.
• Futuro da Pesquisa: Abre caminho para o treinamento de agentes que evoluem e aprendem com a experiência, utilizando o OpenSage como um ambiente de treinamento e scaffold para sistemas de IA mais avançados.
• Segurança e Responsabilidade: O artigo destaca a necessidade de salvaguardas e auditoria ao permitir que agentes criem seu próprio código e ferramentas, garantindo o uso responsável.

Em resumo, o OpenSage não é apenas uma ferramenta de desenvolvimento, mas um framework que permite a transição de agentes estáticos e pré-configurados para sistemas de agentes autônomos, adaptativos e auto-otimizáveis.