O que é o Hermes Agent? O guia de quem roda ele em produção

Procura “Hermes Agent” e você só acha guia de instalação. Cola um curl, escolhe um modelo, conecta o Telegram, pronto. Essa é a parte fácil, e é a que menos importa depois que a coisa já está rodando há um mês.

Eu rodo o Hermes em produção. Treze agentes numa organização no Paperclip rodam nele, um Hermes separado no Telegram é meu assistente pessoal, e no meu trabalho outro escreve um briefing diário a partir dos servidores MCP da empresa. Publiquei um adapter para ele, mandei uma correção upstream e já li o código-fonte mais vezes do que eu queria. Este é o guia que eu queria ter quando comecei: o que o Hermes é por dentro, o que o loop de aprendizado faz de verdade, onde ele quebra e quando vale escolher outra coisa.

O que é o Hermes Agent?

O Hermes Agent é um agent runtime open source, licenciado em MIT, da Nous Research, que você hospeda você mesmo. Você fala com ele por terminal, app desktop, dashboard web, uma API compatível com OpenAI ou mais de 25 plataformas de mensagens. Ele age por shell, arquivos, browser e execução de código. Mantém memória entre sessões, busca no próprio histórico e escreve as próprias skills depois de tarefas difíceis.

Três coisas separam ele do agente de código que você já usa. Ele roda sem você: num servidor, numa agenda, respondendo uma mensagem no seu celular. Ele lembra: um arquivo de memória, um perfil seu e um histórico pesquisável sobrevivem a toda sessão. E ele aprende: a cada poucos turnos, uma revisão em background decide se algo que ele acabou de fazer vale a pena salvar.

Hermes Agent na v0.21.5

250k

estrelas no GitHube quase 48k issues e PRs abertos

38

plugins de model providermais qualquer endpoint compatível com OpenAI

7

backends de execuçãodo local a sandboxes serverless

25+

plataformas de mensagensde Telegram a Matrix a WeChat

Como o Hermes Agent funciona

Desmonta o Hermes e você acha as mesmas quatro partes de qualquer harness: um loop, ferramentas, gestão de contexto e controles. O que faz dele o Hermes é o quanto ele investiu em cada camada.

Hermes Agent, de fora para dentro

1. 1

   Gateways

   CLI, uma UI de terminal, um app desktop, um dashboard web, um servidor de API compatível com OpenAI, ACP para editores como o Zed, e mais de 25 plataformas de mensagens. Toda superfície fala com o mesmo agente.

   +
2. 2

   Contexto

   Um system prompt montado em camadas: uma identidade estável a partir do SOUL.md, um arquivo de contexto do projeto, um índice compacto de skills e memória. A compressão entra na metade da context window por padrão.

   +
3. 3

   Ferramentas

   Terminal, arquivos, browser, web, visão, servidores MCP, mais três primitivas que mudam o custo de uma execução: chamada de ferramentas por código, busca de ferramentas e delegação para subagents.

   +
4. 4

   Backends de execução

   Onde os comandos de fato rodam: local, Docker, SSH, Singularity, Modal, Daytona ou Vercel Sandbox.

   +
5. 5

   Aprendizado

   Uma revisão em background que salva memórias e skills, um curador semanal que arquiva o que não é usado, e busca full-text em toda sessão passada.

A Nous Research treina modelos, e isso aparece no produto. O Hermes vem com um batch runner, um compressor de trajetórias e um SWE runner que escrevem trajetórias de tool-calling no formato próprio do Hermes. O runtime funciona também como uma forma de gerar dados de treino para os modelos do laboratório. Essa é uma razão estrutural para o projeto continuar existindo, e explica por que as primitivas do loop são mais profundas que as features voltadas ao usuário final.

O que o Hermes lê antes de responder

A maioria das surpresas que tive com o Hermes veio de não saber o que ele estava colocando na frente do modelo. Aqui está o mapa. Como eu alimento ele com um second brain sem deixar ele escrever lá está em Hermes Agent e um second brain.

O que alimenta o prompt

