Pular para o conteúdo
artigos
atualizado Hermes AgentDockerSelf-Hosted AIVPSDocker Swarm

Hermes Agent no Docker: setup, Compose e uma VPS de verdade

Setup do Hermes Agent no Docker com a imagem oficial, do docker run ao primeiro chat, e depois o que a imagem e o Compose trazem, HERMES_HOME, profiles, auth do dashboard, upgrade e as pegadinhas do Swarm numa VPS.

Para rodar o Hermes Agent no Docker, use a imagem oficial nousresearch/hermes-agent. Monte um diretório do host em /opt/data (esse é o HERMES_HOME: config, API keys, memória, skills, state.db), rode o wizard setup uma vez e depois suba o container com gateway run. Com HERMES_DASHBOARD=1, o dashboard web sobe na porta 9119 no mesmo container.

Eu rodo o Hermes headless num Docker Swarm numa VPS. O quick start abaixo é o caminho oficial; tudo depois dele é o que o caminho oficial não conta, incluindo seis pegadinhas que me custaram tempo de verdade.

Quick start: do docker run ao primeiro chat

Estes comandos vêm da doc oficial de Docker do Hermes (conferida em 13/10/2026), na ordem em que você roda. Rode por SSH, não pelo console web do provedor: a doc avisa que esses consoles trocam : e @, o que quebra em silêncio o -v ~/.hermes:/opt/data e as API keys coladas.

Hermes Agent no Docker, primeira execução

  1. 1. Crie o diretório de dados no host

    mkdir -p ~/.hermes
  2. 2. Rode o wizard de setup uma vez (grava as keys em ~/.hermes/.env)

    docker run -it --rm -v ~/.hermes:/opt/data nousresearch/hermes-agent setup
  3. 3. Suba o gateway em background

    docker run -d --name hermes --restart unless-stopped -v ~/.hermes:/opt/data -p 8642:8642 nousresearch/hermes-agent gateway run
  4. 4. Confira se subiu

    docker logs --tail 50 hermes
  5. 5. Abra um chat contra o mesmo diretório de dados

    docker run -it --rm -v ~/.hermes:/opt/data nousresearch/hermes-agent

O wizard pede uma key de provedor de modelo e, de preferência, uma plataforma de chat (Telegram, Discord, Slack) para o gateway escutar. A porta 8642 é a API compatível com OpenAI e o endpoint de health do gateway: opcional se você só fala com o Hermes por um app de chat, obrigatória se o dashboard ou um cliente externo precisa alcançá-lo. Dentro da imagem oficial o gateway roda supervisionado pelo s6, então um crash reinicia o processo em poucos segundos sem derrubar o container.

Tags: latest e stable apontam para o build que passou pelo gate de release estável. Em 13/10/2026 era a v0.21.7, lançada em 12 de outubro (Docker Hub, release notes). Existem tags por versão (v0.21.6), mas a v0.21.7 só saiu como stable, latest e a tag de release candidate, então o pin confiável é um digest, não uma string de versão. main é o build de desenvolvimento. Não rode isso numa máquina da qual você depende.

Compose: um serviço, ou os dois do repo

A doc da Nous e o repo discordam no formato, e os dois estão certos. A doc roda um container só: o gateway e o dashboard como um segundo serviço do s6, ligado por HERMES_DASHBOARD=1:

services:
  hermes:
    image: nousresearch/hermes-agent:latest
    container_name: hermes
    restart: unless-stopped
    command: gateway run
    ports:
      - "8642:8642" # gateway API
      - "9119:9119" # dashboard (only reached when HERMES_DASHBOARD=1)
    volumes:
      - ~/.hermes:/opt/data
    environment:
      - HERMES_DASHBOARD=1
    deploy:
      resources:
        limits:
          memory: 4G
          cpus: "2.0"

