Mergulho Profundo no Hermes Agent 2026: O Agente de IA que se Autoaperfeiçoa e Realmente se Lembra de Você

Você provavelmente já viu o Hermes Agent nos Trending do GitHub — mais de 73.000 estrelas, subindo rápido. Desenvolvido pela Nous Research (o laboratório por trás das famílias de modelos Hermes e Nomos), é um agente de IA de código aberto que roda no seu próprio hardware. Não é um simples wrapper de chatbot. Nem um plugin de IDE. É um agente autônomo completo com memória, agendamento, uso de ferramentas e um ciclo de aprendizado que melhora quanto mais tempo ele roda.

Isto não é um resumo de press-release. É um mergulho profundo e prático: o que o Hermes realmente faz, como configurá-lo, o que funciona bem, o que não funciona, e se vale a pena o seu tempo. Cada funcionalidade descrita aqui vem com um cenário de uso real que você pode testar hoje mesmo.

O que o Hermes Agent Realmente É

O Hermes Agent é um agente de IA auto-hospedado que reside no seu servidor (ou laptop, ou um VPS de $5) e conversa com você por meio de um terminal, Telegram, Discord, Slack, WhatsApp, Signal — mais de 15 plataformas a partir de um único processo de gateway. Ele usa qualquer LLM para o qual você o aponte: OpenAI, Anthropic, DeepSeek, Nous Portal, OpenRouter com mais de 200 modelos, ou seu próprio endpoint local.

O argumento que o torna diferente de "mais um framework de agente": ele tem um ciclo de aprendizado fechado. Ele se lembra das coisas entre as sessões, cria skills reutilizáveis a partir de tarefas complexas, aprimora essas skills com o uso e constrói um perfil sobre quem você é ao longo do tempo. A maioria dos agentes começa do zero a cada conversa. O Hermes acumula contexto.

Ele é licenciado sob MIT, o que é importante se você pretende construir algo sobre ele.

Números principais:

Mais de 73.600 estrelas no GitHub (em abril de 2026)
647 skills em 4 registros (79 integradas, 47 opcionais, 521 contribuições da comunidade)
Mais de 15 plataformas de mensagens suportadas por um único gateway
6 backends de terminal: local, Docker, SSH, Daytona, Singularity, Modal
Requisito mínimo de contexto: 64K tokens (modelos abaixo disso são rejeitados na inicialização)

Instalação: 60 Segundos, Sem Brincadeira

# Instalação em uma linha — Linux, macOS, WSL2 e até Android via Termux
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# Recarregue seu shell
source ~/.bashrc  # ou: source ~/.zshrc

# Comece a conversar
hermes

O instalador cuida de tudo: Python 3.11 (via uv, sem sudo), Node.js v22, ripgrep, ffmpeg. O único pré-requisito é o git.

Após a instalação, você tem um conjunto de comandos CLI que cobrem a maior parte da configuração:

hermes model    # Escolha seu provedor de LLM interativamente
hermes tools    # Ative/desative grupos de ferramentas
hermes setup    # Assistente de configuração completo (faz tudo de uma vez)
hermes gateway  # Inicia o gateway de mensagens
hermes doctor   # Diagnostica problemas
hermes update   # Atualiza para a versão mais recente

Funciona no Android também. O Termux tem um caminho de instalação dedicado com um extra .[termux] selecionado que pula as dependências de voz incompatíveis com o Android. Você pode literalmente rodar um agente de IA do seu celular.

Escolhendo um Provedor de Modelo

O Hermes não te prende a nenhum provedor. Execute hermes model e escolha na lista:

Provedor	O que é	Método de Autenticação
Nous Portal	Assinatura, sem configuração	Login OAuth
OpenAI Codex	OAuth do ChatGPT, modelos Codex	Autenticação por código de dispositivo
Anthropic	Modelos Claude diretamente	Autenticação Claude Code ou chave de API
OpenRouter	Mais de 200 modelos, multiprovedor	Chave de API
DeepSeek	API direta	Chave de API
GitHub Copilot	GPT-5.x, Claude, Gemini via Copilot	OAuth
Hugging Face	Mais de 20 modelos abertos	HF_TOKEN
Custom Endpoint	VLLM, SGLang, Ollama, qualquer compatível com OpenAI	URL base + chave

E mais: Z.AI/GLM, Kimi/Moonshot, MiniMax, Alibaba Cloud/DashScope, Arcee AI, entre outros.

A regra dos 64K: O Hermes exige pelo menos 64.000 tokens de contexto. Modelos com menos são rejeitados na inicialização. Isso faz sentido — fluxos de trabalho de chamadas de ferramentas com múltiplos passos consomem contexto rapidamente, e uma janela pequena significa que o agente perde o fio da meada no meio de uma tarefa. Se você está rodando um modelo local, defina --ctx-size 65536 ou maior.

