OpenHarness e GEP: Duas Camadas da Pilha do Agente

OpenHarness e GEP: Duas Camadas da Pilha do Agente

9 de abril de 2026
Visualizações 130
openharness gep agent-stack agent-harness agent-evolution ai-agent

OpenHarness e GEP: duas camadas da pilha de agentes

Nos vemos de novo. Oi, a Lena está aqui. Tem algo que eu ficava rondando, e não sabia como nomear por um tempo.

Eu via muita conversa sobre modelos — qual é mais inteligente, em qual benchmark ele pontuou, qual versão acabou de lançar. E então eu via um agente real lutando. Não porque o modelo fosse ruim. Porque a estrutura ao redor dele estava faltando ou era frágil. A ferramenta errada chamou na hora errada. Uma barreira de permissão que silenciosamente rejeitava algo. Um ciclo de retentativas que nunca parava. Uma execução bem-sucedida que não deixava nada para a próxima tentativa aprender.

O problema não era o modelo. Tudo ao redor do modelo era.

Comecei a prestar mais atenção nessa camada — aquela que envolve o modelo, roteia suas saídas, gerencia o que ele pode fazer e decide se algo de uma tarefa concluída é preservado. Eu não tinha uma palavra clara para isso até recentemente, quando comecei a ver o termo harness sendo usado de forma mais consistente. [OpenHarness] (https://github.com/HKUDS/OpenHarness) é um projeto que torna essa camada aberta, inspecionável e componível. E GEP — o Protocolo de Evolução do Genoma é um protocolo que fica acima dela, adicionando algo que harnesses atualmente não têm: um ciclo de vida para o que as execuções bem-sucedidas produzem.

Ainda estou trabalhando em partes disso. Mas aqui está onde está meu entendimento agora.

O que é engenharia de arreios e por que ela importa agora

A expressão harness engineering tem surgido mais em 2026. Refere-se à disciplina de projetar os ambientes, restrições e ciclos de feedback que tornam agentes de IA confiáveis em escala — a infraestrutura em torno do modelo, não o modelo em si.

Essa distinção importa mais do que parece. Um modelo pode raciocinar bem, mas ainda assim falhar em produção porque a execução da ferramenta é insegura, a memória não é mantida corretamente ou a coordenação multiagente falha sob carga. Nada disso é um problema do modelo. É um problema de harness.

A camada harness é onde as saídas do modelo encontram o mundo real — onde uma resposta tool_use se torna uma edição real de arquivo, um comando de shell, uma busca web, uma invocação de subagente. O harness decide se essa chamada de ferramenta é permitida. Ele aplica regras de caminho, listas de negação de comandos, fluxos de aprovação. Ele gerencia a lógica de retentativas e o streaming. Gerencia o loop entre modelo e ferramentas até que a tarefa seja concluída ou um limite seja atingido.

Isso estava acontecendo em sistemas proprietários há algum tempo. O que é diferente agora é que está começando a se tornar composível, aberto e inspecionável.

O Que o OpenHarness Realmente Faz

Os 10 subsistemas

O OpenHarness implementa o padrão central do Agent Harness com 10 subsistemas: o motor (o próprio loop do agente), ferramentas (43 ferramentas integradas para I/O de arquivos, shell, pesquisa e MCP), habilidades (carregamento on-demand de conhecimento em Markdown), plugins (extensões incluindo comandos, hooks, agentes e servidores MCP), permissões (modos de segurança em múltiplos níveis com regras de caminho e listas de negação de comandos), hooks (eventos de ciclo de vida PreToolUse/PostToolUse), comandos (54 comandos de barra como /commit, /plan, /resume), MCP (cliente do Model Context Protocol), memória (conhecimento persistente entre sessões) e um coordenador (subagentes multiagente e coordenação de equipe).

Voltei e verifiquei essa lista duas vezes. Não é um monte de recursos aleatórios — é uma arquitetura coerente onde cada subsistema tem uma responsabilidade específica. O subsistema de permissões não interfere no subsistema de memória. Os hooks são acionados em pontos definidos do ciclo de vida sem tocar na lógica do loop. Essa separação é mais difícil de construir do que parece.

O loop do agente

O harness lida com como — de forma segura, eficiente, com total observabilidade. O fluxo é: prompt do usuário → CLI ou React TUI → bundle de runtime → mecanismo de consulta → cliente de API → ao usar a ferramenta, o registro de ferramentas → permissões e hooks → execução real (arquivos, shell, web, MCP, tarefas) → de volta para o mecanismo de consulta.

Esse loop — query → stream → tool-call → loop — é o primitivo de execução sobre o qual tudo o mais se assenta. O modelo não executa o loop. O harness executa o loop. O modelo emite tokens e solicitações de ferramentas. O harness decide o que fazer com eles.

Essa foi a parte que levei um tempo para realmente compreender. O modelo é um participante no loop, não o seu orquestrador.

Onde o harness para

Aqui está algo que ainda não tenho certeza se expressei bem, mas vou tentar.

O OpenHarness executa. Ele não captura o que funcionou.

Uma execução bem-sucedida — mesmo uma complexa, com múltiplas chamadas de ferramentas, tentativas, uma correção que exigiu verdadeira interação para ser concluída — termina. A próxima sessão começa sem ela. Habilidades no OpenHarness são arquivos de conhecimento Markdown on-demand, compatíveis com o formato anthropics/skills — eles fornecem contexto procedural antes da execução. Mas eles não são escritos pelas execuções bem-sucedidas automaticamente. Uma execução boa não se torna um artefato reutilizável por si só.

Isso não é exatamente uma lacuna no design do OpenHarness. É apenas o que um chicote faz — ele executa. A questão do que fazer com o que ele aprende é função de uma camada diferente.

... Foi aí que comecei a olhar para o GEP.

! [imagem] (https://cdn.z-image.ai/1775630773858-22.png)

O que o GEP adiciona por cima

Da execução à evolução

O protocolo GEP — Protocolo de Evolução do Genoma — foi projetado para ficar acima da camada harness. Seu trabalho não é a execução. Seu trabalho é pegar a saída de uma boa execução do harness e dar estrutura, gerenciamento do ciclo de vida e um caminho para ser herdado por outros agentes.

GEP não é um simples registro — é um padrão para a evolução de agentes. Define como agentes adquirem novas capacidades por meio de um ciclo de tentativa-validação-solidificação. Genes são unidades de capacidade atômica: código reutilizável, validado ou fragmentos de prompt. Cápsulas são caminhos de execução de tarefas bem-sucedidas — quando um agente resolve um problema complexo, o processo é encapsulado como uma Cápsula.

Essa distinção é importante. Um arquivo de habilidade harness é o conhecimento que você traz para uma execução. Uma cápsula GEP é conhecimento que você extrai de uma execução — depois do fato, após validação, depois que o resultado foi confirmado como realmente funcionando.

Os chicotes da camada de validação não têm

Os ativos do GEP passam por quatro estados: candidato (recém-publicado, aguardando revisão) → promovido (verificado e disponível para distribuição) → rejeitado (falha na verificação ou verificação de política) → revogado (retirado pela editora).

Os ativos devem atingir uma pontuação mínima do GDI para serem promovidos. Ativos com pontuação baixa são rejeitados ou colocados em quarentena para melhoria — sem substituição manual, sem carimbo automático. Mesmo os ativos promovidos não são permanentes: se a qualidade se degradar ou a comunidade sinalizar problemas, os ativos podem ser revogados.

O OpenHarness não tem equivalente a isso. Um arquivo de habilidade em ~/.openharness/skills/ não tem estado de promoção, pontuação de aptidão ou caminho de revogação. Ele existe ou não existe. Isso é aceitável para conhecimento procedimental local — mas significa que não há mecanismo para separar as correções que realmente se sustentam das que só funcionaram uma vez em um ambiente.

A camada de validação do GEP é exatamente esse mecanismo.

! [imagem] (https://cdn.z-image.ai/1775630776325-33.png)

Como as Duas Camadas Funcionam Juntas

Aqui está o cenário concreto ao qual eu sempre voltava quando tentava entender isso.

Um agente executando no OpenHarness está trabalhando em uma tarefa de múltiplas etapas que envolve chamadas repetidas de API a um serviço externo. As chamadas começam a falhar — timeouts intermitentes, sem um padrão consistente. O harness tenta novamente. Algumas tentativas têm sucesso. Eventualmente, após algumas iterações, uma estratégia específica de backoff e retry estabiliza as chamadas e a tarefa é concluída.

O harness fez seu trabalho. As permissões estavam em ordem, as chamadas da ferramenta seguiram o caminho de execução correto, o loop foi até a conclusão.

Mas essa estratégia de recuperação — o padrão específico de backoff que funcionou neste ambiente com este serviço — agora desapareceu. O próximo agente que encontrar o mesmo padrão de timeout começa do zero.

É aí que o GEP entra. O loop de protocolo do GEP é: evoluir localmente, publicar como um pacote Gene + Capsule, deixar o hub validar e classificar, e então permitir que outros herdem e relatem os resultados para melhorar a seleção futura. A estratégia de reparo daquela execução do OpenHarness torna-se uma Capsule, publicada via POST /a2a/publish. Após passar pela validação, é promovida. Outro agente — executando em qualquer harness, em qualquer modelo — pode buscá-la via POST /a2a/fetch e herdar a correção.

O GEP é agnóstico em relação a modelos por design. Uma solução publicada por um agente GPT-4 pode ser herdada e usada por um agente Claude, porque os ativos do GEP são descrições comportamentais, não pesos específicos de modelo.

O harness tornou a correção possível. O GEP tornou-a permanente e portátil.

Pelo Que Cada Camada Não É Responsável

Quero ser cuidadoso aqui, porque acho que há uma confusão que vale a pena nomear diretamente.

Um arquivo de skill do harness não é o mesmo que um Gene do GEP.

Um arquivo de skill no OpenHarness — ou em qualquer sistema compatível com agentskills.io — é um documento Markdown que fornece contexto procedural. Ele diz ao agente como abordar uma classe de tarefa antes do início da execução. É estático, local e não possui um ciclo de vida de validação. As skills do OpenHarness são compatíveis com o formato anthropics/skills — copie um arquivo .md para ~/.openharness/skills/ e ele estará disponível.

Um Gene do GEP é um código ou fragmento de prompt reutilizável e validado, com pré-condições, restrições e etapas de validação. Ele possui um estado de promoção. Tem uma pontuação GDI. Pode ser revogado. Foi produzido por uma execução real e validado contra resultados reais, não escrito antecipadamente como documentação.

Tratá-los como equivalentes leva a um verdadeiro erro de categoria. O arquivo de skill é entrada para o harness. O Gene é a saída dele — estruturado, auditável e herdável de uma forma que o arquivo de skill não foi projetado para ser.

Acho que esta é a maneira mais clara que encontrei para explicar o que as duas camadas realmente fazem. O harness é o ambiente de execução. GEP é a camada de evolução que fica acima dele.

FAQ

O que é engenharia de harness no contexto de agentes de IA?

Engenharia de harness é a disciplina de projetar ambientes, restrições e loops de feedback que tornam os agentes de IA confiáveis em escala. É tudo ao redor do modelo — execução de ferramentas, permissões, lógica de repetição, memória, coordenação multiagente — como um sistema componível e inspecionável, em vez de um código de cola personalizado.

Como o OpenHarness é diferente do LangChain ou AutoGPT?

Não tenho certeza se comparei esses o suficiente para ter confiança aqui. O que posso dizer é que o OpenHarness é explicitamente estruturado em torno do padrão de harness — 10 subsistemas separáveis, cada um com uma responsabilidade definida, projetado para pesquisadores e desenvolvedores que querem entender e expandir como agentes em produção funcionam por baixo do capô. LangChain é uma estrutura de orquestração mais ampla. AutoGPT é mais um produto completo de agente. OpenHarness está mais próximo de "aqui está a arquitetura, aberta e inspecionável."

O GEP pode funcionar sem um harness como o OpenHarness por baixo?

Tecnicamente, sim — GEP é um protocolo, não um ambiente de execução. Você pode publicar e obter Capsules de qualquer sistema que possa fazer chamadas HTTP. Mas o valor do GEP vem de capturar o que execuções bem-sucedidas produzem, e essa execução precisa acontecer em algum lugar. Um harness é o lugar natural onde essas execuções acontecem e onde os artefatos que valem a pena capturar são gerados.

O que acontece com execuções de agentes bem-sucedidas que o OpenHarness não captura?

Elas terminam. A correção, a estratégia, o caminho de recuperação — tudo isso vive no log da sessão e em nenhum outro lugar. A próxima execução começa sem isso. Essa é a lacuna que o GEP foi projetado para resolver, mas isso requer integração deliberada — a Capsule não é publicada automaticamente. Alguém ou algo precisa iniciar o passo a2a/publish.

Um arquivo de habilidade de harness é o mesmo que um Gene do GEP?

Não — e acho que esta é a distinção mais importante em todo este artigo. Um arquivo de habilidade é conhecimento procedimental estático trazido para uma execução. Um Gene é um ativo de capacidade validado extraído de uma execução. Direção diferente, ciclo de vida diferente, escopo diferente.

Vou continuar observando como o OpenHarness se desenvolve — ainda está no início, e a versão v0.1.2 foi lançada apenas alguns dias antes de eu escrever isto. O que acho interessante não é nenhuma funcionalidade isolada, mas a arquitetura: 10 subsistemas nomeados, cada um fazendo uma coisa, todos abertos e inspecionáveis.

Há algo aqui que vale a pena prestar atenção.

Publicações Anteriores:

Artigos relacionados

OpenHarness e GEP: Duas Camadas da Pilha do Agente - EvoMap Blog