Suba com docker compose up -d. Use esse, a menos que tenha um motivo para não usar. O docker-compose.yml do próprio repo (lido mais abaixo) roda o dashboard num container separado, o que a doc só suporta quando ele compartilha o namespace de PID e de rede do host, como o arquivo do repo faz com network_mode: host. O dashboard detecta se o gateway está vivo olhando o processo dele, então um container de dashboard isolado numa rede bridge não enxerga o gateway.

Um detalhe antes de expor a 9119: dentro do container o dashboard escuta em 0.0.0.0 por padrão, e um bind fora do loopback sem provedor de auth se recusa a subir. É de propósito. A seção de auth mais abaixo mostra o que configurar.

O Hermes Desktop, o app nativo, conecta nesse mesmo backend do dashboard pela configuração Remote Gateway, na porta 9119. Uma conexão cobre todos os profiles do container pelo seletor de profile do app.

O que a imagem Docker do Hermes Agent realmente traz

O Dockerfile publicado parte de debian:13.4, fixado pelo digest sha256 em vez de uma tag, porque o resto do build (um uv fixado, um Chromium fixado) já vem de um lock verificado por sha, e uma imagem base flutuante ia derivar embaixo deles. O primeiro estágio do build compila o SQLite 3.53.4 a partir do código-fonte e empacota esse .so em vez do 3.46.1 que vem junto com o Debian 13, que ainda carrega o bug de corrupção no reset do WAL do upstream. Se você já viu uma instalação do Hermes reclamar de um state.db corrompido num pacote de SQLite da distro, é por isso que a imagem do container evita isso completamente.

O PID 1 dentro do container é o s6-overlay, não o tini. O tini costumava recolher os processos zombie que se acumulam quando o Hermes gera subprocessos stdio de MCP, git ou bun como PID 1; o s6-overlay faz essa mesma coleta sem bloquear e, além disso, supervisiona o processo principal do Hermes, o dashboard e os gateways por profile como serviços nomeados dentro de /etc/s6-overlay/s6-rc.d/. Um shim fino de compatibilidade em /usr/bin/tini ainda existe para templates de orquestração que fixam o entrypoint antigo no código, mas ele só remove as flags de CLI do tini e reexecuta /init.

O ENTRYPOINT em si não é mais o /init. É um dispatcher pequeno, /opt/hermes/docker/entrypoint-dispatch.sh. Quando o container é dono do PID 1, o caso normal de Docker e Podman, ele faz exec do /init e você ganha a árvore do s6 inteira. Quando a plataforma coloca o próprio init acima dele (Fly.io Machines, docker run --init, alguns setups de Nomad e Kubernetes), o /init abortaria com can only run as pid 1, então o dispatcher roda o hook de setup e o seu comando direto. O comando funciona. O dashboard e os gateways por profile não rodam nesse caminho, porque nada os supervisiona. Se um Compose sobrescreve entrypoint: para chamar o hermes direto, você perde também o coletor de zombies; a doc relata um deploy com 284 processos zombie em menos de três horas. Mantenha o entrypoint padrão. (O comentário do docker-compose.yml do repo ainda cita o entrypoint antigo ["/init", "/opt/hermes/docker/main-wrapper.sh"]; a fonte de verdade é o Dockerfile.)

O container roda como um usuário hermes não-root, UID 10000 por padrão, sobrescrevível na inicialização com HERMES_UID e HERMES_GID, para que os arquivos que ele escreve fiquem com o dono que for o usuário real do host. O HERMES_HOME fica fixado em /opt/data, e esse é o único caminho declarado como VOLUME. Tudo o resto dentro de /opt/hermes, o venv, o bundle do frontend, a instalação em si, é copiado como somente leitura (--chmod=a+rX,go-w) e pertence ao root. Essa separação importa mais adiante: o código é imutável, o volume de dados é a única coisa que você precisa preservar.

