Hermes Agent: La referencia para profesionales (2026)

TL;DR: Hermes Agent es un agente de IA autoevolutivo de código abierto desarrollado por Nous Research. Se ejecuta como un CLI y como una pasarela de mensajería multiplataforma, almacena una identidad duradera y memoria persistente en disco, agrega skills que mejoran con el uso, y funciona con cualquier proveedor de LLM compatible con OpenAI: Nous Portal, OpenRouter, Anthropic, GitHub Copilot, z.ai, Kimi, MiniMax, DeepSeek, Alibaba, Hugging Face, Google, o tu propio endpoint autoalojado.¹² La parte más difícil para la mayoría de los usuarios nuevos es la autenticación con proveedores: Hermes admite alrededor de 19 proveedores de primera clase más endpoints personalizados, y tres rutas de autenticación distintas (clave API en .env, OAuth mediante hermes model, o endpoint personalizado en config.yaml). El modelo de autenticación es lo primero que conviene aprender: todo lo demás depende de qué proveedor se resuelva.

Hermes Agent opera como un runtime de agente completo, no como un envoltorio de chat. Lee tu sistema de archivos, ejecuta comandos en backends aislados, hace scraping de la web, lanza subagentes, ejecuta tareas cron programadas, se comunica con Telegram/Discord/Slack/WhatsApp/Signal/Email desde un único proceso de gateway, y crea sus propias skills a partir de la experiencia.¹ El CLI es una interfaz de terminal construida sobre un bucle de conversación en run_agent.py; el gateway es un proceso de larga duración que enruta mensajes desde plataformas de mensajería a través del mismo bucle de conversación.³

La diferencia entre un uso casual y experto de Hermes se reduce a cinco sistemas. Domínalos y Hermes se convierte en un multiplicador de fuerza:

1. Resolución de proveedor: cómo los flujos de autenticación se mapean a llamadas de API
2. Jerarquía de configuración: config.yaml + .env + auth.json + SOUL.md + AGENTS.md
3. Sistema de tools + toolsets: lo que el agente puede hacer, controlado por plataforma
4. Sistema de skills: memoria procedural que el agente crea y evoluciona
5. Gateway + cron + profiles: ejecutar Hermes donde vives, no solo donde estás

Conclusiones clave

• La autenticación con proveedores tiene tres rutas, no una. Clave API en .env, OAuth mediante hermes model/hermes auth, o endpoint personalizado en config.yaml. Elige la ruta que corresponda a tu proveedor, no la que te resulte familiar.
• Cambiar de proveedor es un solo comando. hermes model te guía interactivamente por cada proveedor compatible, incluyendo inicios de sesión con OAuth, y /model provider:model cambia a mitad de sesión sin perder el historial.²
• Dos archivos son la superficie de configuración editable por el usuario. ~/.hermes/config.yaml contiene la configuración y ~/.hermes/.env contiene los secretos. auth.json, SOUL.md, MEMORY.md y skills/ son gestionados directamente por Hermes: puedes editar SOUL.md a mano, pero el resto lo modifica el propio agente.⁴
• Hermes es el sucesor de OpenClaw. Si estás migrando, hermes claw migrate importa más de 30 categorías de estado automáticamente.⁵
• La calidad del servicio depende de tu modelo auxiliar. La visión, el resumen web, la compresión y el volcado de memoria utilizan un LLM auxiliar separado. De forma predeterminada, este es Gemini Flash mediante detección automática (OpenRouter → Nous → Codex); si ninguno de estos está configurado, estas funciones se degradan silenciosamente hasta que apuntes los slots auxiliares a tu proveedor principal.⁴

Cada sección a continuación se basa en la documentación oficial en hermes-agent.nousresearch.com/docs y en el árbol de código fuente en github.com/NousResearch/hermes-agent. Cada afirmación factual tiene una nota al pie que apunta a la página específica de la documentación de la que proviene.

Elige tu camino

Cómo funciona Hermes: el modelo mental

Hermes se estructura en torno a un único bucle de conversación que cualquier punto de entrada puede invocar. Los puntos de entrada son el CLI (cli.py), el messaging gateway (gateway/run.py), el adaptador ACP para integración con editores, el ejecutor por lotes y un servidor API.³ Todos terminan llamando a AIAgent.run_conversation() en run_agent.py, que:

1. Construye el prompt del sistema a partir de SOUL.md, MEMORY.md, USER.md, skills, archivos de contexto y guía de herramientas mediante prompt_builder.py³
2. Resuelve el proveedor de ejecución a través de runtime_provider.py — este es el paso que selecciona tu autenticación, URL base y modo API³
3. Llama al proveedor usando uno de tres modos API: chat_completions, codex_responses o anthropic_messages³
4. Despacha las llamadas a herramientas devueltas a través de model_tools.py y el registro central de herramientas (tools/registry.py)³
5. Itera hasta que el modelo produce una respuesta final, luego persiste la sesión en SQLite con FTS5³

Entender este bucle importa porque cada función — personalidades, memoria, skills, compresión, fallback — se conecta a una de estas etapas. Cuando lees una clave de configuración y te preguntas qué hace, la respuesta suele ser “es un control en la etapa 1, 2, 3 o 4 del bucle anterior.”

Núcleo agnóstico de plataforma. Una única clase AIAgent sirve al CLI, gateway, ACP, lotes y servidor API. Las diferencias de plataforma residen en el punto de entrada, no en el agente.³ Por eso los mismos comandos slash funcionan en la terminal y en Telegram — se despachan desde un COMMAND_REGISTRY compartido en hermes_cli/commands.py.⁶

La estructura de directorios es el sistema. Hermes almacena todo bajo ~/.hermes/ (o $HERMES_HOME para perfiles no predeterminados):⁴

~/.hermes/
├── config.yaml        # Settings (model, terminal, TTS, compression, etc.)
├── .env               # API keys and secrets
├── auth.json          # OAuth provider credentials (Nous Portal, Codex, Anthropic)
├── SOUL.md            # Primary agent identity (slot #1 in system prompt)
├── memories/          # Persistent memory (MEMORY.md, USER.md)
├── skills/            # Bundled + agent-created + hub-installed skills
├── cron/              # Scheduled jobs
├── sessions/          # Gateway session state
└── logs/              # agent.log, gateway.log, errors.log (secrets auto-redacted)

Cada archivo tiene un rol específico; ninguno se superpone. Si buscas “dónde almacena Hermes X”, es uno de estos.

Instalación

El instalador de una línea es la vía para el 95% de los usuarios. Se encarga de Python, uv, Node.js, ripgrep, ffmpeg, la clonación del repositorio, el entorno virtual y el comando global hermes.⁷

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

Funciona en Linux, macOS, WSL2 y Android/Termux (el instalador detecta automáticamente Termux y cambia a un paquete Android probado).⁷ Windows nativo no está soportado — instala WSL2 y ejecuta el comando anterior desde ahí.⁷

Una vez que termina:

source ~/.bashrc    # or ~/.zshrc
hermes              # Start chatting

El único prerrequisito es git. El instalador aprovisiona automáticamente Python 3.11 mediante uv (sin necesidad de sudo), Node.js v22 (para automatización del navegador y el puente de WhatsApp), ripgrep y ffmpeg.⁷

Verificar la instalación

hermes version      # Check version
hermes doctor       # Diagnose config/dependency issues
hermes status       # Show current configuration + auth state
hermes dump         # Copy-pasteable setup summary for debugging

hermes doctor te indica exactamente qué falta y cómo solucionarlo.⁷ hermes dump es el comando de diagnóstico para pegar en un issue de GitHub o un hilo de Discord cuando pides ayuda — es un resumen en texto plano de toda tu configuración con los secretos redactados.⁸

Instalación manual

Si necesitas control total — versión personalizada de Python, extras específicos, integración con Nix/NixOS — el flujo manual está documentado paso a paso en la guía de instalación del proyecto.⁷ Los extras opcionales clave que puedes combinar con uv pip install -e ".[<extras>]":

El comando de instalación en Termux es diferente — usa pip con un archivo de restricciones, no uv pip:

python -m pip install -e ".[termux]" -c constraints-termux.txt

Esto se debe a que .[all] en Android arrastra faster-whisper a través del extra voice, que depende de wheels de ctranslate2 que no están publicadas para Android.⁷

Autenticación y proveedores

Hermes admite ~19 proveedores de primera clase más endpoints personalizados, y tres rutas de autenticación distintas. Aquí está toda la superficie de autenticación, organizada por ruta para que puedas encontrar la que se ajusta a lo que tienes.

Las tres rutas de autenticación

Cada proveedor en Hermes encaja en uno de tres patrones de autenticación:

Ruta 1 — clave de API en .env. Coloca tu clave en ~/.hermes/.env y Hermes la lee al iniciar. Usada por OpenRouter, AI Gateway, z.ai/GLM, Kimi/Moonshot, MiniMax (y MiniMax China), Alibaba Cloud/DashScope, Kilo Code, OpenCode Zen, OpenCode Go, DeepSeek, Hugging Face, Google/Gemini y la mayoría de proveedores de terceros.²

Ruta 2 — OAuth mediante hermes model o hermes auth. Inicia un flujo de código de dispositivo, abre un navegador, almacena las credenciales en ~/.hermes/auth.json (y puede importar credenciales existentes desde herramientas como Claude Code o Codex CLI). Usada por Nous Portal, OpenAI Codex (cuenta de ChatGPT), GitHub Copilot y Anthropic (Claude Pro/Max).²

