GUIA COMPLETO do Hermes Agent: Arquitetura, Configuração e o Loop de Autoaperfeiçoamento

Está surgindo uma nova categoria de ferramentas de IA que está tomando forma discretamente: agentes que não vivem em uma janela de chat que você abre e fecha, mas que rodam continuamente na nuvem e conversam com você através de um mensageiro, como um colega de trabalho que nunca sai do ar.

O Hermes é uma das implementações mais interessantes dessa ideia, e o que o diferencia de agentes similares como o OpenClaw é um loop de autoaperfeiçoamento embutido – um sistema que observa suas conversas, extrai padrões úteis delas e transforma esses padrões em atualizações permanentes para sua própria memória e conjunto de habilidades.

Este artigo explica como o Hermes é montado, como configurá-lo e como esse loop de autoaperfeiçoamento realmente funciona internamente.

O que é o Hermes e como ele difere do OpenClaw

Hermes é um agente de IA residente na nuvem, estruturalmente similar ao OpenClaw: ele funciona 24/7 e você interage com ele através de um aplicativo de mensagens, em vez de um terminal ou aba do navegador.

As diferenças significativas são três.

Primeiro, o Hermes vem com uma biblioteca muito maior de habilidades integradas de fábrica, então você gasta menos tempo configurando integrações manualmente.

Segundo, o processo de configuração é consideravelmente mais simplificado – uma TUI guiada cuida de quase tudo.

Terceiro, e mais importante, o Hermes foi projetado em torno do autoaperfeiçoamento contínuo: ele não apenas executa tarefas, mas acumula conhecimento processual sobre como executá-las melhor ao longo do tempo.

Instalação e Configuração Inicial

Colocar o Hermes para funcionar leva um único comando.

No Windows, execute isto no PowerShell:

iex (irm

https://hermes-agent.nousresearch.com/install.ps1

No Linux, macOS ou WSL, o equivalente é:

curl -fsSL

https://hermes-agent.nousresearch.com/install.sh | bash

Após a instalação, reiniciar o terminal e executar hermes setup inicia um fluxo de configuração guiada que percorre a seleção de modelo, backend do terminal, gateway de mensagens e configuração de ferramentas em sequência.

Escolhendo e Roteando Modelos

A primeira decisão real na configuração é qual provedor de LLM alimenta o "cérebro" do agente. A autenticação ocorre via OAuth, em vez de chaves de API brutas, o que se estende à possibilidade de fazer login através de uma sessão existente do Claude Code ou Codex CLI, em vez de gerar uma chave de API separada.

O que é genuinamente bem projetado aqui é como o Hermes separa o modelo usado para sua conversa principal dos modelos usados para tarefas em segundo plano e auxiliares. Por padrão, o mesmo modelo lida com ambas, mas cada tarefa auxiliar pode ser direcionada a um provedor diferente de forma independente.

As tarefas que suportam esse tipo de substituição são:

• vision – análise e descrição de imagens
• web_extract – resumir páginas da web longas
• compression – comprimir um contexto de conversa que está transbordando
• title_generation – gerar títulos de sessão
• curator – o agente em segundo plano responsável pelo loop de autoaperfeiçoamento
• kanban_decomposer – dividir tarefas grandes em subtarefas no modo Kanban
• goal_judge – o agente que verifica se uma /goal foi realmente alcançada

Isso é configurado diretamente no config.yaml, por exemplo:

1# Primary model for chat and complex reasoning
2model:
3  provider: "anthropic"
4  default: "claude-4-8-sonnet"
5  auxiliary:
6    vision:
7      provider: "gemini"
8      model: "gemini-2.5-flash"
9    compression:
10      provider: "custom"
11      base_url: "http://localhost:11434/v1"
12      api_key: "none"
13      model: "qwen2.5:32b"

Esse tipo de roteamento explícito resolve um problema real com o OpenRouter como escolha padrão: o mesmo modelo nominal é frequentemente implantado por muitos provedores diferentes, frequentemente em diferentes quantizações, e o OpenRouter embaralha silenciosamente cada nova solicitação entre cerca de vinte deles.

O efeito prático é que, dentro de uma única sessão, você não está falando com um modelo consistente – você está falando com um elenco rotativo de instâncias configuradas de forma diferente, algumas das quais lidam com chamadas de ferramentas e templates de prompt de forma mais confiável do que outras. Roteamento manual dentro do Hermes evita isso completamente.

Vale notar também que, se você quiser economizar dinheiro no modelo conversacional sem sacrificar a qualidade da codificação, o Hermes suporta comandos /claude_code e /codex que delegam tarefas de codificação diretamente para essas ferramentas CLI, em vez de lidar com elas com o modelo de chat configurado.

Backends de Terminal

Uma peça central da arquitetura é o Ambiente de Backend do Terminal, que determina onde e como os comandos do shell e scripts Python realmente executam, e como o agente toca em seu sistema de arquivos. O Hermes suporta cinco.

Local é o padrão. Os comandos são executados diretamente na sua máquina com as mesmas permissões da sua conta de usuário – sem isolamento. É a escolha certa para desenvolvimento local e uso pessoal confiável, onde você quer que o agente edite seus arquivos de projeto reais.

A segurança aqui depende inteiramente de um sistema de aprovações embutido que intercepta comandos destrutivos (um rm -rf /, um DROP TABLE) e pede permissão explícita antes de executá-los.

Docker executa o agente dentro de uma sandbox isolada para que ele não possa tocar em seu sistema host. SSH faz o agente executar comandos e trabalhar com arquivos em um servidor remoto através de uma conexão remota. Modal executa tudo em sandboxes serverless na nuvem – você está essencialmente alugando computação por segundo, pagando apenas pelos segundos reais em que seu código é executado.

Daytona é uma camada de gerenciamento de contêineres construída especificamente para agentes de codificação de IA; é mais rápido do que executar o Docker diretamente e lida com a configuração do ambiente e instalação de dependências automaticamente.

Para a maioria dos casos de uso pessoal, o Local é genuinamente suficiente – as outras opções importam principalmente se você estiver executando código não confiável ou operando em escala de equipe.

Gateway de Mensagens e Configuração de Ferramentas

Após o backend do terminal, a configuração passa para a escolha de onde você realmente conversará com o agente – sendo o Telegram a opção mais polida. Selecioná-lo fornece um link direto que ativa um bot pré-configurado; não há configuração manual de token de bot envolvida.

O restante da configuração percorre a ativação de ferramentas individuais e seus respectivos provedores – automação de navegador, geração de imagens, texto-para-fala e pesquisa na web. Para pesquisa na web especificamente, Firecrawl auto-hospedado ou Exa se destacam como excelentes escolhas para raspagem e recuperação orientadas a agentes.

A pesquisa no X requer uma assinatura do Grok para ser ativada, o que é bom saber antes de você procurar por ela no menu.

Comandos de barra que vale a pena conhecer

O Hermes vem com uma longa lista de comandos de barra, a maioria autoexplicativa pelo nome, mas alguns merecem destaque específico.

1. /background <prompt> executa uma tarefa em segundo plano sem interromper sua sessão principal.
2. /goal define um objetivo de longo prazo para o qual o agente trabalha persistentemente, com subcomandos para pausar, retomar, limpar ou verificar o status;
3. /subgoal gerencia objetivos menores aninhados sob uma meta ativa.
4. /kanban orquestra trabalho assíncrono de longa duração através de múltiplos agentes independentes – funcionando como um quadro Kanban real, onde um conjunto de tarefas é distribuído entre agentes de trabalho e passa por "a fazer", "em andamento" e "concluído" à medida que é transferido entre eles.

No lado do desenvolvimento, /github_pr_workflow lida com o ciclo completo do branch ao merge, incluindo CI, /github_code_review revisa pull requests, e /codebase_inspection analisa a divisão de linguagens e contagens de linhas de um repositório. /dogfood é um modo de QA dedicado que procura bugs em um aplicativo web e produz um relatório baseado em evidências. /spike executa um experimento rápido e descartável para validar uma ideia antes de se comprometer com o desenvolvimento completo, e /systematic_debugging trabalha com bugs em quatro fases, entendendo a causa raiz antes de tentar uma correção.

Há também um conjunto de comandos específicos de integração – /notion, /obsidian, /airtable, /google_workspace, /arxiv, /blogwatcher, /polymarket, /ocr_and_documents, /youtube_content – cada um encapsulando um serviço ou fluxo de trabalho externo específico, além de /bundles, que agrupa várias habilidades existentes sob um único comando de barra através de pequenos arquivos de configuração YAML.

Tarefas Cron e Webhooks

Duas primitivas de automação merecem atenção especial.

• Tarefas Cron permitem que você agende um script para ser executado em um temporizador; se você passar -no-agent ao criar uma, o Hermes executará um script Python ou bash simples e apenas encaminhará sua saída para seu mensageiro, sem gastar nenhum token de LLM.
• Webhooks são a peça mais poderosa: eles permitem que o agente reaja a eventos externos em vez de um temporizador. Você pode configurar um webhook para que, por exemplo, um novo pull request no GitHub acione automaticamente um agente com um prompt e conjunto de habilidades específicos – efetivamente criando um agente revisor de plantão com zero intervenção manual por PR.

Mecanismos de Contexto

O mecanismo de contexto governa como o Hermes comprime e gerencia o histórico de conversas quando ele se aproxima do limite de tokens do modelo, e há duas opções.

• O padrão, chamado Compressor, aplica sumarização com perdas à parte central de uma conversa longa.
• A alternativa, LCM (Gerenciamento de Contexto sem Perdas), adota uma abordagem estruturalmente diferente: em vez de produzir um resumo de texto, ele constrói um grafo acíclico direcionado dos pontos-chave da conversa, permitindo que o agente navegue de uma visão geral de alto nível e altamente comprimida para as mensagens originais específicas que a suportam.

Mecanismos de Memória

Provedores de memória externa funcionam junto com os arquivos de memória local integrados do Hermes, MEMORY.md e USER.md, adicionando capacidades como busca semântica e grafos de conhecimento.

Vários podem ser configurados diretamente através da TUI de configuração.

1. Honcho é construído em torno da modelagem de um perfil de usuário detalhado, usando chamadas LLM em segundo plano para sintetizar observações em duas camadas: uma camada base de resumos e perfis de sessão, e uma camada dialética que analisa as necessidades atuais do usuário.
2. OpenViking é um banco de dados de contexto que constrói uma hierarquia de conhecimento no estilo de sistema de arquivos, suportando recuperação de contexto em camadas e classificando automaticamente fatos extraídos em seis categorias – eventos, padrões, preferências e assim por diante – ao final de cada sessão.
3. Mem0 é um serviço de memória em nuvem totalmente gerenciado; a extração de fatos ocorre no lado do servidor via LLM, e inclui busca semântica, reordenamento de resultados e desduplicação automática, embora, por ser hospedado na nuvem, seja também a única opção aqui com um custo recorrente.
4. Hindsight é um sistema de memória de longo prazo mais avançado construído sobre um grafo de conhecimento, no estilo GraphRAG. Ele extrai entidades das sessões, constrói relacionamentos entre elas e preserva turnos conversacionais completos, incluindo chamadas de ferramentas, com a memória dividida em quatro categorias: fatos sobre o mundo, a própria experiência do agente, opiniões e observações.
5. Holographic é um armazenamento de fatos local, baseado em SQLite, sem dependências externas, incluindo um sistema de pontuação de confiança para fatos armazenados e o uso de Representações Reduzidas Holográficas para suportar consultas algébricas e composicionais, com a capacidade de detectar automaticamente contradições dentro de sua base de conhecimento.
6. RetainDB é uma API de nuvem para memória de equipe, oferecendo busca híbrida entre vetor, BM25 e métodos de reordenamento, com a memória dividida em sete tipos distintos e compressão delta para manter o armazenamento eficiente.
7. ByteRover é um sistema de memória local portátil, acessado através de uma CLI, construindo uma árvore de conhecimento hierárquica e extraindo fatos importantes antes que a compressão com perdas tenha a chance de removê-los do contexto.
8. Supermemory oferece memória semântica de longo prazo com uma API de grafo: ele ingere logs completos de sessão após uma conversa terminar para construir seu grafo de conhecimento, limpa periodicamente fatos recuperados para evitar poluição de turnos atuais e pode isolar a memória em contêineres separados por perfil de agente.

Para uso diário, a memória local padrão é genuinamente adequada para a maioria das pessoas – os sistemas mais pesados trocam custo real de recursos, especialmente RAM para opções hospedadas localmente, por uma capacidade que a maioria dos fluxos de trabalho ainda não precisa.

O Loop de Autoaperfeiçoamento

Esta é a funcionalidade que mais distingue o Hermes de um agente convencional: um conjunto de processos assíncronos em segundo plano que analisam continuamente suas conversas, extraem padrões úteis delas e escrevem esses padrões na memória de longo prazo e na memória processual (habilidades) – e então mantêm esse conhecimento acumulado para que ele não se deteriore ao longo do tempo. Todo o sistema funciona em paralelo com seu chat principal e é construído a partir de três componentes: um sistema de gatilho, um agente de revisão em segundo plano e um curador.

• O Sistema de Gatilho

O Hermes não analisa todas as mensagens em tempo real, já que isso queimaria tokens sem benefício. Em vez disso, ele depende de dois contadores que acionam uma passagem de reflexão quando ultrapassam um limite.

Um gatilho de memória é acionado a cada dez prompts do usuário, verificando se novos fatos dignos de serem salvos apareceram na conversa.

Um gatilho de habilidade é acionado a cada dez iterações de chamada de ferramenta dentro de um único turno, partindo do princípio de que, se o agente gastou tantos passos lutando com um problema por tentativa e erro, essa experiência vale a pena ser analisada e possivelmente transformada em uma habilidade reutilizável.

Assim que qualquer um dos contadores atinge seu limite, uma função interna é acionada, entregando um instantâneo da conversa atual a um processo de revisão em segundo plano.

• O Agente de Revisão em Segundo Plano

Esse instantâneo vai para um processo de agente totalmente separado e isolado que é executado em paralelo sem interromper sua sessão principal. Ele trabalha em duas direções.

1. No lado declarativo, se notar novas preferências do usuário ou detalhes do ambiente – uma preferência pelo Supabase, um projeto preso ao Python 3.12 – ele atualiza MEMORY.md ou USER.md, dependendo de qual arquivo o fato pertence.
2. No lado processual, se detectar que o agente acabou de resolver um problema não trivial ou elaborou um processo complexo, ele pode criar uma nova habilidade, editar uma existente, aplicar um patch direcionado ou excluir uma habilidade completamente. Qualquer habilidade que ele crie é explicitamente marcada como gerada pelo agente, para que sua origem seja sempre rastreável.

Para que o curador eventualmente julgue quais dessas habilidades autogeradas realmente valem a pena manter, o Hermes mantém um registro de uso oculto rastreando, para cada habilidade: quantas vezes ela foi carregada em um prompt, quantas vezes o agente a abriu para lê-la, quantas vezes foi editada e timestamps para criação, último uso e última edição.

• O Curador

Sem controle, esse processo pode eventualmente produzir centenas de habilidades, algumas redundantes, algumas desatualizadas.

O curador existe para evitar que essa base de conhecimento se degrade. Ele só é iniciado quando duas condições são satisfeitas simultaneamente: tempo suficiente passou desde sua última execução (sete dias, por padrão) e o agente principal está ocioso há tempo suficiente (duas horas, por padrão) para que uma passagem de manutenção pesada não interfira no trabalho ativo.

Antes de fazer qualquer alteração, ele faz backup automático de todo o diretório de habilidades, para que qualquer resultado insatisfatório possa ser revertido através de um único comando de terminal.

O trabalho do curador acontece em duas fases:

• A primeira é puramente mecânica e não envolve uma chamada de LLM: ele verifica as métricas de uso, marca qualquer habilidade gerada pelo agente que não tenha sido usada por mais de 30 dias como obsoleta e move qualquer coisa não usada por mais de 90 dias para uma pasta de arquivamento. Habilidades importantes podem ser explicitamente fixadas para protegê-las desse processo.
• A segunda fase é uma revisão de LLM genuína, executada através de uma instância de agente isolada separada usando qualquer modelo que esteja configurado para a tarefa auxiliar do curador – por padrão, o mesmo modelo da conversa principal, embora possa ser direcionado para algo mais barato. Vale a pena ser cauteloso ao escolher algo muito barato aqui, já que a qualidade dessas decisões tem um efeito downstream real na biblioteca de habilidades.

Para cada habilidade, o curador decide mantê-la como está se ainda for precisa e útil, corrigi-la se contiver erros ou métodos desatualizados, mesclá-la com outra habilidade que cubra substancialmente o mesmo terreno (realocando corretamente quaisquer scripts associados, avaliações ou arquivos de referência e reescrevendo caminhos relativos no processo), ou arquivá-la completamente.

Ao final do ciclo, ele produz um relatório detalhado incluindo um mapa de renomeação mostrando exatamente como os nomes antigos das habilidades foram mapeados para os novos após quaisquer mesclagens, para que o raciocínio por trás de cada decisão seja totalmente auditável.

Usando o Hermes bem

Agentes de nuvem como este são genuinamente valiosos para qualquer processo que você possa executar 24/7 – sendo o trabalho de codificação a exceção notável – desde que você tenha realmente digitalizado esse processo cuidadosamente e construído uma habilidade sólida em torno dele, incluindo avaliações.

O fluxo de trabalho que tende a produzir bons resultados é mais ou menos assim:

1. Comece gravando a si mesmo, em detalhes, percorrendo o processo do início absoluto ao fim, idealmente usando uma ferramenta de ditado para capturá-lo com precisão – e esta etapa só funciona se você realmente entender o processo ou tiver pesquisado adequadamente.
2. Pegue essa gravação ou essas anotações e alimente-as em um agente de codificação usando uma ferramenta de criação de habilidades para produzir um primeiro rascunho; ele não será bom o suficiente ainda para ser delegado, especialmente para algo complexo.
3. Incorpore avaliações – soluções de referência que representam um resultado correto – já que são elas que permitem que você realmente meça se a habilidade está tendo um bom desempenho, em vez de apenas chutar.
4. Execute a habilidade em um ambiente de teste e refine tanto as avaliações quanto o conteúdo da habilidade com base no que você observar, fazendo a maior parte dessa edição manualmente, em vez de delegá-la.
5. Somente quando a habilidade se comportar de forma consistente e determinística ela deve ser entregue ao agente sempre ativo. Se o processo depender de algum serviço externo, vale a pena verificar se um servidor MCP ou CLI existente já o cobre antes de construir um do zero.

O ponto mais amplo é que o alcance das coisas que você pode entregar a um agente como este é limitado principalmente pelo quão bem você consegue especificar o trabalho, não pela capacidade bruta do agente.

Três princípios parecem se manter em todos os casos de uso: não terceirize o trabalho de codificação para um agente de nuvem não supervisionado 24/7, mantenha um humano no loop revisando o que o agente realmente produz e trate o refinamento de habilidades como um trabalho contínuo, em vez de algo que você termina uma vez e abandona.

Se isso foi útil – salve nos favoritos. Você vai querer voltar a ele.

Para mais análises como esta, siga @ScottyBeamIO

Sem enrolação, apenas o que realmente funciona.