Cómo montar tu propio agente de IA always-on con Hermes

La mayoría usa la IA abriendo un chat, preguntando algo y copiando la respuesta. Eso es un buscador con mejor conversación. El salto real pasa cuando el agente tiene herramientas, memoria y corre solo, sin que tú estés presente.

Hermes es un agente open-source de Nous Research que hace exactamente eso: corre en tu terminal, en plataformas de mensajería y en tu propia infraestructura, con acceso real a tu sistema. Esta guía te lleva de cero a un agente corriendo 24/7 en la nube, conectado a tu WhatsApp o Telegram, usando la imagen oficial. No necesitas ser DevOps — si te defiendes con una terminal, te alcanza.

Tabla de contenidos

1. El modelo mental: harness, no chatbot
2. Instalación local
3. Qué modelo usar (incluidos gratis)
4. Por qué moverlo a la nube
5. Deploy en Railway con la imagen oficial
6. El volumen: dónde vive tu agente
7. Conectar WhatsApp o Telegram
8. Resumen — el setup mínimo viable

El modelo mental: harness, no chatbot

Antes de instalar nada, conviene entender qué hace distinto a Hermes. El modelo de lenguaje es solo el motor. Lo que lo convierte en un agente útil es el harness que lo rodea: la capa que le da manos, memoria y la capacidad de actuar sin ti.

• Herramientas (tools) — terminal, sistema de archivos, búsqueda web, browser, ejecución de código. El agente no te habla de código: abre el repo y manda el Pull Request. No te describe un archivo: lo lee, lo edita y lo guarda.
• Memoria persistente — recuerda quién eres, tus proyectos y tus decisiones entre sesiones. No empiezas de cero cada vez.
• Skills — procedimientos reutilizables que el agente aprende una vez y vuelve a aplicar: revisar un PR, publicar un post, desplegar a producción.
• Autonomía (cron) — tareas programadas que corren sin que estés presente: un resumen cada mañana, un vigilante de precios, un clasificador de correos.
• Gateway multiplataforma — el mismo agente, con la misma memoria, en WhatsApp, Telegram, Discord o tu terminal.

Para eso sirve el harness: convierte un modelo que responde en un sistema que hace. Y por eso tiene sentido hostearlo en la nube — para que ese sistema esté disponible 24/7, no solo cuando tu laptop está abierta.

Instalación local

Empieza siempre local para probar. La instalación es un comando:

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

Después configuras el modelo y las API keys con el wizard interactivo:

hermes setup          # wizard guiado: modelo, terminal, gateway, tools
hermes model          # elegir o cambiar modelo/proveedor
hermes doctor         # verificar dependencias y config

Para una primera prueba en modo interactivo:

hermes                                            # chat interactivo
hermes chat -q "resume este repo en 5 bullets"   # query única

La configuración vive en archivos sencillos dentro de ~/.hermes/:

Guárdate la ubicación: cuando lo lleves a la nube, esto —no el código— es lo que persiste en el volumen.

Qué modelo usar (incluidos gratis)

Hermes es agnóstico de proveedor: el motor lo eliges tú, y puedes cambiarlo cuando quieras con hermes model. Lo más interesante es que no estás atado a uno — puedes apilar varios en un pool y dejar que Hermes rote entre ellos.

Algunas opciones que valen la pena para empezar:

• OpenAI con tu plan de ChatGPT ($20/mes). Si ya pagas ChatGPT Plus, lo conectas vía el proveedor OpenAI Codex (login OAuth con tu cuenta, usa los modelos Codex). Te da muy buenos límites sin pagar por token aparte — de lo más rentable para un agente personal.
• NVIDIA — modelos gratis. Los modelos Nemotron de NVIDIA están disponibles vía build.nvidia.com con un NVIDIA_API_KEY gratuito. Modelos frontier abiertos, sin costo, ideales para no quemar presupuesto en tareas de fondo.
• OpenRouter. Un solo API key que enruta a cientos de modelos (Claude, Gemini, DeepSeek, Qwen…). Perfecto cuando quieres probar varios sin abrir cuenta en cada proveedor. Es el default de Hermes.
• Kimi / Moonshot. Modelos de chat y coding muy capaces, con un KIMI_API_KEY.
• Ollama. Si quieres correr modelos locales en tu propia máquina (privacidad total, cero costo de API), Hermes se conecta a Ollama como cualquier otro proveedor. Solo recuerda darle al menos 64K de contexto (-c 65536).

# ~/.hermes/config.yaml — un pool de modelos con respaldos
fallback_providers:
  - provider: nvidia
    model: nvidia/nemotron-3-ultra
  - provider: openai-codex
    model: gpt-5-codex
  - provider: openrouter
    model: anthropic/claude-sonnet-4