Ruta 3 — endpoint personalizado en config.yaml. Para cualquier API compatible con OpenAI: Ollama, vLLM, SGLang, llama.cpp, LM Studio, proxy LiteLLM, Together AI, Groq, Azure OpenAI o tu propio servidor autoalojado. Se configura una sola vez mediante hermes model → Custom endpoint y luego se persiste en config.yaml.²

La matriz completa de proveedores

Esta es la lista completa de proveedores de primera clase, con el flujo de configuración exacto para cada uno.²

Anthropic: tres métodos de autenticación

Anthropic tiene su propia sección porque Hermes admite tres rutas distintas hacia Claude, y elegir la correcta importa. Según los documentos oficiales:²

# Method 1: API key (pay-per-token)
export ANTHROPIC_API_KEY=***
hermes chat --provider anthropic --model claude-sonnet-4-6

# Method 2: OAuth through hermes model (preferred)
# Uses Claude Code's credential store when available
hermes model

# Method 3: Manual setup-token (fallback/legacy)
export ANTHROPIC_TOKEN=***
hermes chat --provider anthropic

# Auto-detect Claude Code credentials
hermes chat --provider anthropic   # reads Claude Code files automatically

Cuando eliges Anthropic OAuth a través de hermes model, Hermes prefiere el almacén de credenciales de Claude Code en lugar de copiar el token a ~/.hermes/.env. Eso mantiene actualizables las credenciales actualizables de Claude.² Si ya usas Claude Code en la misma máquina, esta es la ruta más limpia.

Para fijar Anthropic permanentemente en config.yaml:

model:
  provider: "anthropic"
  default: "claude-sonnet-4-6"

--provider claude y --provider claude-code también funcionan como atajos para --provider anthropic.²

GitHub Copilot: dos modos

Copilot se admite en dos modos: API directa de Copilot (recomendada) y Copilot ACP (que ejecuta el CLI local de Copilot como subproceso).²

# Direct Copilot API
hermes chat --provider copilot --model gpt-5.4

# Copilot ACP (requires the Copilot CLI in PATH + an existing copilot login)
hermes chat --provider copilot-acp --model copilot-acp

La autenticación se verifica en este orden, según los documentos oficiales:² 1. Variable de entorno COPILOT_GITHUB_TOKEN 2. Variable de entorno GH_TOKEN 3. Variable de entorno GITHUB_TOKEN 4. Fallback al CLI gh auth token 5. Inicio de sesión con código de dispositivo OAuth mediante hermes model

El tipo de token importa. La API de Copilot no admite los Personal Access Tokens clásicos (ghp_*). Los tipos admitidos son tokens OAuth (gho_*), PATs de granularidad fina (github_pat_* con permiso Copilot Requests) y tokens de GitHub App (ghu_*). Si tu gh auth token devuelve un token ghp_*, usa hermes model para autenticarte mediante OAuth en su lugar.²

Proveedores de IA chinos (soporte de primera clase)

Hermes incluye soporte integrado para z.ai/GLM, Kimi/Moonshot, MiniMax (endpoints global y China) y Alibaba Cloud con IDs de proveedor dedicados.²

# z.ai / ZhipuAI GLM
hermes chat --provider zai --model glm-5                 # Requires: GLM_API_KEY

# Kimi / Moonshot AI
hermes chat --provider kimi-coding --model kimi-for-coding   # Requires: KIMI_API_KEY

# MiniMax (global)
hermes chat --provider minimax --model MiniMax-M2.7          # Requires: MINIMAX_API_KEY

# MiniMax (China)
hermes chat --provider minimax-cn --model MiniMax-M2.7       # Requires: MINIMAX_CN_API_KEY

# Alibaba Cloud / DashScope (Qwen)
hermes chat --provider alibaba --model qwen3.5-plus          # Requires: DASHSCOPE_API_KEY

Las URLs base se pueden sobrescribir con las variables de entorno GLM_BASE_URL, KIMI_BASE_URL, MINIMAX_BASE_URL, MINIMAX_CN_BASE_URL o DASHSCOPE_BASE_URL.²

Z.AI detecta automáticamente el endpoint. Al usar el proveedor z.ai/GLM, Hermes prueba múltiples endpoints (variantes global, China, coding) para encontrar uno que acepte tu clave de API. El endpoint funcional se almacena en caché automáticamente: para la mayoría de usuarios no se necesita GLM_BASE_URL.²

xAI (Grok) habilita automáticamente el almacenamiento en caché de prompts. Cuando la URL base contiene x.ai, Hermes envía el encabezado x-grok-conv-id con cada solicitud para enrutar al mismo servidor dentro de una sesión de conversación, reutilizando los prompts de sistema y el historial cacheados.² Es automático; no se necesita configuración.

El comando hermes auth

hermes auth es el comando de gestión de credenciales para pools y credenciales OAuth.⁶

hermes auth                              # Interactive wizard
hermes auth list                         # Show all credential pools
hermes auth list openrouter              # Show one provider's pool
hermes auth add openrouter --api-key sk-or-v1-xxx
hermes auth add anthropic --type oauth
hermes auth remove openrouter 2          # Remove by index
hermes auth reset openrouter             # Clear cooldowns

Los pools de credenciales son la forma de rotar múltiples claves de API o tokens OAuth para el mismo proveedor: útil para distribuir los límites de tasa entre varias claves sin cambiar el código.⁶ Los comandos heredados hermes login / hermes logout se han eliminado; usa hermes auth en su lugar.⁶

Endpoints personalizados y autoalojados

Hermes funciona con cualquier endpoint API compatible con OpenAI. Si un servidor implementa /v1/chat/completions, puedes apuntar Hermes a él.²

Configuración interactiva (recomendada):

hermes model
# Select "Custom endpoint (self-hosted / VLLM / etc.)"
# Enter: API base URL, API key, Model name

config.yaml manual:

model:
  default: your-model-name
  provider: custom
  base_url: http://localhost:8000/v1
  api_key: your-key-or-leave-empty-for-local

Ambos enfoques se persisten en config.yaml, que es la única fuente de verdad para el modelo principal, el proveedor y la URL base.² Las variables de entorno heredadas OPENAI_BASE_URL y LLM_MODEL ya no se leen para la configuración del modelo principal: usa hermes model o edita config.yaml directamente.² (OPENAI_BASE_URL + OPENAI_API_KEY aún se respetan como fallback para la ruta de enrutamiento auxiliar provider: "main", así que no las elimines a ciegas si las estás usando ahí).⁴

Cambiar de endpoints personalizados a mitad de sesión:

/model custom:qwen-2.5             # Custom endpoint with explicit model
/model custom                      # Auto-detect the model from the endpoint
/model custom:local:qwen-2.5       # Named custom provider "local"
/model custom:work:llama3          # Named custom provider "work"
/model openrouter:claude-sonnet-4  # Back to a cloud provider

/model custom (sin nombre de modelo) consulta la API /v1/models de tu endpoint y selecciona automáticamente el modelo si hay exactamente uno cargado: útil para servidores locales que ejecutan un único modelo.²

Servidores LLM locales (plantillas de configuración)

Los documentos oficiales tienen guías de configuración completas para Ollama, vLLM, SGLang, llama.cpp y LM Studio. Estos son los comandos clave que realmente vas a ejecutar. Cada uno está diseñado para producir un endpoint funcional al que Hermes pueda apuntar.²

Ollama — la ruta local más fácil, sin configuración:

ollama pull qwen2.5-coder:32b
OLLAMA_CONTEXT_LENGTH=32768 ollama serve   # Raise from 4k default
hermes model   # Custom endpoint → http://localhost:11434/v1 → qwen2.5-coder:32b

Trampa crítica de Ollama: Ollama tiene por defecto longitudes de contexto muy bajas (4.096 tokens con menos de 24 GB de VRAM). Debes aumentarlo mediante OLLAMA_CONTEXT_LENGTH o un Modelfile: la API compatible con OpenAI no acepta la longitud de contexto del cliente, por lo que Hermes no puede establecerla por ti.² Para uso de agente, configura al menos 16k–32k.

vLLM — servicio GPU de alto rendimiento:

pip install vllm
vllm serve meta-llama/Llama-3.1-70B-Instruct \
  --port 8000 \
  --max-model-len 65536 \
  --tensor-parallel-size 2 \
  --enable-auto-tool-choice \
  --tool-call-parser hermes

La invocación de herramientas requiere --enable-auto-tool-choice y --tool-call-parser <name>. Parsers admitidos: hermes (Qwen 2.5, Hermes 2/3), llama3_json, mistral, deepseek_v3, deepseek_v31, xlam, pythonic. Sin estos flags, las llamadas a herramientas vuelven como texto plano.²

SGLang — servicio rápido con RadixAttention para reutilización de caché KV:

pip install "sglang[all]"
python -m sglang.launch_server \
  --model meta-llama/Llama-3.1-70B-Instruct \
  --port 30000 \
  --context-length 65536 \
  --tp 2 \
  --tool-call-parser qwen

Trampa de SGLang: El max_tokens por defecto es 128. Configura --default-max-tokens en el servidor o ajusta model.max_tokens en config.yaml si las respuestas se cortan.²

llama.cpp / llama-server — CPU y Apple Silicon Metal:

./build/bin/llama-server \
  --jinja -fa \
  -c 32768 \
  -ngl 99 \
  -m models/qwen2.5-coder-32b-instruct-Q4_K_M.gguf \
  --port 8080 --host 0.0.0.0

--jinja es obligatorio para la invocación de herramientas. Sin él, llama-server ignora por completo el parámetro tools y el modelo intenta llamar a las herramientas escribiendo JSON en el texto de su respuesta — que Hermes no puede analizar como llamadas reales a herramientas.²

LM Studio — aplicación de escritorio con GUI:

Inicia el servidor desde la app LM Studio (pestaña Developer → Start Server) o mediante CLI: lms server start (inicia en el puerto 1234) y lms load qwen2.5-coder --context-length 32768.² Luego apunta hermes model a http://localhost:1234/v1.

Trampa crítica de LM Studio: LM Studio lee la longitud de contexto desde los metadatos del modelo, pero muchos modelos GGUF reportan valores por defecto de 2048 o 4096. Establece siempre la longitud de contexto explícitamente en la configuración del modelo de LM Studio: haz clic en el icono de engranaje junto al selector de modelos, configura “Context Length” en al menos 16384 (preferiblemente 32768) y recarga el modelo.²

Proveedores personalizados con nombre

Si trabajas con múltiples endpoints personalizados (un servidor de desarrollo local y un servidor GPU remoto, por ejemplo), defínelos como proveedores personalizados con nombre en config.yaml:²

custom_providers:
  - name: local
    base_url: http://localhost:8080/v1
    # api_key omitted — Hermes uses "no-key-required" for keyless local servers
  - name: work
    base_url: https://gpu-server.internal.corp/v1
    api_key: corp-api-key
    api_mode: chat_completions      # optional, auto-detected from URL
  - name: anthropic-proxy
    base_url: https://proxy.example.com/anthropic
    api_key: proxy-key
    api_mode: anthropic_messages    # for Anthropic-compatible proxies

Después puedes alternar entre ellos a mitad de sesión con la sintaxis triple:

/model custom:local:qwen-2.5
/model custom:work:llama3-70b
/model custom:anthropic-proxy:claude-sonnet-4

También puedes seleccionar proveedores personalizados con nombre desde el menú interactivo de hermes model.²

Arquitectura de proveedores enchufables (v0.13.0+)

v0.13.0 incluye una ABC ProviderProfile más un directorio plugins/model-providers/ para que los proveedores de inferencia de terceros se puedan integrar sin modificaciones del núcleo.¹⁸ Si un proveedor habla un modo de API compatible con OpenAI, Anthropic o Codex, puedes implementar una subclase ProviderProfile que declare la ruta de autenticación, la URL base, el catálogo de modelos y los encabezados de caché; Hermes la resuelve a través de la misma ruta runtime_provider.py que usan los proveedores integrados. Este es el cambio arquitectónico detrás de la expansión de proveedores de v0.13.0: en lugar de editar el código del núcleo para añadir un proveedor, distribuyes un plugin.

Detección de la longitud de contexto

Dos configuraciones se confunden constantemente, según los documentos oficiales:²

• context_length — la ventana de contexto total (presupuesto combinado de tokens de entrada + salida, p. ej. 1.000.000 para Claude Opus 4.7 o 200.000 para Sonnet 4.6). Hermes la usa para decidir cuándo comprimir el historial.
• model.max_tokens — el límite de salida (máximo de tokens que el modelo puede generar en una única respuesta). No tiene relación con la longitud del historial.

Establece context_length cuando la detección automática se equivoca con el tamaño de la ventana:

model:
  default: "qwen3.5:9b"
  base_url: "http://localhost:8080/v1"
  context_length: 131072      # tokens

Hermes usa una cadena de resolución de múltiples fuentes para detectar las ventanas de contexto: override en config → proveedor personalizado por modelo → caché persistente → endpoint /models → Anthropic /v1/models → API de OpenRouter → Nous Portal → models.dev (registro mantenido por la comunidad para más de 3.800 modelos) → valores predeterminados de fallback (128K).² El sistema es consciente del proveedor, así que el mismo modelo puede tener distintos límites de contexto según quién lo sirva (p. ej., claude-opus-4.6 es de 1M en Anthropic directo pero de 128K en GitHub Copilot).²

Rotación y fallback de proveedores

Pools de credenciales. Cuando tienes múltiples claves de API para el mismo proveedor, configura una estrategia de rotación mediante hermes auth. Así es como distribuyes los límites de tasa entre varias claves.⁶

Modelo de fallback. Configura un provider:model de respaldo al que Hermes cambia automáticamente cuando tu modelo principal falla (límites de tasa, errores de servidor, fallos de autenticación):²

fallback_model:
  provider: openrouter            # required
  model: anthropic/claude-sonnet-4  # required
  # base_url: http://localhost:8000/v1    # optional, for custom endpoints
  # api_key_env: MY_CUSTOM_KEY           # optional, env var name

El fallback intercambia modelo y proveedor a mitad de sesión sin perder tu conversación. Se activa como máximo una vez por sesión.² Proveedores admitidos para fallback: openrouter, nous, openai-codex, copilot, copilot-acp, anthropic, huggingface, zai, kimi-coding, minimax, minimax-cn, deepseek, ai-gateway, opencode-zen, opencode-go, kilocode, alibaba, custom.²

Modelos auxiliares

Hermes usa modelos “auxiliares” ligeros para tareas secundarias: análisis de imágenes, resumen de páginas web, análisis de capturas de pantalla del navegador, clasificación de aprobación de comandos peligrosos, compresión de contexto, resumen de búsqueda de sesiones, coincidencia de skills, despacho de herramientas MCP y vaciado de memoria.⁴ Por defecto, estos usan Gemini Flash mediante detección automática (OpenRouter → Nous → Codex).

Puedes configurar qué modelo y proveedor usa cada tarea auxiliar. Cada slot auxiliar usa los mismos tres parámetros: provider, model, base_url.⁴

auxiliary:
  vision:
    provider: "auto"                # "auto", "openrouter", "nous", "codex", "main", etc.
    model: ""                       # e.g. "openai/gpt-4o", "google/gemini-2.5-flash"
    base_url: ""                    # Custom OpenAI-compatible endpoint
    api_key: ""                     # Falls back to OPENAI_API_KEY
    timeout: 30
    download_timeout: 30
  web_extract:
    provider: "auto"
    model: ""
    timeout: 360
  approval:
    provider: "auto"
    model: ""
    timeout: 30
  compression:
    timeout: 120
  session_search: { provider: "auto", model: "", timeout: 30 }
  skills_hub:    { provider: "auto", model: "", timeout: 30 }
  mcp:           { provider: "auto", model: "", timeout: 30 }
  flush_memories:{ provider: "auto", model: "", timeout: 30 }

La opción de proveedor "main" significa “usa el proveedor que use mi agente principal” — válida solo dentro de las configuraciones auxiliary:, compression: y fallback_model:. No es válida para tu configuración de nivel superior model.provider. Si usas un endpoint personalizado compatible con OpenAI como tu modelo principal, configura provider: custom en tu sección model:.⁴

Por qué importa: si solo configuraste Anthropic OAuth (sin clave de OpenRouter), tu visión, resumen web y compresión se degradarán o fallarán porque la cadena de fallback auxiliar por defecto prueba primero con OpenRouter. Añade un OPENROUTER_API_KEY para tareas auxiliares, o reconfigura cada slot auxiliar para que use tu proveedor principal:

auxiliary:
  vision:
    provider: "main"
  web_extract:
    provider: "main"

Esta es la trampa más común de “mis funciones no funcionan en silencio” para usuarios nuevos de Hermes.

Sistema de Configuración

Hermes tiene un sistema de configuración por capas. Entender la precedencia es esencial porque las capas superiores anulan a las inferiores, y una de las capas es un registro global de proveedores que no puedes ver en config.yaml.

Estructura de Archivos de Configuración

Según la documentación oficial, estos son los archivos que componen una configuración de Hermes:⁴

~/.hermes/
├── config.yaml       # All settings (model, terminal, TTS, compression, memory, toolsets, ...)
├── .env              # Secrets (API keys, bot tokens, passwords)
├── auth.json         # OAuth provider credentials (Nous Portal, Codex, Anthropic)
├── SOUL.md           # Primary agent identity (slot #1 in system prompt)
├── memories/         # Persistent memory (MEMORY.md, USER.md)
├── skills/           # Bundled + agent-created + hub-installed skills
├── cron/             # Scheduled jobs
├── sessions/         # Gateway session state
└── logs/             # agent.log, gateway.log, errors.log (secrets auto-redacted)

config.yaml vs .env — cuando ambos están configurados, config.yaml gana para los ajustes que no son secretos.⁴ La regla es: - Secretos (claves de API, tokens de bots, contraseñas) → .env - Todo lo demás (modelo, backend de terminal, ajustes de compresión, límites de memoria, toolsets) → config.yaml

Los secretos pueden referenciarse desde config.yaml usando interpolación al estilo shell:⁴

auxiliary:
  vision:
    api_key: ${GOOGLE_API_KEY}
    base_url: ${CUSTOM_VISION_URL}
  delegation:
    api_key: ${DELEGATION_KEY}

Gestionar la Configuración

hermes config                # View current configuration
hermes config show           # Same as above
hermes config edit           # Open config.yaml in your editor
hermes config set KEY VAL    # Set a specific value
hermes config path           # Print the config file path
hermes config env-path       # Print the .env file path
hermes config check          # Check for missing options (after updates)
hermes config migrate        # Interactively add missing options

Ejemplos:⁴

hermes config set model anthropic/claude-opus-4
hermes config set terminal.backend docker
hermes config set OPENROUTER_API_KEY sk-or-...   # Saves to .env

hermes config check y hermes config migrate son los comandos que debes ejecutar después de cada hermes update — detectan opciones de configuración recién añadidas que tu archivo aún no tiene.⁶

Precedencia de la Configuración

Hermes carga la configuración desde varias fuentes. Cuando múltiples fuentes definen el mismo valor, gana la de mayor prioridad:⁴