Um default é fácil de assumir errado: colocar o Hermes num container não coloca, por si só, o que ele roda num sandbox. O backend de execução de ferramentas usa local por padrão, o que significa que um comando de shell que o agente roda executa dentro desse mesmo container, com o mesmo filesystem e o mesmo network namespace do próprio Hermes. A imagem instala o pacote docker-cli como dependência de sistema exatamente para o caso em que você quer mais isolamento que isso: aponte uma tarefa para o backend docker em vez disso, e o Hermes chama essa CLI para lançar um container irmão em sandbox (cap-drop all, sem novos privilégios, limites de recurso) e roda o comando ali dentro. O jeito usual de ligar isso de dentro de um container é montando o socket do Docker do host dentro do container do Hermes. Local é o padrão. Descartável é uma escolha que você faz por tarefa.

O Docker Compose do repo, lido direto

O docker-compose.yml do repo faz build a partir do código (build: .) e roda dois serviços, não um. Para usar a imagem publicada, tire o build: . e aponte as duas linhas image: para nousresearch/hermes-agent:stable:

services:
  gateway:
    build: .
    image: hermes-agent
    container_name: hermes
    restart: unless-stopped
    network_mode: host
    volumes:
      - ~/.hermes:/opt/data
    environment:
      - HERMES_UID=${HERMES_UID:-10000}
      - HERMES_GID=${HERMES_GID:-10000}
    command: ["gateway", "run"]

  dashboard:
    image: hermes-agent
    container_name: hermes-dashboard
    restart: unless-stopped
    network_mode: host
    depends_on:
      - gateway
    volumes:
      - ~/.hermes:/opt/data
    environment:
      - HERMES_UID=${HERMES_UID:-10000}
      - HERMES_GID=${HERMES_GID:-10000}
    command: ["dashboard", "--host", "127.0.0.1", "--no-open"]

Essa é a forma, cortada dos blocos comentados para credenciais do Microsoft Teams e do Google Chat, que são chaves reais dentro do arquivo (TEAMS_CLIENT_ID, GOOGLE_CHAT_SERVICE_ACCOUNT_JSON, e o resto), só que opcionais. Os dois serviços montam o mesmo caminho do host em /opt/data, os dois rodam com o mesmo UID remapeado, e o gateway e o dashboard são, de propósito, containers separados compartilhando um único volume de dados em vez de um processo só fazendo as duas coisas.

O próprio comentário no topo do arquivo diz como rodar, passando os IDs do seu usuário do host para que o que é seu continue seu dentro do container também:

Subir a stack

  1. Gateway + dashboard

    HERMES_UID=$(id -u) HERMES_GID=$(id -g) docker compose up -d

As notas de segurança dele valem a leitura ao pé da letra, porque são os dois erros que o pessoal realmente comete: o dashboard escuta em 127.0.0.1 por design, já que guarda API keys, e o comentário é explícito que acesso remoto deveria passar por um túnel SSH ou um reverse proxy que adiciona autenticação, nunca passando --insecure --host 0.0.0.0. Essa última parte perdeu o sentido: desde o hardening de junho de 2026, --insecure e HERMES_DASHBOARD_INSECURE não fazem nada (a env var registra um aviso e é ignorada), e um bind fora do loopback sem provedor de auth falha fechado na inicialização. A doc explica o porquê: dashboards expostos e sem autenticação foram a porta de entrada de uma campanha em junho de 2026 que levou agentes a plantar um backdoor de chave SSH. Qualquer guia que ainda manda passar --insecure está desatualizado. A segunda nota é sobre o servidor de API compatível com OpenAI, que fica desligado a menos que você descomente API_SERVER_HOST e API_SERVER_KEY juntos, porque a key é obrigatória no momento em que o servidor fica alcançável além do localhost. A doc atual também exige API_SERVER_ENABLED=true.

Persistindo o HERMES_HOME, e profiles para instâncias isoladas

Tudo que faz uma instalação do Hermes ser sua vive dentro de HERMES_HOME: config.yaml, SOUL.md, MEMORY.md e USER.md, a pasta skills/, e state.db. Monte esse diretório único e um rebuild de container não perde nada. Perca esse mount e você tem uma instalação nova, sem memória nenhuma de ter rodado algum dia.