• ~/.hermes/// HERMES_HOME, um por perfil
  • config.yamlvocê// modelo, provider, reasoning effort, servidores MCP
  • SOUL.mdsempre// identidade, carregado em todo turno
  • MEMORY.mdaprendido// o que ele salvou sobre o trabalho
  • USER.mdaprendido// o que ele salvou sobre você
  • skills/// pastas SKILL.md, formato agentskills.io
  • state.db// toda sessão, pesquisável com SQLite FTS5
• seu diretório de trabalho/// só um arquivo de contexto carrega, o primeiro encontrado ganha
  • .hermes.md// 1º
  • AGENTS.md// 2º, procurado a partir da raiz do git
  • CLAUDE.md// 3º
  • .cursorrules// 4º

Duas lições aqui me custaram dinheiro de verdade.

Auto-discovery é uma feature até o diretório de trabalho pertencer a outra pessoa. Meus agentes do Paperclip rodavam dentro da própria pasta do app do Paperclip, então o Hermes achava o AGENTS.md interno do Paperclip e carregava ele a cada wake. Isso era 22 por cento dos tokens de input de cada wake, para instruções escritas para outro programa. Um diretório próprio por agente baixou o input de 9.044 para 6.992 tokens.

Identidade vai no SOUL.md, em nenhum outro lugar. O Hermes abre o system prompt se apresentando como Hermes Agent. Quando minha persona chegava depois como mensagem de usuário, o modelo recebia duas identidades e escolhia a média segura. No meu próprio teste de design de oferta, o GLM-5.1 pontuou 9,55 pelo OpenCode e 7,0 a 7,9 pelo Hermes com a persona no lugar errado. Mesmo modelo. O layout do prompt era a variável.

O loop de aprendizado, sem o discurso de venda

O loop é a feature mais divulgada e a que as pessoas descrevem pior. Aqui está o que o código realmente faz.

A cada 10 turnos o Hermes dispara uma revisão de memória, e a cada 10 iterações de ferramenta dispara uma revisão de skill. Os dois intervalos são configuráveis. A revisão roda como um agente forkado que só pode tocar nas ferramentas de memória e skill, e decide se algo da sessão vale a pena guardar. Um curador roda semanalmente quando o agente está ocioso, marca skills não usadas como obsoletas depois de 14 dias e arquiva depois de 30. Ele nunca deleta, então qualquer coisa arquivada pode voltar.

Minha conclusão depois de meses rodando: o loop é bom em procedimento e ruim em julgamento. Ele vai lembrar a flag que uma ferramenta precisa, a ordem certa de um deploy, o workaround para uma API instável. Não deveria ser a coisa que reescreve como um agente pensa. Minhas persona skills carregam julgamento, e eu escrevo elas na mão a partir de material que estudei. Um fork em background que viu uma sessão não é o autor certo para isso. A divisão completa está em skills do Hermes Agent.

As ferramentas que mudam a economia

Três primitivas importam mais que a lista enorme de ferramentas nativas.

Chamada de ferramentas por código. O modelo escreve um script Python que chama ferramentas do Hermes via RPC, e só o stdout do script volta para o contexto, limitado a 50 KB com início e fim mantidos. Todo o resto cai num arquivo em disco. Se o seu agente itera sobre cinquenta itens chamando uma ferramenta em cada um, essa é a diferença entre cinquenta resultados de ferramenta no contexto e uma linha de resumo.

Busca de ferramentas. Quando qualquer ferramenta de MCP ou plugin existe, o Hermes move essas ferramentas para trás de uma ferramenta de busca e embute uma listagem compacta dimensionada para um orçamento pequeno, 5 por cento da janela por padrão. Minha frota tinha 114 ferramentas de MCP escondidas atrás da busca. Com esse deferral, o custo de “ferramentas demais” praticamente desaparece, e fazer hard-scope das ferramentas de cada agente deixa de valer o risco de quebrar ele.

Subagents. delegate_task cria filhos isolados, até 10 de uma vez por padrão, e os filhos podem delegar de novo dentro de um orçamento de profundidade. Desde a v0.21 você consegue listar, direcionar e parar subagents enquanto rodam, e validar o que eles retornam contra um JSON schema.

Tem mais: um modo Mixture-of-Agents que agrega respostas de vários modelos, cron jobs que você encadeia e responde, e um Bot Mode onde agentes nomeados compartilham grupos de chat. Útil, mas as três de cima são as que mudam o custo de uma execução. A conta completa está em quanto custa o Hermes Agent.