1. Argumentos de CLI — hermes chat --model anthropic/claude-sonnet-4 (anulación por invocación)
2. Variables de entorno — se aplican al iniciar el proceso
3. config.yaml — el archivo principal de ajustes
4. .env — solo secretos
5. Valores predeterminados integrados — se aplican cuando ninguna otra fuente define un valor

Las flags de CLI siempre ganan para esa invocación única. config.yaml es la fuente de verdad a largo plazo.

Localización (v0.13.0+)

v0.13.0 añade 7 locales para los mensajes de CLI y del gateway: chino (simplificado), japonés, alemán, español, francés, ucraniano y turco.¹⁸ La documentación actualmente solo está localizada en zh-Hans. El locale se resuelve a partir de las variables de entorno LC_ALL / LANG o de una clave explícita locale: en config.yaml. El inglés sigue siendo el predeterminado y la fuente de verdad para cualquier cadena que una traducción aún no haya cubierto.

Profiles — Múltiples Instancias de Hermes Aisladas

Los profiles te dan múltiples instancias de Hermes aisladas, cada una con su propia configuración, sesiones, skills, memoria y PID de gateway. Así es como ejecutas un “Hermes de trabajo” y un “Hermes personal” en paralelo sin que ninguno vea el estado del otro.⁶

hermes profile list
hermes profile create work --clone                  # Clone from current profile
hermes profile use work                             # Set sticky default
hermes profile alias work --name h-work             # Create wrapper script
hermes profile export work -o work-backup.tar.gz
hermes profile import work-backup.tar.gz --name restored
hermes -p work chat -q "Hello from work profile"    # One-off without switching

Cada profile obtiene su propio HERMES_HOME (~/.hermes-<name>/ por defecto), de modo que varios profiles pueden ejecutar el gateway de forma concurrente sin interferir entre sí.⁶³

Comandos CLI

Esta sección es la referencia práctica de los comandos de nivel superior de CLI. Para la referencia autoritativa derivada del código, consulta la documentación upstream CLI Commands Reference.⁶

Opciones globales

hermes [global-options] <command> [subcommand/options]

Comandos de nivel superior

hermes chat — El punto de entrada principal

hermes sin argumentos te lleva al chat interactivo. hermes chat es la forma explícita con opciones:⁶

hermes chat -q "Summarize the latest PRs"           # One-shot, non-interactive
hermes chat --provider openrouter --model anthropic/claude-sonnet-4.6
hermes chat --toolsets web,terminal,skills          # Enable specific toolsets
hermes chat --quiet -q "Return only JSON"           # Programmatic mode
hermes chat --worktree -q "Review repo and open a PR"

Opciones principales:

hermes setup — Asistente completo

Ejecuta el asistente de configuración completo o salta directamente a una sección:⁶

hermes setup                 # Full wizard
hermes setup model           # Provider and model only
hermes setup terminal        # Terminal backend only
hermes setup gateway         # Messaging platforms only
hermes setup tools           # Tool enable/disable per platform
hermes setup agent           # Agent behavior only
hermes setup --non-interactive
hermes setup --reset         # Reset config to defaults before setup

hermes logs — Consulta estructurada de logs

hermes logs es más potente que un simple tail -f sobre los archivos de log, ya que permite filtrar por nivel, ID de sesión y rango de tiempo de forma simultánea.⁶

hermes logs                          # Last 50 lines of agent.log
hermes logs -f                       # Follow in real time
hermes logs gateway -n 100           # Last 100 lines of gateway.log
hermes logs --level WARNING --since 1h   # Warnings from the last hour
hermes logs --session abc123         # Filter by session ID substring
hermes logs errors --since 30m -f    # Follow errors.log from 30m ago
hermes logs list                     # List all log files with sizes

Los archivos de log se encuentran en ~/.hermes/logs/:⁶ - agent.log — toda la actividad del agente (llamadas a API, despacho de herramientas, ciclo de vida de sesiones, nivel INFO+) - errors.log — solo advertencias y errores (un subconjunto filtrado de agent.log) - gateway.log — actividad del messaging gateway (conexiones de plataforma, despacho, webhooks)

La rotación es automática mediante RotatingFileHandler de Python — busca archivos como agent.log.1, agent.log.2, etc.⁶

hermes doctor — Diagnósticos

hermes doctor [--fix] es el primer comando que debes ejecutar cuando algo falla. Verifica la validez de la configuración, la presencia de dependencias, la disponibilidad de claves API, el estado de los servicios, y puede intentar reparaciones automáticas con --fix.⁶

Para compartir diagnósticos con alguien más, usa hermes dump — genera un resumen compacto en texto plano con claves API redactadas, listo para pegar en un issue de GitHub o en un hilo de Discord.⁶

Comandos slash

Los comandos slash se ejecutan dentro de una sesión de chat activa (CLI o plataforma de mensajería). Se despachan desde un COMMAND_REGISTRY compartido en hermes_cli/commands.py, razón por la cual la mayoría de los comandos funcionan de forma idéntica en todas las superficies.⁹

Control de sesión

Configuración y modelo

El comando /model es el caballo de batalla para cambiar de proveedor a mitad de sesión:⁹

/model                              # Show current model and options
/model claude-sonnet-4              # Switch model (auto-detect provider)
/model zai:glm-5                    # Switch provider:model
/model custom:qwen-2.5              # Use model on custom endpoint
/model custom                       # Auto-detect model from custom endpoint
/model custom:local:qwen-2.5        # Named custom provider
/model openrouter:anthropic/claude-sonnet-4   # Back to cloud

Herramientas, skills e información

Comandos slash dinámicos de skills

Cada skill instalada se expone automáticamente como un comando slash:⁹

/gif-search funny cats
/axolotl help me fine-tune Llama 3 on my dataset
/github-pr-workflow create a PR for the auth refactor
/excalidraw       # Just the skill name loads it and lets the agent ask what you need

También puedes definir quick commands en config.yaml que asocien un nombre corto a un prompt más largo:⁹

quick_commands:
  review: "Review my latest git diff and suggest improvements"
  deploy: "Run the deployment script at scripts/deploy.sh and verify the output"
  morning: "Check my calendar, unread emails, and summarize today's priorities"

Luego escribe /review, /deploy o /morning en la CLI.

Coincidencia por prefijo

Los comandos admiten coincidencia por prefijo: al escribir /h se resuelve a /help, y /mod se resuelve a /model. Cuando un prefijo es ambiguo, gana el primer registro en orden del registry. Los nombres completos de comandos y los alias registrados siempre tienen prioridad sobre las coincidencias por prefijo.⁹

Comandos específicos de mensajería

Algunos comandos solo funcionan en plataformas de mensajería (Telegram, Discord, Slack, WhatsApp, Signal, Email, Home Assistant):⁹

• /status — muestra información de la sesión
• /sethome (alias /set-home) — marca el chat actual como home de la plataforma
• /approve [session|always] — aprueba un comando peligroso pendiente
• /deny — rechaza un comando peligroso pendiente
• /update — actualiza Hermes Agent a la última versión
• /commands [page] — explora todos los comandos y skills (paginado)

Y algunos son exclusivos de CLI: /skin, /tools, /toolsets, /browser, /config, /cron, /skills, /platforms, /paste, /statusbar, /plugins.⁹

Herramientas y toolsets

Hermes incluye un amplio registro de herramientas integradas que cubre búsqueda web, automatización del navegador, ejecución en terminal, edición de archivos, memoria, delegación, entrenamiento RL, entrega de mensajes, integración con Home Assistant y más.¹⁰ Las herramientas se organizan en toolsets lógicos que se pueden habilitar o deshabilitar por plataforma.

Categorías de alto nivel

Entre los nombres comunes de toolsets se incluyen web, terminal, file, browser, vision, image_gen, moa, skills, tts, todo, memory, session_search, cronjob, code_execution, delegation, clarify, homeassistant y rl.¹⁰

Gestionar herramientas

hermes chat --toolsets "web,terminal"       # Use specific toolsets
hermes tools                                # Interactive per-platform tool config
hermes tools --summary                      # Print enabled-tools summary

También puedes activar o desactivar herramientas a mitad de sesión con /tools disable <name> y /tools enable <name>, lo que reinicia la sesión para que el nuevo toolset entre en vigor.⁹

Backends de terminal

La herramienta de terminal puede ejecutar comandos en 6 entornos diferentes:¹⁰

Cambia de backend con hermes config set terminal.backend <name> o en config.yaml:

terminal:
  backend: docker      # or: local, ssh, singularity, modal, daytona
  cwd: "."             # Working directory
  timeout: 180         # Command timeout in seconds

Backend SSH (recomendado por seguridad: el agente no puede modificar su propio código):¹⁰

terminal:
  backend: ssh

# In ~/.hermes/.env
TERMINAL_SSH_HOST=my-server.example.com
TERMINAL_SSH_USER=myuser
TERMINAL_SSH_KEY=~/.ssh/id_rsa

Backend Docker:

terminal:
  backend: docker
  docker_image: python:3.11-slim

Recursos de contenedor (aplica a docker, singularity, modal, daytona):¹⁰

terminal:
  container_cpu: 1
  container_memory: 5120          # MB (default 5GB)
  container_disk: 51200           # MB (default 50GB)
  container_persistent: true      # Persist filesystem across sessions

Con container_persistent: true, los paquetes instalados, archivos y configuración se conservan entre sesiones.¹⁰

Todos los backends de contenedor se ejecutan con endurecimiento de seguridad: sistema de archivos raíz de solo lectura (Docker), todas las capacidades de Linux eliminadas excepto DAC_OVERRIDE, CHOWN y FOWNER, sin escalada de privilegios, límites de PID (256 procesos), aislamiento completo por namespaces, workspace persistente mediante volúmenes.¹⁰