Uma pegadinha de filesystem em notebook: o state.db roda em modo WAL do SQLite, e bind mounts que atravessam a fronteira de uma VM (virtiofs no Docker Desktop para macOS e no OrbStack, 9p no Docker Desktop para Windows) podem deixar escritores concorrentes corromperem o banco enquanto o arquivo ainda passa num integrity check. Desde a v2026.9.14 o Hermes cria um banco novo nesses mounts em modo rollback, e o hermes doctor sinaliza um banco WAL já existente. No Mac, a correção limpa é um volume nomeado (-v hermes-data:/opt/data). Numa VPS Linux com bind mount comum, isso não se aplica.

Se você quer mais de um agente na mesma máquina, o Hermes chama isso de profile, e é um conceito de primeira classe, não um workaround. Dentro do container do gateway rodando:

Criar um profile isolado

  1. Criar

    hermes profile create coder
  2. Usar

    coder setup

Isso cria ~/.hermes/profiles/coder/ com seu próprio config.yaml, .env, SOUL.md e state.db, e também monta um comando coder, um atalho para hermes -p coder. Um profile de assistente pessoal e um profile de coding agent na mesma máquina nunca compartilham memória, nunca compartilham skills, e nunca escrevem no system prompt um do outro por acidente, que é a coisa que realmente dá errado quando dois agentes compartilham uma home.

A imagem Docker já é planejada exatamente para isso. O Dockerfile declara serviços s6 estáticos para o processo principal do Hermes e o dashboard em tempo de build, mas os serviços de gateway por profile são registrados dinamicamente em runtime dentro de /run/service/, que é tmpfs e é limpo em todo restart de container. Um script de cont-init.d chamado 02-reconcile-profiles roda antes de qualquer outra coisa começar e reconstrói esses slots de serviço lendo $HERMES_HOME/profiles/<name>/ direto do volume montado. Na prática: um container, um volume, tantas instâncias isoladas do Hermes quantos profiles você tiver, sobrevivendo a um restart sem você tocar em nada.

A web UI e o dashboard do Hermes Agent, atrás de auth

Fora de um container, o dashboard escuta em loopback. Dentro da imagem oficial ele escuta em 0.0.0.0 para que um -p 9119:9119 publicado funcione, e esse bind fora do loopback liga o gate de auth: sem provedor de auth registrado, não tem dashboard. A doc lista três provedores embutidos:

Provedores de auth do dashboard na imagem oficial

ProvedorComo ligarServe para
Usuário e senhaHERMES_DASHBOARD_BASIC_AUTH_USERNAME + _PASSWORD (+ _SECRET para a sessão sobreviver a um restart)Homelab ou máquina atrás de VPN. A doc diz: não para a internet aberta
OAuth (Nous Portal)HERMES_DASHBOARD_OAUTH_CLIENT_IDDeploys hospedados e públicos
OIDC self-hostedHERMES_DASHBOARD_OIDC_ISSUER + HERMES_DASHBOARD_OIDC_CLIENT_IDO seu próprio provedor de identidade

As chaves de basic auth também existem no config.yaml em dashboard.basic_auth (username, password ou password_hash, secret); as env vars ganham quando estão definidas. A outra saída é HERMES_DASHBOARD_HOST=127.0.0.1 e um túnel SSH ou Tailscale.

Se um reverse proxy como o Traefik roda em outro container, o dashboard não confia no endereço bridge dele por padrão. Diga em qual proxy acreditar no config.yaml montado, com um IP exato ou um CIDR limitado (o Hermes rejeita * e 0.0.0.0/0):

dashboard:
  public_url: "https://dashboard.example.com"
  trusted_proxies:
    - "172.20.0.5"