Sete lugares onde seus comandos podem rodar

O Hermes separa o agente de onde os comandos dele executam. A lista de backends na v0.21.5: local, Docker, SSH, Singularity, Modal, Daytona e Vercel Sandbox. Modal e Daytona dão sandboxes que persistem entre tarefas sem uma máquina que você fica pagando o tempo todo.

Roda o agente numa máquina e executa em outra, descartável. O backend Docker vem com um proxy de egress que mantém credenciais fora do sandbox. Comandos de terminal arriscados param e pedem aprovação em qualquer superfície que você estiver usando, Telegram incluído, e um arquivo ESTOP dentro de HERMES_HOME pausa todo cron, kanban e trabalho de gateway novo. Também existem guardas de escrita de arquivo, mas o código é explícito que elas não são uma fronteira de segurança: a ferramenta roda como o seu usuário do sistema operacional. O resto está em o Hermes Agent é seguro?.

Como eu rodo o Hermes em produção

Meu setup é chato de propósito. Uma VPS virou um Docker Swarm com Traefik e Portainer pelo bento, meu instalador. O Hermes roda headless num container com o gateway do Telegram ligado, e é esse o assistente com quem eu falo por voz. O Paperclip roda no mesmo swarm, e todo agente da organização chama o binário do Hermes pelo meu adapter. Os servidores MCP ficam num gateway catálogo com o mcp-pooler na frente dele, então agentes de vida curta veem suas ferramentas em cerca de 50 milissegundos em vez de vários segundos. O setup completo de MCP está em Hermes Agent e MCP.

O modelo vive no ~/.hermes/config.yaml, nunca no orquestrador. Ao longo dos meses a frota rodou GLM-5.1 pela Z.AI e depois DeepSeek V4 Flash pelo OpenRouter. Os agentes mais específicos rodam bem em modelos baratos, e como eu escolho eles está em o melhor modelo para o Hermes Agent. A regra que aprendi é que o runtime é dono do modelo e do reasoning effort. Toda vez que o orquestrador tentava definir eles, alguma coisa desalinhava.

Onde o Hermes quebra em produção

Nada disso aparece numa demo. Tudo isso apareceu no primeiro mês.

Sintoma, causa real, correção

O que você vê	O que está acontecendo de fato	O que corrigiu
O agente diz que as ferramentas dele não existem	Os backends de MCP fazem cold-spawn além da janela de descoberta de menos de um segundo	Um pooler aquecido na frente do gateway MCP
Sob um orquestrador, uma execução que terminou o trabalho é marcada como morta	O orquestrador lê liveness pelo stdout, e uma síntese longa e silenciosa parece morta	Um keepalive num timer, enviado upstream como pull request
A persona soa genérica	A persona chega como mensagem de usuário sob a identidade do próprio Hermes	Identidade no SOUL.md, uma única fonte
Todo wake custa um quinto mais do que devia	O auto-discovery carrega o AGENTS.md de outro programa a partir do diretório de trabalho	Um diretório próprio por agente
API keys aparecem num log de sessão	Um dump do config.yaml dentro de uma sessão escreveu elas no log	Rotacionar as chaves; manter segredo fora de tudo que o agente imprime
O dashboard trava ao conectar	O browser não reenvia basic auth no upgrade do WebSocket	Uma rota de token para o WebSocket, separada do basic auth

As duas primeiras estão escritas no Lab: 157 ferramentas e zero chamadas e quatro minutos de silêncio que mataram um agente. As duas ensinaram a mesma regra. O agente é um narrador não confiável. Quando ele reporta uma falha, não debugue a história dele. Leia o ~/.hermes/logs/agent.log. O log estava certo todas as vezes.

