Você tem três sessões do Hermes trabalhando em paralelo: uma de olho no CI, outra triando issues, outra redigindo o relatório semanal. Você encara o terminal e o dashboard, julgando “em que etapa está” pelos logs — você vê a saída, mas não vê ele. Agora imagine esses agentes como pessoas pequenas num escritório: quem está na mesa escrevendo código, quem está na sala de reunião para o standup, quem está movendo cartões no quadro — escaneável de relance em vez de vasculhar logs. Essa é a proposta.

É isso que o Hermes3D faz: um frontend open-source de escritório virtual 3D (MIT, 105 estrelas, do LukeTheDev) que transforma seus agentes do Hermes em personagens andando por um escritório compartilhado. É um projeto da comunidade (o README é explícito: não é afiliado às equipes de backend do agente), não executa agentes sozinho — é puramente a camada de visualização, conectando-se pelo gateway JSON-RPC do Hermes diretamente ou via um adaptador de gateway. Serve para desenvolvedores que querem ver sua equipe de agentes trabalhando. O projeto foi atualizado ativamente em 20 de agosto.

Como é na prática

O núcleo é um ambiente retro de escritório /office: todo agente conectado é um personagem se movendo por um mundo 3D compartilhado. Mas não é só um screensaver:

• Veja os agentes trabalhando em tempo real — quem está rodando qual tarefa, progresso de relance;
• Faça standups — agentes conectados ao GitHub e ao Jira fazem reuniões numa sala de conferência;
• Revise PRs — percorra pull requests de dentro do escritório;
• Mesa kanban — um quadro embutido que exibe os dados de hermes kanban do backend diretamente: arrastar um cartão para Working enfileira a tarefa como ready, só o dispatcher pode marcá-la como running, e o status é gravado de volta no Hermes;
• Treine skills na academia, e um sistema de zeladoria para resetar sessões e limpar contexto.

Em termos simples: o dashboard é o console de controle; o Hermes3D é o mirante de observação onde você entra dentro da sua equipe de agentes. Quer dar uma olhada antes? O repositório traz um gateway de demonstração embutido, então você pode passear pelo escritório sem instalar nenhum framework de agente.

Duas formas de conectar

O Hermes3D suporta três runtimes; dois interessam ao Hermes:

1. Hermes Agent (direto) — recomendado: o Studio fala o gateway JSON-RPC do Hermes por conta própria, sem processo adaptador. Requer um hermes serve em loopback no host do Hermes (Máquina A).
2. Hermes HTTP API + gateway adapter: npm run hermes-adapter inicia um adaptador que fala o protocolo WebSocket do gateway Hermes3D de um lado e chama a Hermes HTTP API (padrão http://localhost:8642) do outro. Bom quando o backend não é local ou você prefere o caminho da HTTP API.

Implantação em duas máquinas: o tutorial direto com Tailscale (o formato mais comum)

O formato canônico do tutorial oficial são duas máquinas: a Máquina A roda o backend do Hermes, a Máquina B roda o Hermes3D, e o Tailscale as conecta com segurança. A cadeia:

Browser <-> Studio server (Machine B) <-> Tailscale <-> hermes serve (Machine A)

Máquina A — o host do Hermes:

Passo um, fixe um token de sessão — o segredo compartilhado entre as duas máquinas, guardado sob um nome dedicado. Não mexa no HERMES_DASHBOARD_SESSION_TOKEN em si: o Hermes carrega ~/.hermes/.env com override=True, então fixá-lo sobrescreveria o token novo que o app do desktop cunha para o próprio backend a cada inicialização, e o app morre no boot:

echo "HERMES3D_OFFICE_TOKEN=$(openssl rand -hex 32)" >> ~/.hermes/.env

Passo dois, inicie o backend em loopback (--host 127.0.0.1 não é opcional: vincular ao endereço da tailnet liga o login gate e quebra a autenticação por token):

HERMES_DASHBOARD_SESSION_TOKEN="$(grep '^HERMES3D_OFFICE_TOKEN=' ~/.hermes/.env | cut -d= -f2)" \
  hermes serve --host 127.0.0.1 --port 9120 --skip-build

Passo três, publique na tailnet (a porta --https precisa estar realmente livre — se a 443 estiver ocupada, use 10000/8443):

tailscale serve --yes --bg --https=10000 http://127.0.0.1:9120

Verifique o túnel de ponta a ponta antes de tocar na Máquina B: curl -s -H "Host: localhost" https://<machine-a>.<tailnet>.ts.net:10000/api/status deve retornar JSON.

Passo quatro, mantenha rodando: macOS usa um plist do launchd, Linux uma unit do systemd por usuário, ambos lendo o token do .env na inicialização — o segredo fica fora das definições de serviço e fora do ps. O Tailscale Serve persiste entre reboots depois de configurado com --bg.

Máquina B — o host do Hermes3D:

git clone https://github.com/iamlukethedev/Hermes3D.git hermes3d
cd hermes3d && npm install && cp .env.example .env && npm run dev

Abra http://localhost:3000 e preencha a tela de conexão: Backend = Hermes Agent (direct), Gateway URL = wss://<machine-a>.<tailnet>.ts.net:10000 (dê a raiz do servidor, não /api/ws — o Studio acrescenta o caminho), Token = o do passo um. Você cai no escritório com um personagem por profile hermes-agent.

O limite de segurança (o autor é refrescantemente honesto)

• O token de sessão é uma credencial de portador para o seu agente inteiro — trate-o como uma API key: nunca faça commit, rotacione reiniciando com um valor novo;
• Nada é exposto à internet pública: hermes serve vincula ao loopback, e o Tailscale Serve publica apenas dentro da sua tailnet;
• Qualquer pessoa na sua tailnet que descubra o token pode alcançar o backend — use ACLs do Tailscale em tailnets com vários membros.

A tabela de troubleshooting também já vem pronta: wrong version number/EPROTO = wss:// contra uma porta de texto puro (use a porta --https); 403 = token não confere (funcionava até um restart geralmente significa que o token nunca foi fixado); 401 = você bateu no hermes dashboard com login gate em vez do hermes serve em loopback; 400 Invalid Host header = build antigo, atualize o Studio.

Vale a pena?

Se você roda várias sessões do Hermes regularmente e seu senso de “o que o agente está fazendo” vive no nível de rolar logs, o Hermes3D oferece uma perspectiva genuinamente diferente — e sua mesa kanban reutiliza os dados de hermes kanban que você já tem, com zero configuração extra. É um projeto jovem de 105 estrelas, mas o README, a documentação de arquitetura e o tutorial são escritos com cuidado incomum. Ainda assim, é um frontend da comunidade: o gateway JSON-RPC carrega a conexão, e o comportamento do agente em si, as permissões e os fluxos de aprovação não mudam em nada — sua configuração multi-profile e a orquestração ao vivo com subagents continuam funcionando exatamente como antes; você só ganha olhos. Para mais projetos do ecossistema, navegue pela nossa página do ecossistema.