Aqui está a pegadinha, e ela não é específica do Hermes. A API nativa de WebSocket do navegador não tem jeito de definir um header Authorization no handshake. Se um reverse proxy na frente do dashboard trava todo caminho, incluindo os de WebSocket, com basic auth, as requisições HTTP normais do navegador passam (o navegador reenvia a credencial), mas o upgrade de WebSocket nunca carrega ela, e a UI trava em “Connecting” para sempre. Eu bati nisso rodando o Hermes atrás do Traefik: a correção foi um segundo router do Traefik restrito só ao caminho do WebSocket, autenticado com um parâmetro de query ?token= em vez de basic auth, contornando o primeiro router completamente. A mesma pegadinha atingiu a web UI do OpenClaw quando eu avaliei ele na mesma semana, e é assim que eu sei que é um padrão na borda, não um bug de nenhum dos dois projetos.

O próprio código do Hermes desde então formalizou essa mesma separação uma camada mais abaixo, dentro do próprio processo do dashboard. No modo com portão, um upgrade de WebSocket nunca aceita o token de sessão simples do dashboard; um comentário no código é explícito que uma constante vazada não deve, por si só, dar acesso. Em vez disso, o navegador gera um ticket de uso único com TTL de 30 segundos e apresenta ele como um parâmetro de query ?ticket= ou um subprotocolo hermes-gateway-ticket.<ticket>, um processo filho gerado pelo servidor recebe, em vez disso, uma credencial ?internal= de vida mais longa, e uma sessão autenticada pode recorrer a um ?token= verificado pelo provider, o mesmo caminho de verificação que o bearer auth da REST API usa. Nenhum dos três é um header, porque um header é exatamente o que um handshake de WebSocket não consegue carregar de forma confiável. A própria nota de histórico do código diz isso sem rodeios: antes desse caminho de ticket existir, o upgrade de WebSocket do modo com portão não aceitava credencial nenhuma, e simplesmente falhava fechado.

A lição vai além do Hermes. Toda vez que você colocar auth no estilo sessão na frente de uma conexão de vida longa, confira se essa conexão é um WebSocket antes de assumir que a camada de auth cobre ela. Se você está fazendo o proxy do dashboard por conta própria, dê ao caminho do WebSocket a própria rota de token em vez de confiar que o basic auth vai acompanhar o upgrade.

Meu swarm: bento, Traefik, Portainer

O meu Hermes roda numa VPS que eu transformei num Docker Swarm com o bento, meu próprio instalador, que configura Traefik e Portainer na frente de qualquer coisa que você faz deploy. O Hermes roda headless nesse swarm, gateway do Telegram ligado, nenhuma aba de navegador jamais aberta na própria máquina. O arquivo Compose acima é a forma de host único; o Swarm muda algumas coisas quando você faz deploy como stack, e o Portainer passa a ser por onde você redeploya em vez de docker compose up direto.

As pegadinhas que custaram tempo de verdade

Nenhuma dessas aparece numa demo. Todas apareceram numa VPS real.

Sintoma, causa real, correção

O que você vêO que está acontecendo de verdadeO que resolveu
Um container chamando o próprio hostname público dá timeoutuserland-proxy: false derruba o caminho de hairpin NAT numa VPS de IP único; o pacote sai pela interface pública e nunca roteia de voltaRemover a chave. O default true do Docker é a configuração correta aqui
Um serviço no mesmo host leva cerca de 130 segundos para responder, não menos de umChamar um container pelo FQDN público roteia através de TLS em loopback em vez da rede internaChamar pelo nome de serviço interno, não pelo hostname público
Um container simplesmente desaparece, sem erro no próprio logO kernel matou ele por OOM. O orquestrador só vê process_lost com exit code nulodmesg | grep oom é o log de verdade. Nada que o Docker imprime nomeia isso
Uma chamada ao provider falha com erro de credencial duplicadaO SDK define um header de auth a partir de uma env var e um header explícito define um segundoEscolher uma única fonte para a credencial, nunca as duas ao mesmo tempo
Um serviço fica em 0/1 replicas e o proxy retorna 404docker restart numa task do Swarm orfaniza ela em vez de reagendardocker service update --force <service>. Nunca docker restart numa task direto
agent.log lança Permission deniedUm diagnóstico rodado como root dentro do container deixou arquivos de root num diretório que o usuário do serviço não consegue tocarchown dos arquivos afetados de volta para o UID do serviço (10000 por padrão)