Depois tem o ritmo. O Hermes tem quase 48.000 issues e pull requests abertos. A v0.21.0 lançou regressões no banco de dados de sessão que levaram seis pull requests de follow-up e 44 issues fechadas para estabilizar na v0.21.2. Algumas issues abertas que eu leria antes de atualizar uma máquina de produção: um executor de gateway sem timeout que congela o gateway por 120 segundos (#101033), um heartbeat de liveness do loop que pode nascer morto (#94758), e um processo de dashboard que vaza memória até os clientes serem derrubados por OOM (#80527).

Hermes Agent vs OpenClaw vs Claude Code

Eles são comparados porque todos dizem “agente”. Mas são feitos para trabalhos diferentes.

O OpenClaw é um assistente pessoal que quer estar em todo lugar que você está: apps nativos para macOS, iOS, Android e Linux, uma wake word, voz on-device, um heartbeat que acorda ele sozinho. O Hermes é um runtime que quer viver num servidor e executar seus comandos em algo descartável. Em junho a diferença era profundidade: o Hermes tinha o loop de aprendizado e a chamada de ferramentas por código, e o OpenClaw não. Em outubro o OpenClaw já tinha lançado as duas coisas. Eu escolhi o Hermes para a frota depois de ler os dois códigos-fonte, li de novo antes de escrever isso, e a comparação completa está em Hermes Agent vs OpenClaw.

O Claude Code é um agente de código que você dirige dentro de um repositório. Eu uso ele todo dia e não é um substituto para o Hermes, nem o contrário. A mesma pessoa pode rodar os dois: Claude Code para construir, Hermes para o trabalho que deveria continuar acontecendo com o notebook fechado. A versão completa está em Hermes Agent vs Claude Code.

Quando não usar o Hermes

Escolha outra coisa se

• ✓Obrigatório:
  Você quer um agente de código dentro do seu repositório.Claude Code, OpenCode ou pi vão te servir melhor. O Hermes consegue programar, mas o centro de design dele é o trabalho que acontece quando você não está olhando.
• ✓Obrigatório:
  Você quer um assistente no celular e no notebook, com voz.Esse é o centro de design do OpenClaw: apps nativos, voz, presença em todo lugar.
• ✓Obrigatório:
  Você não vai ler log em Python.Quando o Hermes falha, a verdade está no agent.log e no código-fonte. O relato do próprio agente costuma estar errado.
• ✓Obrigatório:
  Você precisa de uma API que fique parada.As releases saem cerca de duas vezes por semana. Chaves de configuração, padrões e features mudam.
• ✓Obrigatório:
  Você tem uma tarefa só e nenhuma agenda.Memória, cron e gateways se pagam quando um agente roda por semanas. Para uma tarefa só, uma sessão simples é mais fácil.

Hermes Agent, respostas rápidas

O que é o Hermes Agent?+

O Hermes Agent é um agent runtime open source, licenciado em MIT e self-hosted, da Nous Research. Ele age por shell, arquivos, browser e execução de código, mantém memória entre sessões, busca no próprio histórico, escreve as próprias skills, e você fala com ele por terminal, app desktop, dashboard web, API ou mais de 25 plataformas de mensagens.

O Hermes Agent é de graça?+

O software é de graça e licenciado em MIT. Você paga pelos tokens do modelo e por onde ele roda.

O custo real está em como você configura ele: o que entra no prompt a cada turno, com que frequência o loop de aprendizado dispara, e qual modelo cada tarefa recebe.

O Hermes Agent é seguro?+

Ele tem controles reais: prompts de aprovação para comandos arriscados em toda superfície, um arquivo de parada de emergência, e um proxy de egress que mantém credenciais fora do sandbox do Docker. O próprio código diz que as guardas de escrita de arquivo não são uma fronteira de segurança.

Trate ele como um colega com acesso a shell. Dê a ele a própria máquina ou sandbox, credenciais com escopo reduzido, e nunca uma chave que você não consiga rotacionar.

Qual é o melhor modelo para o Hermes Agent?+

O mais barato que passar no seu próprio teste, rodado pelo Hermes, não num chat simples. O runtime muda o resultado: o mesmo modelo pontuou 9,55 pelo OpenCode e caiu para 7,0 pelo Hermes quando minha persona foi para o lugar errado.

Defina o modelo no ~/.hermes/config.yaml e mantenha orquestradores fora disso.

Dá para usar o Hermes Agent junto com o Claude Code?+

Sim, eles fazem trabalhos diferentes e convivem bem. O Hermes fala ACP para editores como o Zed, e hermes mcp serve expõe as conversas dele como ferramentas MCP que o Claude Code, o Cursor ou o Codex conseguem chamar. No meu setup, o Claude Code é onde eu construo e o Hermes é o que continua trabalhando quando eu paro.