Procesos en segundo plano

La herramienta de terminal admite ejecución en segundo plano con gestión explícita de procesos:¹⁰

terminal(command="pytest -v tests/", background=true)
# Returns: {"session_id": "proc_abc123", "pid": 12345}

process(action="list")                            # Show all running processes
process(action="poll", session_id="proc_abc123")  # Check status
process(action="wait", session_id="proc_abc123")  # Block until done
process(action="log", session_id="proc_abc123")   # Full output
process(action="kill", session_id="proc_abc123")  # Terminate
process(action="write", session_id="proc_abc123", data="y")  # Send input

El modo PTY (pty=true) habilita herramientas interactivas de CLI como Codex y Claude Code.¹⁰

Sudo

Si un comando necesita sudo, Hermes te pedirá la contraseña (almacenada en caché durante la sesión). También puedes definir SUDO_PASSWORD en ~/.hermes/.env.¹⁰

Kanban multiagente (v0.13.0+)

v0.13.0 convierte la colaboración multiagente en una primitiva de primera clase: un tablero Kanban durable que rastrea tareas, estado e identidad del worker entre agentes y reinicios.¹⁸ El tablero es lo que hace que un enjambre de workers de Hermes realmente termine el trabajo en lugar de quedarse atascado en traspasos muertos.

El tablero Kanban se combina de forma natural con /goal (bucle Ralph con objetivo bloqueado) para el lado del objetivo y con la herramienta existente delegate_task para la semántica de spawn. El resultado es un patrón de enjambre donde cada agente comparte una única fuente de verdad sobre qué hacer después, quién lo está haciendo y qué está atascado.

Sistema de Skills

Las skills son documentos de conocimiento bajo demanda que el agente puede cargar cuando los necesita. Siguen un patrón de divulgación progresiva para minimizar el uso de tokens y son compatibles con el estándar abierto agentskills.io.¹¹

Todas las skills viven en ~/.hermes/skills/: el directorio principal y la fuente de verdad. En una instalación nueva, las skills incluidas se copian desde el repo. Las skills instaladas desde el hub y las creadas por el agente también van aquí.¹¹

Divulgación progresiva

Level 0: skills_list()           → [{name, description, category}, ...]   (~3k tokens)
Level 1: skill_view(name)        → Full content + metadata                 (varies)
Level 2: skill_view(name, path)  → Specific reference file                 (varies)

El agente solo carga el contenido completo de la skill cuando realmente lo necesita.¹¹

Formato de SKILL.md

---
name: my-skill
description: Brief description of what this skill does
version: 1.0.0
platforms: [macos, linux]      # Optional — restrict to OS platforms
metadata:
  hermes:
    tags: [python, automation]
    category: devops
    fallback_for_toolsets: [web]     # Conditional activation
    requires_toolsets: [terminal]    # Conditional activation
    config:                          # Config.yaml settings
      - key: my.setting
        description: "What this controls"
        default: "value"
        prompt: "Prompt for setup"
---

# Skill Title

## When to Use
Trigger conditions for this skill.

## Procedure
1. Step one
2. Step two

## Pitfalls
- Known failure modes and fixes

## Verification
How to confirm it worked.

Activación condicional

Las skills pueden mostrarse u ocultarse según las herramientas disponibles. Esto es especialmente útil para skills de fallback: alternativas gratuitas o locales que solo deberían aparecer cuando una herramienta premium no está disponible:¹¹

Ejemplo: la skill integrada duckduckgo-search usa fallback_for_toolsets: [web]. Cuando tienes configurada FIRECRAWL_API_KEY, el toolset web está disponible y el agente usa web_search; la skill de DuckDuckGo permanece oculta. Sin la clave API, la skill de DuckDuckGo aparece automáticamente como fallback.¹¹

Skills gestionadas por el agente

El agente puede crear, actualizar y eliminar sus propias skills mediante la herramienta skill_manage. Esta es la memoria procedimental del agente: cuando descubre un flujo de trabajo no trivial, guarda el enfoque como una skill para reutilizarlo en el futuro.¹¹

Cuándo crea skills el agente:¹¹ - Después de completar correctamente una tarea compleja (5+ llamadas a herramientas) - Cuando encontró errores o callejones sin salida y dio con el camino funcional - Cuando el usuario corrigió su enfoque - Cuando descubrió un flujo de trabajo no trivial

Acciones:¹¹

Hub de Skills

Explora, busca, instala y gestiona skills desde registros en línea:⁶¹¹

hermes skills browse                          # Browse all hub skills
hermes skills browse --source official        # Browse official optional skills
hermes skills search kubernetes               # Search all sources
hermes skills search react --source skills-sh # Search skills.sh directory
hermes skills inspect openai/skills/k8s       # Preview before installing
hermes skills install openai/skills/k8s       # Install with security scan
hermes skills install skills-sh/anthropics/skills/pdf --force
hermes skills check                           # Check for upstream updates
hermes skills update                          # Reinstall changed hub skills
hermes skills audit                           # Re-scan installed hub skills
hermes skills uninstall k8s
hermes skills publish skills/my-skill --to github --repo owner/repo
hermes skills tap add myorg/skills-repo       # Add custom GitHub source

Fuentes de hub integradas:¹¹

Taps predeterminados de GitHub (explorables sin configuración): openai/skills, anthropics/skills, VoltAgent/awesome-agent-skills, garrytan/gstack.¹¹

Escaneo de seguridad

Todas las skills instaladas desde el hub pasan por un escáner de seguridad que revisa exfiltración de datos, prompt injection, comandos destructivos, señales de supply-chain y otras amenazas.¹¹

Niveles de confianza:¹¹

--force puede omitir bloqueos de política no peligrosos para skills de la comunidad. No omite un veredicto de escaneo dangerous.¹¹

Directorios externos de skills

Puedes apuntar Hermes a directorios adicionales de skills que se escanean junto con el local:¹¹

skills:
  external_dirs:
    - ~/.agents/skills
    - /home/shared/team-skills
    - ${SKILLS_REPO}/skills

Las rutas admiten expansión de ~ y sustitución de variables de entorno ${VAR}. Los directorios externos son de solo lectura: cuando el agente crea o edita una skill, siempre escribe en ~/.hermes/skills/. La precedencia local gana si existe una skill con el mismo nombre en ambos lugares.¹¹

Memoria persistente

Hermes tiene memoria acotada y curada que persiste entre sesiones. Dos archivos componen la memoria del agente, ambos almacenados en ~/.hermes/memories/:¹²

Ambos se inyectan en el system prompt como una instantánea congelada al inicio de la sesión. El agente administra su propia memoria mediante la herramienta memory: add, replace o remove.¹²

Patrón de instantánea congelada: la inyección en el system prompt se captura una sola vez al inicio de la sesión y nunca cambia durante la sesión. Esto es intencional: preserva la caché de prefijo de LLM para mejorar el rendimiento. Los cambios realizados durante una sesión se guardan en disco de inmediato, pero no aparecen en el system prompt hasta la siguiente sesión.¹²

Qué guardar

Guarda esto (el agente lo hace de forma proactiva):¹² - Preferencias del usuario: “Prefiero TypeScript en lugar de JavaScript” → user - Datos del entorno: “Este servidor ejecuta Debian 12 con PostgreSQL 16” → memory - Correcciones: “No uses sudo para comandos de Docker; el usuario está en el grupo docker” → memory - Convenciones: “El proyecto usa tabs, ancho de línea de 120 caracteres y docstrings estilo Google” → memory - Trabajo completado: “Migré la base de datos de MySQL a PostgreSQL el 2026-01-15” → memory

Omite esto:¹² - Información trivial u obvia - Datos fáciles de redescubrir - Volcados de datos sin procesar (demasiado grandes para la memoria) - Detalles efímeros específicos de la sesión - Información que ya está en archivos de contexto

Búsqueda de sesiones

Además de MEMORY.md y USER.md, el agente puede buscar en sus conversaciones pasadas con la herramienta session_search. Todas las sesiones de CLI y mensajería se almacenan en SQLite (~/.hermes/state.db) con búsqueda de texto completo FTS5. Las consultas devuelven conversaciones pasadas relevantes con resumen de Gemini Flash.¹²

Proveedores externos de memoria

Para una memoria persistente más profunda, más allá de MEMORY.md y USER.md, Hermes incluye ocho plugins de proveedores externos de memoria: Honcho, OpenViking, Mem0, Hindsight, Holographic, RetainDB, ByteRover y Supermemory.¹²

Los proveedores externos se ejecutan junto con la memoria integrada (nunca la reemplazan) y agregan capacidades como grafos de conocimiento, búsqueda semántica, extracción automática de hechos y modelado de usuario entre sesiones:⁶¹²

hermes memory setup         # Pick a provider and configure it
hermes memory status        # Check what's active
hermes memory off           # Disable external provider (built-in only)

Solo puede haber un proveedor externo activo a la vez. La memoria integrada siempre está activa.⁶

Reanudación automática de sesiones (v0.13.0+)

v0.13.0 hace que una interrupción a mitad de ejecución del agente sea recuperable. El gateway reanuda automáticamente las sesiones interrumpidas después de un reinicio; los reinicios por /update conservan el estado de la sesión durante la actualización; las recargas de archivos fuente durante el desarrollo mantienen viva la sesión activa en lugar de forzar una nueva.¹⁸ Efecto práctico: el trabajo de larga duración del gateway y las tareas impulsadas por cron ya no reinician su ventana de contexto cuando el proceso se reinicia.

Checkpoints v2 (v0.13.0+)

La persistencia de estado se reescribe en v0.13.0 como un diseño de almacén único con poda real, límites de seguridad en disco y sin repos shadow huérfanos.¹⁸ El sistema anterior de checkpoint acumulaba estado en disco en profiles de larga duración; el almacén v2 impone un límite estricto al almacenamiento local de checkpoint y elimina la contabilidad duplicada que impulsaba ese crecimiento. No se requiere ningún cambio de configuración visible para el usuario; la siguiente escritura de checkpoint usa la ruta v2.

Personalidad y SOUL.md

SOUL.md es la identidad principal de una instancia de Hermes. Ocupa el slot #1 en el system prompt y reemplaza la identidad predeterminada hardcodeada.¹³

Hermes crea automáticamente un SOUL.md predeterminado en ~/.hermes/SOUL.md (o $HERMES_HOME/SOUL.md para profiles personalizados). Los archivos existentes del usuario nunca se sobrescriben. Hermes solo carga SOUL.md desde HERMES_HOME: no busca en el directorio de trabajo actual. Esto hace que la personalidad sea predecible entre proyectos.¹³

Qué pertenece en SOUL.md

Úsalo para guía duradera de voz y personalidad:¹³ - tono - estilo de comunicación - nivel de franqueza - estilo de interacción predeterminado - qué evitar en términos de estilo - cómo debe manejar Hermes la incertidumbre, el desacuerdo y la ambigüedad

Úsalo menos para:¹³ - instrucciones puntuales de proyecto - rutas de archivos - convenciones de repositorio - detalles temporales de workflow

Eso pertenece en AGENTS.md, no en SOUL.md.

SOUL.md vs AGENTS.md

Esta es la distinción más importante en la gestión de identidad de Hermes:¹³

SOUL.md: identidad, tono, estilo, valores predeterminados de comunicación, comportamiento a nivel de personalidad.

AGENTS.md: arquitectura del proyecto, convenciones de código, preferencias de herramientas, workflows específicos del repositorio, comandos, puertos, rutas, notas de despliegue.

Una regla útil: si debe acompañarte en todas partes, pertenece en SOUL.md. Si pertenece a un proyecto, pertenece en AGENTS.md.¹³

Personalidades integradas

Hermes incluye personalidades integradas que puedes activar con /personality:¹³

Personalidades personalizadas en config.yaml:¹³

agent:
  personalities:
    codereviewer: >
      You are a meticulous code reviewer. Identify bugs, security issues,
      performance concerns, and unclear design choices. Be precise and constructive.

Luego cambia con /personality codereviewer.

SOUL.md vs /personality

SOUL.md es la voz base. /personality es una capa superpuesta a nivel de sesión.¹³ Mantén un SOUL.md predeterminado y pragmático; luego usa /personality teacher para una conversación de tutoría o /personality creative para una lluvia de ideas.

Nous Tool Gateway (v0.10.0+)

A partir de Hermes Agent v0.10.0 (2026-04-16), los suscriptores de pago de Nous Portal obtienen acceso administrado a un conjunto curado de herramientas mediante sus credenciales existentes de Portal, sin claves API adicionales que administrar.²⁰ El CLI de Hermes sigue teniendo licencia MIT y siendo completamente open source. Lo que cambió es que tu autenticación de Portal ahora desbloquea más que inferencia de modelos.

Qué incluye el gateway

Cómo funciona

El gateway es opt-in por herramienta mediante un nuevo campo de configuración use_gateway. Si tienes credenciales de Portal en hermes auth y habilitas el gateway para una herramienta, las llamadas de esa herramienta se enrutan por Portal. De lo contrario, se usa tu clave directa de API (si existe).

# config.yaml — per-tool gateway opt-in
tools:
  web_search:
    provider: firecrawl
    use_gateway: true          # route via Nous Portal subscription
  image_generation:
    provider: fal
    use_gateway: true

Precedencia en runtime: cuando el gateway está disponible y una herramienta tiene use_gateway: true, Hermes prefiere el gateway aunque también tengas configurada una clave directa de API. Esto importa para la facturación: las llamadas del gateway se descuentan de tu suscripción de Portal, no del saldo de tu clave directa de API.

Habilitar el gateway

hermes model                      # select Nous Portal (OAuth flow)
hermes tools                      # per-platform tool picker integrates gateway tools
hermes status                     # confirms gateway/subscription detection

No hay un comando separado hermes subscribe ni hermes login --portal. La suscripción se detecta automáticamente a partir de las credenciales OAuth de Portal que ya tienes en hermes auth.

Precios y acceso

Los precios y los nombres de tiers se publican en la página de precios de Nous Portal (https://portal.nousresearch.com/pricing). Esta guía no enumera tiers porque son responsabilidad del producto Portal, no del CLI de Hermes, y cambian de forma independiente a las versiones de Hermes. Regístrate en https://portal.nousresearch.com/ y consulta la página de precios para ver los tiers actuales.

Aviso de deprecación

• La variable de entorno HERMES_ENABLE_NOUS_MANAGED_TOOLS se eliminó en v0.10.0. Las herramientas administradas ahora se habilitan mediante el campo de configuración use_gateway por herramienta y dependen del estado de tu suscripción de Portal.²⁰

Marco: lo que esta versión no es

El CLI de Hermes Agent no está bloqueado detrás de una suscripción. El proyecto sigue teniendo licencia MIT; todas las funciones principales (CLI, skills, memoria, gateway de mensajería, cron, MCP, dashboard local, BYOK para cada proveedor) funcionan de extremo a extremo sin pagarle a nadie. v0.10.0 agrega una ruta conveniente para usuarios que ya pagan por Nous Portal; no elimina nada de la ruta gratuita.

Gateway de mensajería

Hermes puede ejecutarse como un proceso gateway de larga duración que se conecta a 20 plataformas de mensajería desde un único proceso gateway: Telegram, Discord, Slack, WhatsApp, Signal, SMS, Email, Home Assistant, Mattermost, Matrix, DingTalk, Feishu/Lark, WeCom, Weixin (WeChat), BlueBubbles (iMessage), QQBot, Microsoft Teams, Tencent Yuanbao, Google Chat y un adaptador Webhook genérico.^3191718 v0.9.0 agregó iMessage mediante BlueBubbles (registro automático de webhooks, asistente de configuración y resiliencia ante fallos) y soporte nativo para WeChat mediante iLink Bot API, con modo de callback de WeCom para apps empresariales.¹⁶ v0.11.0 agregó QQBot.¹⁹ v0.12.0 agregó Microsoft Teams y Tencent Yuanbao.¹⁷ v0.13.0 agregó Google Chat como la plataforma número 20, usando la misma arquitectura de adaptadores conectables; IRC y Microsoft Teams también se migraron al nuevo patrón de adaptadores con hooks de plugin genéricos env_enablement_fn / cron_deliver_env_var.¹⁸

Configuración

hermes gateway setup                # Interactive platform configuration
hermes gateway install              # Install as user service (systemd/launchd)
hermes gateway start                # Start the installed service
hermes gateway stop
hermes gateway restart
hermes gateway status
hermes gateway run                  # Run in foreground (debugging)

La configuración interactiva te guía para conectar cada plataforma: tokens de API, IDs de bot, mapeos de canales y allowlists.⁶

Cómo fluyen los mensajes

Según la documentación de arquitectura upstream:³

Platform event → Adapter.on_message() → MessageEvent
  → GatewayRunner._handle_message()
    → authorize user
    → resolve session key
    → create AIAgent with session history
    → AIAgent.run_conversation()
    → deliver response back through adapter

Todas las plataformas de mensajería pasan por el mismo bucle de conversación AIAgent que CLI. Por eso los comandos slash funcionan de forma idéntica en ambos lugares y por eso un cron job programado en Telegram puede entregar su salida en Discord: la diferencia entre plataformas está solo en el borde.³

Autorización y emparejamiento de usuarios

hermes pairing list                    # Show pending and approved users
hermes pairing approve <platform> <code>
hermes pairing revoke <platform> <user-id>
hermes pairing clear-pending

Los códigos de emparejamiento evitan que personas desconocidas hablen con tu gateway. Un usuario envía un código de emparejamiento desde su plataforma de mensajería; tú lo apruebas con hermes pairing approve; a partir de ese momento queda autorizado.⁶

Tareas programadas (cron)

Hermes tiene un sistema cron de primera clase donde los jobs son tareas de agente, no comandos de shell. Cada job programado se ejecuta mediante un AIAgent nuevo con el prompt configurado, skills adjuntas opcionales, y entrega resultados a cualquier plataforma:³⁶

hermes cron list
hermes cron create --prompt "Check HN for AI news and summarize" --schedule "0 9 * * *" --deliver telegram
hermes cron edit <id>
hermes cron pause <id>
hermes cron resume <id>
hermes cron run <id>         # Trigger now on the next tick
hermes cron remove <id>
hermes cron status           # Check if scheduler is running
hermes cron tick             # Run due jobs once and exit

O crea una de forma conversacional dentro de un chat de mensajería:

Every morning at 9am, check Hacker News for AI news and send me a summary on Telegram.

El agente configurará el cron job mediante sus herramientas. Los jobs persisten en JSON y sobreviven a reinicios.³

Integración con MCP

Hermes soporta Model Context Protocol tanto como cliente como servidor:⁶

Como cliente: conecta Hermes a servidores MCP externos para ampliar su superficie de herramientas:

hermes mcp add <name> --url https://example.com/mcp
hermes mcp add <name> --command npx --args "-y,@modelcontextprotocol/server-github"
hermes mcp list
hermes mcp test <name>
hermes mcp remove <name>
hermes mcp configure <name>   # Toggle individual tool selection

O manualmente en config.yaml:¹⁴

mcp_servers:
  github:
    command: npx
    args: ["-y", "@modelcontextprotocol/server-github"]
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: "ghp_xxx"

Como servidor: expón conversaciones de Hermes a otros agentes:

hermes mcp serve
hermes mcp serve -v    # Verbose

Compresión de contexto

Hermes comprime automáticamente las conversaciones largas para mantenerse dentro de la ventana de contexto de tu modelo. El resumidor de compresión es una llamada LLM separada: puedes apuntarla a cualquier proveedor o endpoint.⁴

compression:
  enabled: true
  threshold: 0.50                           # Compress at this % of context limit
  target_ratio: 0.20                        # Fraction to preserve as recent tail
  protect_last_n: 20                        # Min recent messages to keep uncompressed
  summary_model: "google/gemini-3-flash-preview"
  summary_provider: "auto"                  # "auto", "openrouter", "nous", "codex", "main", etc.
  summary_base_url: null                    # Custom OpenAI-compatible endpoint

Opciones de proveedor:⁴

summary_model debe soportar una longitud de contexto al menos tan grande como la de tu modelo principal, ya que recibe toda la sección intermedia de la conversación para comprimirla.⁴

Advertencias de presión de presupuesto

Cuando el agente trabaja en una tarea compleja con muchas llamadas a herramientas, puede consumir su presupuesto de iteraciones (predeterminado: 90 turnos) sin darse cuenta. La presión de presupuesto advierte automáticamente al modelo:⁴

Timeouts de stream

La conexión de streaming de LLM tiene dos capas de timeout que se ajustan automáticamente para proveedores locales (localhost, IPs LAN):⁴

El timeout de lectura de socket se eleva a 30 minutos para endpoints locales porque los LLM locales pueden tardar minutos en el prefill de contextos grandes antes de producir el primer token.⁴

Dashboard web local (v0.9.0+)

Un dashboard basado en navegador para gestionar tu Hermes Agent localmente. Configura ajustes, monitorea sesiones, explora skills y administra tu gateway sin tocar archivos de configuración ni la terminal.¹⁶ Lánzalo con hermes dashboard. Es la ruta de onboarding más sencilla para usuarios nuevos que prefieren una GUI.

Monitoreo de procesos en segundo plano (v0.9.0+)

watch_patterns te permite definir patrones para monitorear la salida de procesos en segundo plano y recibir notificaciones en tiempo real cuando coinciden.¹⁶ Monitorea errores, espera eventos específicos (“listening on port”) o vigila logs de compilación, todo sin polling. Combinado con notify_on_complete de v0.8.0 (que notifica cuando se completa una tarea en segundo plano), Hermes ahora tiene una capa completa de observabilidad para procesos en segundo plano.¹⁵

Context engine conectable (v0.9.0+)

La gestión de contexto ahora es un slot conectable mediante hermes plugins. Puedes intercambiar context engines personalizados que controlan lo que el agente ve en cada turno: filtrado, resumen o inyección de contexto específico del dominio.¹⁶ Esto desacopla la estrategia de contexto del bucle central del agente, lo que permite personalizar el contexto por proyecto o dominio.

Backup y restauración (v0.9.0+)

hermes backup crea un archivo completo de tu configuración, sesiones, skills y memoria. hermes import restaura desde un archivo de backup.¹⁶ Úsalo para migrar entre máquinas, crear snapshots antes de cambios importantes o compartir una configuración validada con tus compañeros de equipo.

Soporte para Termux / Android (v0.9.0+)

Hermes se ejecuta de forma nativa en Android mediante Termux. Las rutas de instalación adaptadas, las optimizaciones de TUI para pantallas móviles, el soporte de backend de voz y el comando /image funcionan directamente en el dispositivo.¹⁶

Endurecimiento de seguridad (v0.13.0+)

v0.13.0 cerró 8 problemas de seguridad P0 y cambió un valor predeterminado a favor del usuario.¹⁸

Si mantienes un despliegue de Hermes, trata v0.13.0 como una actualización relevante para la seguridad, no solo como una entrega de funciones. El bypass entre guilds de Discord y las dos ventanas TOCTOU son explotables en versiones anteriores.

Arquitectura para profesionales

Esta sección está dirigida a quienes quieren entender lo que sucede bajo el capó para poder depurarlo, extenderlo o razonar sobre su rendimiento. Es una síntesis de la documentación de arquitectura upstream.³

Puntos de entrada → AIAgent

Cada punto de entrada en Hermes termina llamando a AIAgent.run_conversation():

┌──────────────────────────────────────────────────────────────────┐
│                        Entry Points                              │
│                                                                  │
│  CLI (cli.py)    Gateway (gateway/run.py)    ACP (acp_adapter/)  │
│  Batch Runner    API Server                  Python Library     │
└──────────┬──────────────┬───────────────────────┬────────────────┘
           │              │                       │
           ▼              ▼                       ▼
┌──────────────────────────────────────────────────────────────────┐
│                     AIAgent (run_agent.py)                       │
│                                                                  │
│  ┌─────────────┐  ┌──────────────┐  ┌──────────────┐             │
│  │ Prompt      │  │ Provider     │  │ Tool         │             │
│  │ Builder     │  │ Resolution   │  │ Dispatch     │             │
│  └──────┬──────┘  └──────┬───────┘  └──────┬───────┘             │
│         │                │                 │                    │
│  ┌──────┴───────┐ ┌──────┴───────┐  ┌──────┴───────┐             │
│  │ Compression  │ │ 3 API Modes  │  │ Tool Registry│             │
│  │ & Caching    │ │ chat_compl   │  │ 47 tools     │             │
│  │              │ │ codex_resp   │  │ 20 toolsets  │             │
│  │              │ │ anthropic    │  │              │             │
│  └──────────────┘ └──────────────┘  └──────────────┘             │
└──────────────────────────────────────────────────────────────────┘

Diagrama adaptado de la documentación de arquitectura upstream.³

“47 tools / 20 toolsets” frente a “28 tools” en tu banner. El conteo de “47 tools” corresponde al registro total de herramientas del repositorio upstream — cada herramienta para la que Hermes incluye código fuente, en todos los toolsets. Tu CLI en ejecución mostrará un número menor en el banner de inicio (la instalación con la que verifiqué esta guía reporta 28 tools / 89 skills). Eso no es un error. Muchos toolsets son opcionales y deben habilitarse explícitamente en config.yaml bajo toolsets: — adaptadores de plataformas de mensajería, automatización de navegador, herramientas de scraping más pesadas, etc. El total del registro es “lo que está disponible”; el número del banner es “lo que está habilitado en tu perfil actual.” Verifica qué toolsets están activos con hermes tools --list y habilita o deshabilita toolsets individuales con el bloque toolsets: en ~/.hermes/config.yaml (o con /tools list / /tools enable <name> / /tools disable <name> dentro de una sesión en ejecución — eliminar una herramienta provoca un reinicio de sesión para que el agente reconstruya su manifiesto de herramientas).

Los tres modos de API

Hermes abstrae las diferencias entre proveedores en tres modos de API, seleccionados automáticamente en tiempo de ejecución:³

El resolutor runtime_provider.py mapea las tuplas (provider, model) a (api_mode, api_key, base_url) para más de 18 proveedores, gestionando flujos de OAuth, pools de credenciales y resolución de alias.³

Flujo de datos a través de una sesión de CLI

User input → HermesCLI.process_input()
  → AIAgent.run_conversation()
    → prompt_builder.build_system_prompt()
    → runtime_provider.resolve_runtime_provider()
    → API call (chat_completions / codex_responses / anthropic_messages)
    → tool_calls? → model_tools.handle_function_call() → loop
    → final response → display → save to SessionDB

De la página de arquitectura upstream.³

Orden de ensamblado del prompt

La pila del prompt incluye:¹³

1. SOUL.md (identidad del agente — o respaldo integrado si no está disponible)
2. Guía de comportamiento consciente de las herramientas
3. Memoria/contexto del usuario (MEMORY.md, USER.md)
4. Guía de skills
5. Archivos de contexto (AGENTS.md, .cursorrules)
6. Marca de tiempo
7. Sugerencias de formato específicas por plataforma
8. Superposiciones opcionales del prompt del sistema, como /personality

SOUL.md es la base — todo lo demás se construye sobre ella.¹³

Almacenamiento de sesiones

Almacenamiento de sesiones basado en SQLite con búsqueda de texto completo FTS5. Las sesiones tienen seguimiento de linaje (padre/hijo a través de compresiones), aislamiento por plataforma y escrituras atómicas con manejo de contención.³

Sistema de plugins

Tres fuentes de descubrimiento: ~/.hermes/plugins/ (usuario), .hermes/plugins/ (proyecto) y entry points de pip. Los plugins registran herramientas, hooks y comandos de CLI a través de una API de contexto. Los proveedores de memoria son un tipo especializado de plugin bajo plugins/memory/.³

hermes plugins                       # Interactive enable/disable UI
hermes plugins install <repo>        # Install from Git URL or owner/repo
hermes plugins enable <name>
hermes plugins disable <name>
hermes plugins list

Principios de diseño

De la página de arquitectura upstream:³

Migración desde OpenClaw

Hermes Agent es el sucesor de OpenClaw. Si estás migrando desde una instalación existente de OpenClaw:⁶⁵

hermes claw migrate --dry-run                    # Preview what would be migrated
hermes claw migrate --preset full                # Full migration including API keys
hermes claw migrate --preset user-data --overwrite   # User data only, no secrets
hermes claw migrate --source /custom/path        # Non-default OpenClaw location

hermes claw migrate lee desde ~/.openclaw por defecto (también detecta automáticamente los directorios heredados ~/.clawdbot y ~/.moldbot) y escribe en ~/.hermes.⁶

Importado directamente (más de 30 categorías): SOUL.md, MEMORY.md, USER.md, AGENTS.md, skills desde 4 directorios fuente, modelo predeterminado, proveedores personalizados, servidores de MCP, tokens y listas de permitidos de plataformas de mensajería (Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost), valores predeterminados del agente (esfuerzo de razonamiento, compresión, retraso humano, zona horaria, sandbox), políticas de reinicio de sesión, reglas de aprobación, configuración de TTS, ajustes del navegador, ajustes de herramientas, timeout de exec, lista de permitidos de comandos, configuración del gateway y claves de API desde 3 fuentes.⁶

Archivado para revisión manual: trabajos cron, plugins, hooks/webhooks, backend de memoria (QMD), configuración del registro de skills, UI/identidad, logging, configuración multiagente, vinculaciones de canales, IDENTITY.md, TOOLS.md, HEARTBEAT.md, BOOTSTRAP.md.⁶

La resolución de claves de API verifica tres fuentes en orden de prioridad: valores de config → ~/.openclaw/.env → auth-profiles.json.⁶

Solución de problemas

“API key not set”

Ejecuta hermes model para configurar tu proveedor de forma interactiva, o hermes config set OPENROUTER_API_KEY your_key. El comando hermes doctor te dirá exactamente qué claves faltan.⁷

“Context limit: 2048 tokens” al iniciar (modelos locales)

Hermes detecta automáticamente la longitud del contexto desde el endpoint /v1/models de tu servidor, pero muchos servidores locales reportan valores predeterminados bajos. Configúralo explícitamente en config.yaml:²

model:
  default: your-model
  provider: custom
  base_url: http://localhost:11434/v1
  context_length: 32768

Las llamadas a herramientas aparecen como texto en lugar de ejecutarse

Tu servidor no tiene habilitada la invocación de herramientas, o el modelo no la admite a través de la implementación del servidor.²

Las respuestas se cortan a la mitad de una oración

Dos posibles causas:²

1. Límite de salida bajo (max_tokens) en el servidor — SGLang tiene un valor predeterminado de 128 tokens por respuesta. Configura --default-max-tokens en el servidor o ajusta model.max_tokens en config.yaml.
2. Agotamiento del contexto — El modelo llenó su ventana de contexto. Aumenta model.context_length o habilita la compresión de contexto en Hermes.

“Connection refused” desde WSL2 hacia un servidor de modelos alojado en Windows

WSL2 usa un adaptador de red virtual con su propia subred — localhost dentro de WSL2 hace referencia a la VM de Linux, no al host de Windows. Dos opciones:²

Mirrored networking (Windows 11 22H2+): edita %USERPROFILE%\.wslconfig:

[wsl2]
networkingMode=mirrored

Luego ejecuta wsl --shutdown y reinicia. localhost ahora funciona de manera bidireccional.

Alternativa con la IP del host (Windows más antiguo): obtén la IP del host de Windows desde dentro de WSL2 y úsala en lugar de localhost:

ip route show | grep -i default | awk '{ print $3 }'
# Use that IP as the base_url host

También necesitas que el servidor del modelo escuche en 0.0.0.0, no en 127.0.0.1 — configura OLLAMA_HOST=0.0.0.0 para Ollama, agrega --host 0.0.0.0 para llama-server/SGLang, o habilita “Serve on Network” en LM Studio.²

¿Dónde está todo?

hermes status y hermes dump son tus aliados aquí. hermes logs list muestra todos los archivos de registro con sus tamaños. hermes config path imprime la ubicación del archivo de configuración. hermes config env-path imprime la ubicación del archivo .env.⁶

FAQ

¿Cuál es la diferencia entre Hermes Agent y Claude Code?

Claude Code es el CLI oficial de Anthropic, vinculado exclusivamente a los modelos de Anthropic. Hermes Agent es un framework de agentes de código abierto de Nous Research que funciona con cualquier proveedor compatible con OpenAI — Nous Portal, OpenRouter, Anthropic, GitHub Copilot, z.ai, Kimi, MiniMax, DeepSeek, Hugging Face, Google, o tu propio endpoint autoalojado.¹² Hermes también incluye un gateway de mensajería para Telegram/Discord/Slack/WhatsApp/Signal que Claude Code no tiene.

¿Puedo usar Hermes con una API key de Anthropic?

Sí. Tres formas:²

1. Configura ANTHROPIC_API_KEY en ~/.hermes/.env y ejecuta hermes chat --provider anthropic --model claude-sonnet-4-6
2. Ejecuta hermes model y selecciona Anthropic — Hermes usará el almacén de credenciales de Claude Code cuando esté disponible
3. Configura un ANTHROPIC_TOKEN manual (setup-token o token OAuth) como respaldo

La opción 2 es la preferida si ya usas Claude Code en la misma máquina — mantiene las credenciales refrescables de Claude refrescables.

¿Cómo cambio de proveedor sin perder mi conversación?

Usa /model provider:model dentro de una sesión. El historial de conversación, la memoria y los skills se conservan:⁹

/model zai:glm-5
/model openrouter:anthropic/claude-sonnet-4
/model custom:local:qwen-2.5

Configuré Anthropic pero vision/web/compresión no funcionan

Estás encontrando el fallback del modelo auxiliar. Vision, resumen web, compresión y otras tareas secundarias usan un LLM auxiliar separado — por defecto Gemini Flash mediante autodetección (OpenRouter → Nous → Codex). Si ninguno de esos está configurado y solo tienes Anthropic configurado, estas funciones se degradan silenciosamente.⁴

Solución: agrega un OPENROUTER_API_KEY para tareas auxiliares, o reconfigura los slots auxiliares para que usen tu proveedor principal. Ten en cuenta que la compresión de contexto vive en su propio bloque de nivel superior compression: y toma summary_provider, no auxiliary.compression.provider — el slot auxiliary.compression solo expone un timeout. Solución completa:

auxiliary:
  vision:      { provider: "main" }
  web_extract: { provider: "main" }

compression:
  summary_provider: "main"

¿Cuál es la diferencia entre SOUL.md y AGENTS.md?

SOUL.md es la identidad de tu agente — tono, estilo, valores predeterminados de comunicación. Vive en ~/.hermes/SOUL.md y te acompaña a todas partes. AGENTS.md es específico del proyecto — arquitectura, convenciones, comandos, rutas — y vive en el directorio de tu proyecto.¹³ Si debe acompañarte a todas partes, SOUL.md. Si pertenece a un proyecto, AGENTS.md.

¿Cómo ejecuto múltiples instancias de Hermes en paralelo?

Profiles. Cada profile tiene su propio HERMES_HOME, config, memoria, sesiones y PID del gateway:⁶

hermes profile create work --clone
hermes profile use work                 # Sticky default
hermes -p work chat -q "..."            # One-off without switching
hermes profile alias work --name h-work # Wrapper script

¿Hermes admite LLMs locales?

Sí, a través de la ruta del endpoint personalizado. Hermes funciona con cualquier servidor compatible con OpenAI: Ollama, vLLM, SGLang, llama.cpp/llama-server, LM Studio, LocalAI, Jan, o el tuyo propio.² Consulta Custom & Self-Hosted Endpoints para la configuración por servidor.

¿Por qué mi banner de inicio muestra menos herramientas de las que la guía dice que Hermes tiene?

La guía cita 47 herramientas / 20 toolsets del registro de arquitectura upstream — ese es el conteo total de herramientas para las que Hermes incluye código fuente en cada toolset. Tu instalación en ejecución muestra un número menor en el banner (la instalación de referencia usada para esta guía reporta 28 herramientas) porque Hermes solo habilita el conjunto de toolsets predeterminado al iniciar. Muchos toolsets son opt-in: los adaptadores del gateway de mensajería, la automatización del navegador, los stacks de scraping más pesados y varias integraciones especializadas deben listarse explícitamente bajo toolsets: en ~/.hermes/config.yaml antes de que se carguen. Total del registro = “lo que está disponible si lo habilitas”. Total del banner = “lo que tu profile actual realmente cargó”. Usa hermes tools --list para ver qué toolsets están activos y cuáles están disponibles pero deshabilitados. Activa o desactiva toolsets individuales en tiempo de ejecución con /tools enable <name> y /tools disable <name> (al deshabilitar se dispara un reinicio de sesión para que el agente reconstruya su manifiesto de herramientas con la nueva forma).

¿Cómo maneja Hermes el fallback de modelo cuando mi proveedor principal falla?

Configura un bloque fallback_model en config.yaml:²

fallback_model:
  provider: openrouter
  model: anthropic/claude-sonnet-4

Cuando el principal falla (rate limit, error del servidor, fallo de autenticación), Hermes cambia al fallback a mitad de sesión sin perder el historial de conversación. Se activa como máximo una vez por sesión.

¿Puede el agente mejorar sus propios skills con el tiempo?

Sí — esa es la parte “self-improving” de Hermes Agent. El agente puede crear, actualizar y eliminar skills mediante la herramienta skill_manage. Cuando descubre un flujo de trabajo no trivial, guarda el enfoque como un skill para reutilizarlo en el futuro.¹¹ El agente crea skills después de tareas complejas (más de 5 llamadas a herramientas), cuando se topa con errores y encuentra la ruta que funciona, cuando corriges su enfoque, o cuando descubre un flujo de trabajo no trivial.

¿Existe integración con IDE?

Sí — Hermes puede ejecutarse como un servidor ACP (Agent Client Protocol) para VS Code, Zed y JetBrains:⁶

pip install -e '.[acp]'
hermes acp

Registro de cambios

Referencias