Troque de provedor a qualquer momento com hermes model. Sem alterar código, sem aprisionamento tecnológico (lock-in).

O Sistema de Memória: Pequeno, Limitado e Deliberado

É aqui que o Hermes se diferencia da maioria dos frameworks de agentes. Em vez de despejar tudo em um banco de dados vetorial, o Hermes usa dois arquivos minúsculos com limite de caracteres:

Arquivo	Propósito	Limite
`MEMORY.md`	Anotações do agente — fatos do ambiente, convenções, lições aprendidas	2.200 caracteres (~800 tokens)
`USER.md`	Perfil do usuário — suas preferências, estilo de comunicação	1.375 caracteres (~500 tokens)

Ambos ficam em ~/.hermes/memories/ e são injetados no prompt do sistema como um snapshot congelado (frozen snapshot) no início da sessão.

Como a memória realmente funciona na prática:

══════════════════════════════════════════════
MEMORY (suas anotações pessoais) [67% — 1.474/2.200 caracteres]
══════════════════════════════════════════════
O projeto do usuário é um serviço web em Rust em ~/code/myapi usando Axum + SQLx
§Esta máquina roda Ubuntu 22.04, tem Docker e Podman instalados
§O usuário prefere respostas concisas, não gosta de explicações detalhadas

O agente gerencia sua própria memória através de três ações:

add — Armazenar um novo fato
replace — Atualizar uma entrada existente (correspondência de substring)
remove — Apagar algo que não é mais relevante

A pegadinha do snapshot congelado: Quando o Hermes escreve na memória durante uma sessão, as mudanças são salvas em disco imediatamente — mas elas não aparecerão no prompt do sistema até que a próxima sessão comece. Isso é intencional (preserva o cache de prefixo do LLM para performance), mas significa que o agente pode "esquecer" algo que acabou de aprender se você continuar conversando na mesma sessão.

Quando a memória enche, o agente recebe um erro com as entradas atuais e estatísticas de uso, e então precisa consolidar ou substituir entradas para liberar espaço. É como um ser humano com um caderno de apenas 15 linhas — você aprende a ser seletivo sobre o que anota.

O que salvar vs. o que pular:

✅ Salvar: Preferências do usuário, fatos do ambiente, convenções do projeto, correções, padrões de workflow
❌ Pular: Informações triviais, fatos facilmente pesquisáveis, blocos grandes de código, dados temporários específicos da sessão

Essa abordagem limitada é revigorante. A maioria dos sistemas de memória de agentes ou não tem limites (e se enchem de ruído) ou usa recuperação vetorial (que alucina relevância). O Hermes força a disciplina.

Skills: Memória Procedural que o Próprio Agente Cria

As skills são a resposta do Hermes para "como você melhora em tarefas recorrentes?". Quando o agente completa algo complexo, ele pode criar uma skill — essencialmente um arquivo SKILL.md com instruções para a próxima vez. As skills se autoaperfeiçoam com o uso.

O ecossistema é surpreendentemente grande: 647 skills em 4 registros. As integradas cobrem:

Agentes de codificação: Claude Code, Codex, OpenCode delegation
Ferramentas criativas: ASCII art, arte generativa com p5.js, animações matemáticas com Manim, diagramas com Excalidraw, diagramas de arquitetura
Integrações de plataforma: Apple Notes, Apple Reminders, FindMy, iMessage
Coisas divertidas: Configuração de servidor de modpack do Minecraft, jogador de Pokémon (sim, ele joga Pokémon autonomamente via emulação headless)
Design: 54 templates de design systems com qualidade de produção, extraídos de sites reais (Stripe, Linear, Vercel, Notion, Airbnb…)

As skills seguem o padrão aberto agentskills.io, então são portáteis e compartilháveis pela comunidade.

Cenário real: Você pede ao Hermes para configurar uma stack Docker Compose para uma aplicação Postgres + Redis + Node. Ele faz isso e, em seguida, cria uma skill chamada "docker-compose-setup" com o template, as pegadinhas comuns e as convenções de porta que descobriu. Da próxima vez que você pedir uma stack semelhante, ele carrega a skill e faz o trabalho na metade dos passos.

Ferramentas: 47 Integradas, Organizadas por Categoria

O Hermes vem com um amplo registro de ferramentas. Você ativa/desativa grupos com hermes tools:

Categoria	Exemplos	Para que serve
Web	`web_search`, `web_extract`	Pesquisar e extrair dados da web
Terminal e Arquivos	`terminal`, `process`, `read_file`, `patch`	Executar comandos, editar arquivos
Navegador	`browser_navigate`, `browser_snapshot`, `browser_vision`	Automação completa do navegador
Mídia	`vision_analyze`, `image_generate`, `text_to_speech`	Análise de imagem, geração, TTS
Orquestração de agente	`todo`, `execute_code`, `delegate_task`	Planejamento, subagentes, execução de código
Memória e recuperação	`memory`, `session_search`	Memória persistente, busca entre sessões
Automação	`cronjob`, `send_message`	Tarefas agendadas, envio de mensagens

Ativação/desativação rápida:

# Começar apenas com ferramentas de web e terminal
hermes chat --toolsets "web,terminal"

# Ou configurar interativamente
hermes tools

Backends de Terminal: Rode em Qualquer Lugar, com Segurança

Esta é uma das funcionalidades práticas mais fortes do Hermes. Você pode escolher onde os comandos de terminal do agente realmente são executados:

Backend	Caso de Uso
`local`	Padrão — roda na sua máquina
`docker`	Contêineres isolados — seguro para tarefas não confiáveis
`ssh`	Servidor remoto — o agente não pode tocar no próprio código
`daytona`	Sandbox na nuvem — persistente, hiberna quando ocioso
`modal`	Serverless — escalável, pague por uso
`singularity`	Contêineres HPC — computação em cluster sem root

# ~/.hermes/config.yaml
terminal:
  backend: docker
  docker_image: python:3.11-slim
  container_persistent: true  # pacotes sobrevivem entre sessões
  container_cpu: 1
  container_memory: 5120      # 5GB

O backend SSH é o ponto ideal de segurança: o agente trabalha em uma máquina remota e literalmente não pode modificar seu próprio código ou configuração. Os backends de contêiner (Docker, Singularity, Modal) adicionam ainda mais proteção (hardening): sistema de arquivos raiz somente leitura, todas as capabilities do Linux removidas, sem escalonamento de privilégios, limites de PID, isolamento completo de namespace.

Dica prática: Se você está rodando o Hermes em um VPS e dando a ele tarefas reais, comece com o backend docker. Se você confia nas tarefas mas quer separação, use ssh. Use local apenas para desenvolvimento ou para tarefas que você mesmo executaria.

Cron: Automação Agendada Integrada

O Hermes tem um agendador cron embutido. Nenhuma ferramenta externa é necessária. Crie tarefas em linguagem natural ou expressões cron, e os resultados são entregues em qualquer plataforma de mensagens.

# Do chat
/cron add "a cada 6h" "Verifique os repositórios em alta no GitHub em Python e resuma os 5 principais novos. Se não houver nada interessante, responda com [SILENT]." --name "GitHub watcher" --deliver telegram

# Da CLI
hermes cron create "0 9 * * 1" \
  "Gere um relatório semanal das principais notícias de IA, repositórios de ML em alta e os posts mais discutidos no HN." \
  --name "Weekly AI digest" \
  --deliver telegram

O ponto crucial a entender é: As tarefas do cron rodam em sessões de agente novas, sem memória da sua conversa atual. Os prompts devem ser completamente autocontidos. Isso confunde as pessoas — elas escrevem um prompt de cron como "faça aquilo que discutimos" e se perguntam por que o agente não tem ideia do que elas querem dizer.

O parâmetro --script é a jogada de mestre. Você pode anexar um script Python que roda antes de cada execução. Sua saída padrão (stdout) se torna contexto para o agente:

# ~/.hermes/scripts/watch-site.py
import hashlib, json, os, urllib.request

URL = "https://example.com/pricing"
STATE_FILE = os.path.expanduser("~/.hermes/scripts/.watch-state.json")

content = urllib.request.urlopen(URL, timeout=30).read().decode()
current_hash = hashlib.sha256(content.encode()).hexdigest()

# Carregar estado anterior
prev_hash = None
if os.path.exists(STATE_FILE):
    with open(STATE_FILE) as f:
        prev_hash = json.load(f).get("hash")

# Salvar estado atual
with open(STATE_FILE, "w") as f:
    json.dump({"hash": current_hash, "url": URL}, f)

if prev_hash and prev_hash != current_hash:
    print(f"CHANGE DETECTED on {URL}")
    print(f"Content preview:\n{content[:2000]}")
else:
    print("NO_CHANGE")

/cron add "a cada 1h" "Se o script disser CHANGE DETECTED, resuma o que mudou. Se disser NO_CHANGE, responda com [SILENT]." --script ~/.hermes/scripts/watch-site.py --name "Pricing monitor" --deliver telegram

O truque do [SILENT]: Quando a resposta do agente contém [SILENT], a entrega é suprimida. Você só é notificado quando algo realmente acontece. Sem spam.