Requisito único: el modelo necesita al menos 64.000 tokens de contexto. Casi todos los hosteados (Claude, GPT, Gemini, Qwen, DeepSeek) lo cumplen de sobra.

Por qué moverlo a la nube

Local funciona, pero tiene un límite: el agente solo existe mientras tu máquina está encendida. Si quieres que las tareas programadas corran de madrugada, que el bot responda siempre y que el agente sobreviva a reinicios y a que cierres la laptop, necesitas un host always-on.

Elegí Railway porque es de lo más simple: despliega una imagen Docker con un volumen persistente, sin administrar un VPS a mano. Y como Hermes ya publica una imagen oficial, no tienes que construir nada.

Deploy en Railway con la imagen oficial

La clave de este setup: la imagen oficial nousresearch/hermes-agent ya trae todo —Hermes, los bridges de WhatsApp y Telegram, y supervisión con s6-overlay (auto-restart si algo crashea). No escribes un Dockerfile; despliegas la imagen tal cual.

La ruta más sencilla es por el dashboard de Railway:

1. New Project → Deploy from Docker Image.
2. Imagen: nousresearch/hermes-agent:latest.
3. Add Volume, mount path: /opt/data (ahí vive el estado del agente).
4. En Variables, agrega tu API key del proveedor y los canales que quieras, por ejemplo:
   • ANTHROPIC_API_KEY=... (o OPENROUTER_API_KEY, NVIDIA_API_KEY, etc.)
   • TELEGRAM_BOT_TOKEN=... para conectar Telegram
5. Deploy y abre los logs.

Si prefieres la terminal, el CLI de Railway hace lo mismo:

railway init                                  # nombre, ej: hermes-gateway
railway add --service hermes \
  --image nousresearch/hermes-agent:latest    # ← imagen oficial, sin build
railway volume add --mount-path /opt/data     # volumen persistente
railway variables --set "ANTHROPIC_API_KEY=..." \
                  --set "TELEGRAM_BOT_TOKEN=..."
railway up
railway logs                                  # esperar "connected"

Una vez arriba, configura el modelo conectándote por SSH al contenedor y corriendo el wizard una sola vez (queda guardado en el volumen):

railway ssh
hermes setup     # elige proveedor/modelo; se escribe en /opt/data

A partir de ahí, s6-overlay mantiene el proceso vivo: si el gateway crashea, se reinicia solo.

El volumen: dónde vive tu agente

El volumen montado en /opt/data es el ~/.hermes del contenedor: ahí quedan tu config.yaml, tu state.db (memoria + sesiones), tus skills y la sesión de mensajería. Sobrevive a redeploys y reinicios, así que tu agente no pierde la memoria cada vez que actualizas.

Si arrancas desde cero, no tienes que migrar nada: configuras directo en el contenedor y listo.

# en tu máquina local
cd ~/.hermes
tar -czf /tmp/hermes-state.tgz \
  --exclude='./logs' --exclude='./cache' \
  config.yaml .env state.db auth.json skills memories cron
# súbelo y extráelo en el volumen vía: railway ssh

Conectar WhatsApp o Telegram

Aquí es donde el agente se mete en tu bolsillo. Ambos bridges ya viven dentro de la imagen oficial, así que no instalas nada extra — solo activas el canal.

Telegram es la ruta de menor fricción: creas un bot con @BotFather, copias el token y lo pones como variable. Sin QR, sin re-pairing — el token es toda la autenticación.

railway variables --set "TELEGRAM_BOT_TOKEN=123456:ABC..."

WhatsApp vive más cerca del día a día, pero pide un paso extra. Lo activas con dos variables:

railway variables --set "WHATSAPP_ENABLED=true" --set "WHATSAPP_MODE=self-chat"

El modo self-chat te deja hablar con el agente desde tu propio chat. La primera vez, WhatsApp Web puede pedir vincular un dispositivo: el QR aparece en railway logs, lo escaneas con tu teléfono (Dispositivos vinculados) y queda conectado.

Resumen — el setup mínimo viable

Si empiezas desde cero, este es el orden:

1. Instala local — curl … | bash, hermes setup, prueba en interactivo.
2. Elige tu modelo — un plan que ya pagues (ChatGPT $20), uno gratis (Nemotron de NVIDIA), o un pool con fallback entre varios.
3. Despliega en Railway — imagen oficial nousresearch/hermes-agent, volumen en /opt/data, variables con tu API key.
4. Configura en el contenedor — railway ssh → hermes setup, una sola vez.
5. Conecta un canal — Telegram (token) o WhatsApp (QR de los logs).

El resultado: un agente con herramientas, memoria y autonomía, corriendo 24/7, al que le hablas por WhatsApp o Telegram como si fuera una persona más. No es un chatbot. Es un harness con manos, y vive en la nube.