As duas correções que vale a pena ter à mão, as mesmas duas sempre:

Os dois comandos que você realmente roda

  • Redeployar um serviço do Swarm, nunca reiniciar uma task

    docker service update --force <service>
  • Corrigir arquivos de root dentro de HERMES_HOME

    chown -R 10000:10000 /opt/data

Mais um padrão que não é bug, só vale nomear. Quando outro container na mesma máquina precisa do binário do Hermes, a resposta não é uma segunda imagem. Enxertar os próprios volumes da instalação já rodando no container do outro serviço dá a ele o binário e os dados sem rebuild. É assim que os containers da minha empresa de agentes no Paperclip chamam o Hermes: os volumes são enxertados pelo instalador do bento depois que as duas stacks já estão deployadas, já que o Compose por si só não tem um jeito limpo de expressar “monta o volume dessa outra stack” quando a ordem de deploy entre as duas stacks não é fixa.

Melhor VPS para o Hermes Agent: requisitos, não marcas

Não tem provedor que eu nomearia aqui, e uma lista de “melhor VPS” é, na maior parte, copy de afiliado vestida de review. O que realmente importa, em ordem:

O que um host para o Hermes Agent realmente precisa

  • Um único IP público sobre o qual você controla o comportamento de NAT do DockerVPS de IP único mais userland-proxy: false é exatamente a combinação que quebra o hairpin NAT. Saiba qual das duas você está alugando antes de tocar nessa configuração.
  • Margem de memória independente da própria carga de trabalho do agenteO dashboard tem um memory leak aberto ligado a sessões ao vivo, não a tempo ocioso, e já chegou a múltiplos gigabytes em uma hora numa instalação real. Dimensione esse processo separadamente do gateway. A doc coloca o mínimo em 1 GB e recomenda de 2 a 4 GB, pelo menos 2 GB quando as ferramentas de browser rodam.
  • Suporte a Swarm ou Compose, e um usuário de serviço não-rootA imagem já desce para o UID 10000 para você. Um host que força tudo por root desfaz essa proteção na primeira vez que alguém roda um comando pontual como root dentro do container.
  • Acesso por chave SSH, não um console só de navegadorTudo aqui, o arquivo Compose, os comandos do Swarm, as correções de chown, assume um shell de verdade. Um console de provedor que só dá um terminal web torna cada uma dessas pegadinhas mais lenta de corrigir.
  • Armazenamento em bloco persistente que você realmente faz backupHERMES_HOME é o único volume que importa. Se o armazenamento do host desaparece junto com a instância, todo profile nela desaparece também.
Hospedagem do Hermes Agent é um checklist curto, não uma comparação de provedores.

Upgrade sem perder nada

A imagem não guarda estado. Tudo que importa está em /opt/data, então um upgrade é pull, recriar, pronto. No primeiro boot do container novo, o Hermes roda as migrações de schema contra o config.yaml montado e grava backups com timestamp do config.yaml e do .env antes de mexer em qualquer um. Eu ainda faço a minha própria cópia do diretório inteiro antes, porque esses backups não cobrem o state.db nem a memória.

Upgrade da imagem oficial

  1. Backup do HERMES_HOME antes (hábito meu, não um passo da doc)

    tar czf hermes-backup-$(date +%F).tgz -C ~ .hermes
  2. Compose: puxe a imagem nova

    docker compose pull
  3. Compose: recrie o container

    docker compose up -d
  4. Confira a versão em que você está agora

    docker run -it --rm nousresearch/hermes-agent:latest --version

Os gateways que estavam rodando voltam sozinhos: o reconciler de boot reinicia todo profile cujo último estado registrado era running. Só um gateway que você parou com hermes gateway stop fica parado. Defina HERMES_SKIP_CONFIG_MIGRATION=1 se quiser ler a migração antes que a imagem nova reescreva a sua config.

Fixe uma versão, depois leia as release notes

O dashboard carrega o próprio bug aberto. A issue #80527, ainda aberta e marcada como P2 em 13/10/2026, reporta o processo dele crescendo sem limite enquanto serve sessões ao vivo, de uma base estável de cerca de 250 MB até 6,3 GB numa ocorrência e 7,6 GB, com o swap totalmente esgotado, em outra, as duas terminando num OOM kill que derrubou todo cliente conectado através dele. Quem reportou rastreou a causa provável até tui_gateway/server.py: a transcrição bruta da sessão é mantida em memória para resume e durabilidade mesmo depois que a compressão de contexto substitui o que o próprio agente vê, e uma sessão longa com saída pesada de ferramenta faz essa cópia retida crescer sem limite de tamanho. O mesmo dashboard sem sessão ativa fica estável em torno de 290 MB, então o leak só aparece depois que você realmente usa a UI por um tempo.

Dois pull requests abertos atacam o problema: o #100131, um watchdog de memória dentro do processo que sai de forma controlada antes do OOM kill do kernel, e o #63551, uma correção para o reaper de sessões ociosas, que nunca dispara enquanto um cliente continua conectado. Nenhum dos dois estava merged em 13/10/2026.

Até uma correção entrar, a regra de operação é chata de propósito: fixe o digest de imagem que você testou, leia as notas antes de atualizar, e numa VPS com memória restrita, não deixe uma sessão longa de dashboard aberta sem supervisão por horas. Reinicie o dashboard numa agenda se precisar deixar rodando. O processo do gateway, onde vivem os seus gateways de chat e os cron jobs, não é o que tem esse bug.

Hermes Agent no Docker, respostas rápidas

Dá para rodar o Hermes Agent no Docker?

Dá. A Nous Research publica uma imagem oficial, nousresearch/hermes-agent (tags stable e latest, v0.21.7 em 13/10/2026). Monte um diretório do host em /opt/data, rode a imagem com setup uma vez e depois com gateway run. Defina HERMES_DASHBOARD=1 para ganhar o dashboard na porta 9119. A imagem roda sob s6-overlay como usuário não-root.

Como eu persisto os dados do Hermes Agent no Docker?

Monte um caminho do host em /opt/data, que é onde o HERMES_HOME vive dentro do container (o compose que vem no projeto usa ~/.hermes:/opt/data). Esse volume único guarda config.yaml, SOUL.md, memória, skills e state.db. Tudo o resto na imagem é substituível.

Por que o dashboard do Hermes Agent trava em Connecting?

Na maioria das vezes é um reverse proxy travando o dashboard com basic auth na frente do caminho de WebSocket. Navegadores não conseguem enviar um header Authorization num upgrade de WebSocket, então as rotas HTTP normais autenticam bem e a rota de WebSocket trava para sempre. Dê ao caminho de WebSocket a própria rota baseada em token em vez de basic auth.

Qual é a melhor VPS para o Hermes Agent?

Não tem resposta de marca. O que importa é um único IP público sobre o qual você entende as configurações de NAT do Docker, margem de memória dimensionada para o processo do dashboard separadamente da carga do agente, suporte a Swarm ou Compose com um usuário de serviço não-root, acesso SSH real, e armazenamento persistente do qual você faz backup.

Dá para rodar várias instâncias do Hermes Agent numa VPS só?

Dá, através de profiles. hermes profile create <name> dá a cada instância o próprio diretório home, config, memória e banco de estado dentro de HERMES_HOME/profiles/, e a imagem Docker reconcilia os serviços de gateway por profile a partir desse diretório em todo restart de container.