Messaging Gateway: Converse com Ele do seu Celular

hermes gateway setup  # interativo — escolhe sua plataforma
hermes gateway        # inicia o processo do gateway

O Hermes suporta mais de 15 plataformas de mensagens a partir de um único gateway: Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, Email, SMS, DingTalk, Feishu, WeCom, BlueBubbles, Home Assistant e Open WebUI.

Exemplo de configuração do Telegram (o mais comum):

Crie um bot via @BotFather (/newbot)
Obtenha seu ID de usuário via @userinfobot
Execute hermes gateway setup, selecione Telegram, cole o token e o ID de usuário
Inicie o gateway: hermes gateway

É isso. Agora você pode conversar com seu agente pelo celular enquanto ele trabalha no seu servidor.

Mensagens de voz também funcionam — envie uma mensagem de voz no Telegram, o Hermes a transcreve automaticamente com o faster-whisper (roda localmente, de graça) e responde ao texto.

Dica para chats em grupo: Os bots do Telegram têm o modo de privacidade ativado por padrão — o bot só vê /commands e respostas diretas. Para permitir que ele veja todas as mensagens em um grupo, desative o modo de privacidade no BotFather ou promova o bot a administrador.

Integração MCP: Estenda com Ferramentas Externas

O Hermes suporta o Model Context Protocol (MCP) — conecte-se a qualquer servidor MCP para adicionar ferramentas:

# ~/.hermes/config.yaml
mcp:
  servers:
    - name: "github"
      command: "npx"
      args: ["-y", "@modelcontextprotocol/server-github"]
      env:
        GITHUB_TOKEN: "seu-token"

As ferramentas MCP aparecem junto com as ferramentas integradas. Você pode filtrar quais ferramentas MCP o agente pode usar para evitar sobrecarga de ferramentas.

Segurança: Sete Camadas de Profundidade

O Hermes tem um modelo genuíno de defesa em profundidade, não apenas um "adicionamos um prompt de aprovação":

Autorização de usuário — allowlists (listas de permissão) controlam quem pode falar com o agente
Aprovação de comandos perigosos — humano-no-ciclo (human-in-the-loop) para operações destrutivas (rm -rf, chmod 777, etc.)
Isolamento de contêiner — Docker/Singularity/Modal com configurações de segurança reforçadas (hardened)
Filtragem de credenciais MCP — isolamento de variáveis de ambiente para subprocessos MCP
Escaneamento de arquivos de contexto — detecção de prompt injection em arquivos de projeto
Isolamento entre sessões — sessões não podem acessar os dados umas das outras
Sanitização de entrada — parâmetros de diretório de trabalho validados contra a allowlist

Modos de aprovação:

# ~/.hermes/config.yaml
approvals:
  mode: manual   # manual | smart | off
  timeout: 60    # segundos antes da negação automática

manual (padrão): Sempre pergunta antes de comandos perigosos
smart: Usa um LLM auxiliar para avaliar o risco — aprova automaticamente os de baixo risco, nega automaticamente os perigosos e escala os incertos
off / --yolo: Ignora todas as verificações. Use apenas em CI/CD ou contêineres descartáveis.

O timeout é fail-closed: se você não responder em 60 segundos, o comando é negado. Não aprovado. Este é o padrão correto.

Subagentes: Delegue e Paralelize

O Hermes pode criar subagentes isolados para fluxos de trabalho paralelos:

❯ Pesquise estes três tópicos simultaneamente:
  1. Latest Rust async runtime benchmarks
  2. PostgreSQL 17 new features
  3. Best practices for LLM caching in production

Cada subagente tem sua própria sessão, ferramentas e contexto. Os resultados retornam para o agente pai. Isso é útil para tarefas que são naturalmente paralelas — pesquisa, processamento em lote, operações em múltiplos repositórios.

Você também pode usar execute_code para escrever scripts Python que chamam ferramentas via RPC, colapsando pipelines de múltiplos passos em turnos com custo zero de contexto.

Desvantagens Reais (A Parte Honesta)

Toda análise que só diz coisas boas é inútil. Aqui está o que realmente atrapalha:

1. A Memória é Minúscula e Exige Gerenciamento Ativo

2.200 caracteres para a memória do agente. 1.375 para o perfil do usuário. Isso dá um total de aproximadamente 20 entradas curtas. Para um assistente pessoal que deveria "crescer com você", atingir o limite é frustrantemente rápido. Você verá o agente gastando turnos para consolidar e substituir entradas de memória em vez de fazer o trabalho de

Hermes Agent Review 2026: O agente de IA que se auto-aprimora e realmente se lembra de você