Hermes Agent não é apenas mais inteligente: agora ele prova que terminou

O modo de falha mais comum dos agentes de IA não é que eles não consigam fazer o trabalho, mas que você não pode ter certeza de que o trabalho está realmente terminado. Eles declaram com confiança que terminaram, mas esquecem um arquivo. Executam um script sem inspecionar a saída. Continuam como se a etapa anterior não tivesse falhado.

Hermes Agent v0.18.0 — codinome “The Judgment Release” — é construído em torno de uma ideia: fazer o agente provar que terminou.

Confira as notas de lançamento completas do v0.18.0 para uma lista completa de alterações.

De “parece que terminou” para “as evidências dizem que terminou”

Tradicionalmente, um modelo para quando decide que respondeu o suficiente. Essa decisão é subjetiva. Sentir que terminou não é o mesmo que atender às expectativas.

Hermes v0.18.0 introduz dois mecanismos complementares que transformam a conclusão de uma intuição em um objeto verificável:

  • Standing Goals: uma condição de meta persistente contra a qual o agente verifica continuamente o progresso.
  • Completion Contracts: um acordo verificável que define o que significa “terminado”, incluindo evidências e etapas de validação.

Resumindo: em vez de pedir para ele fazer algo e confiar quando ele diz que terminou, você diz o que significa terminar, e ele traz as evidências.

Por que a auto-verificação importa

Hermes já podia chamar ferramentas, escrever código, executar testes e gerenciar arquivos. Mas tudo isso deixava uma lacuna: ele não verificava ativamente seu próprio trabalho.

v0.18.0 muda isso. Depois de agir, o agente tenta verificar se o resultado atende às condições definidas. Parece pouco, mas transforma Hermes de mero executor em um executor responsável:

  • Ele verifica se um arquivo existe e corresponde às expectativas após editá-lo.
  • Inspeciona códigos de saída, logs e efeitos colaterais após executar comandos.
  • Percorre os critérios de conclusão antes de dizer que a tarefa terminou.

Não é uma garantia perfeita, mas reduz bastante a chance de “parece terminado, mas não está”.

Standing Goals: a condição de conclusão como contrato de longo prazo

Standing Goals permitem declarar uma meta de longo prazo e fazer o agente medir o progresso continuamente. Usos típicos:

  • “Converter todos os caminhos codificados em src/utils.py para variáveis de ambiente.”
  • “Resolver todos os comentários TODO do repositório.”
  • “Garantir que toda chamada de API tenha lógica de retry.”

Essas tarefas raramente são resolvidas em uma única ação. Elas exigem verificar, editar e verificar novamente. Os Standing Goals forçam o agente a se perguntar após cada passo: “Cheguei mais perto da meta? A meta já foi atingida?”

Você define a meta; o agente planeja, age, verifica e itera até atingi-la ou encontrar um bloqueio que exige intervenção humana.

Completion Contracts: tornar “terminado” verificável

Se os Standing Goals respondem “qual é a meta”, os Completion Contracts respondem “como sabemos que terminou”.

Um Completion Contract pode incluir:

  1. Critérios de conclusão: condições que devem ser atendidas, como existência de arquivo, testes passando, formato de saída correto ou builds bem-sucedidos.
  2. Método de verificação: a ferramenta ou comando usado para validar, como pytest, curl, grep ou diff.
  3. Tratamento de falhas: o que fazer se a verificação falhar — tentar novamente, reverter ou pausar e relatar ao usuário.

Essa estrutura torna o comportamento do agente transparente. Você pode ver exatamente qual padrão ele usou para julgar a conclusão e auditar esse julgamento depois.

Exemplo: deixe o agente verificar sua própria correção

Suponha que você peça ao Hermes para corrigir um bug de valor nulo em utils/parser.py e exija que os testes passem antes de relatar a conclusão. Um Completion Contract poderia parecer com isto:

Objetivo: Corrigir a exceção de análise de valores nulos em utils/parser.py
Critérios de conclusão:
  1. O caso falhante não lança mais TypeError
  2. pytest tests/test_parser.py passa completamente
  3. Um teste de regressão cobrindo a exceção é adicionado
Método de verificação:
  - Executar pytest tests/test_parser.py
  - Verificar se o Git diff inclui alterações em parser.py e test_parser.py
Tratamento de falhas:
  - Se os testes falharem, analisar o log, modificar o código e tentar novamente até 3 vezes
  - Se ainda falhar, pausar e relatar ao usuário

Hermes executará esse contrato: modificar o código, executar os testes, inspecionar o diff e só relatar a conclusão quando os três critérios forem atendidos. Isso é muito mais confiável do que “código alterado, tarefa concluída”.

Combinado com Mixture-of-Agents: verificação mais cuidadosa

v0.18.0 também fortalece o Mixture-of-Agents (MoA): vários modelos atuam como um painel, cada um raciocinando independentemente, enquanto um agregador produz a resposta final.

Para a auto-verificação, MoA agrega valor ao:

  • Fazer vários modelos inspecionarem as mesmas evidências independentemente.
  • Mostrar o raciocínio de cada modelo de referência.
  • Transformar a resposta final em uma conclusão cruzada, não no palpite mais confiante.

É como adicionar uma revisão entre pares ao julgamento de conclusão do agente.

O que os usuários notarão

Para usuários do dia a dia, v0.18.0 traz três melhorias concretas:

  1. Menos conclusões falsas: o agente se verifica em vez de terminar apressadamente.
  2. Decisões mais transparentes: você pode ver os critérios e evidências usados.
  3. Tarefas longas mais estáveis: Standing Goals e Completion Contracts mantêm a automação no rumo certo.

Essas mudanças não aparecem como um único recurso chamativo, mas na forma como o agente se comporta.

Limitações e recomendações

A auto-verificação não é mágica. Ela é limitada por:

  • Quão completos são seus critérios de conclusão.
  • Se suas ferramentas de verificação cobrem os cenários reais de uso.
  • Quão precisamente o modelo interpreta os resultados da verificação.

Por isso, ao usá-la:

  • Escreva critérios de conclusão específicos e verificáveis.
  • Dê preferência a métodos de verificação com saídas claras e códigos de saída.
  • Mantenha uma revisão humana para tarefas críticas, em vez de delegar totalmente o julgamento ao agente.

Principais conclusões

  • Hermes Agent v0.18.0 “The Judgment Release” se concentra na auto-verificação e conclusão comprovável.
  • Standing Goals mantêm o agente verificando o progresso contra uma meta de longo prazo.
  • Completion Contracts decompõem “terminado” em critérios verificáveis, métodos de verificação e tratamento de falhas.
  • O agente não para mais com base em uma intuição; ele julga a conclusão com base em evidências.
  • Com a validação cruzada do Mixture-of-Agents, os julgamentos de conclusão ficam mais cuidadosos e transparentes.
  • Os usuários devem escrever critérios específicos e verificáveis, e manter revisão humana para trabalhos críticos.

Referências: