Análisis a fondo de Hermes Agent 2026: El agente de IA que se automejora y de verdad te recuerda

Probablemente hayas visto a Hermes Agent en las tendencias de GitHub: más de 73.000 estrellas y subiendo rápidamente. Creado por Nous Research (el laboratorio detrás de las familias de modelos Hermes y Nomos), es un agente de IA de código abierto que se ejecuta en tu propio hardware. No es un envoltorio de chatbot. No es un plugin para tu IDE. Es un agente totalmente autónomo con memoria, programación de tareas, uso de herramientas y un ciclo de aprendizaje que mejora cuanto más tiempo se ejecuta.

Esto no es un resumen de una nota de prensa. Es un análisis práctico y a fondo: qué hace Hermes realmente, cómo configurarlo, qué funciona bien, qué no, y si merece tu tiempo. Cada característica descrita aquí viene con un escenario de uso real que puedes probar hoy mismo.

Qué es Hermes Agent en realidad

Hermes Agent es un agente de IA autoalojado que vive en tu servidor (o portátil, o un VPS de 5 $) y habla contigo a través de una terminal, Telegram, Discord, Slack, WhatsApp, Signal: más de 15 plataformas desde un único proceso de gateway. Usa cualquier LLM al que lo apuntes: OpenAI, Anthropic, DeepSeek, Nous Portal, OpenRouter con más de 200 modelos, o tu propio endpoint local.

La propuesta que lo diferencia de "otro framework de agentes más" es que tiene un ciclo de aprendizaje cerrado. Recuerda cosas entre sesiones, crea habilidades reutilizables a partir de tareas complejas, mejora esas habilidades durante su uso y construye un perfil de quién eres con el tiempo. La mayoría de los agentes empiezan de cero en cada conversación. Hermes acumula contexto.

Tiene licencia MIT, lo cual es importante si vas a construir sobre él.

Cifras clave:

Más de 73.600 estrellas en GitHub (a fecha de abril de 2026)
647 skills en 4 registros (79 integradas, 47 opcionales, 521 aportadas por la comunidad)
Más de 15 plataformas de mensajería compatibles desde un único gateway
6 backends de terminal: local, Docker, SSH, Daytona, Singularity, Modal
Requisito mínimo de contexto: 64K tokens (los modelos por debajo de esto son rechazados al iniciar)

Instalación: 60 segundos, no es broma

# Instalación en una línea — Linux, macOS, WSL2, incluso Android vía Termux
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# Recarga tu shell
source ~/.bashrc  # o: source ~/.zshrc

# Empieza a chatear
hermes

El instalador se encarga de todo: Python 3.11 (vía uv, sin sudo), Node.js v22, ripgrep, ffmpeg. El único prerrequisito es git.

Tras la instalación, obtienes un conjunto de comandos CLI que cubren la mayor parte de la configuración:

hermes model    # Elige tu proveedor de LLM interactivamente
hermes tools    # Activa/desactiva grupos de herramientas
hermes setup    # Asistente de configuración completo (lo hace todo de una vez)
hermes gateway  # Inicia el gateway de mensajería
hermes doctor   # Diagnostica problemas
hermes update   # Actualiza a la última versión

También funciona en Android. Termux tiene una ruta de instalación dedicada con un extra .[termux] curado que omite las dependencias de voz incompatibles con Android. Puedes literalmente ejecutar un agente de IA desde tu teléfono.

Cómo elegir un proveedor de modelos

Hermes no te ata a ningún proveedor. Ejecuta hermes model y elige de la lista:

Proveedor	Qué es	Método de autenticación
Nous Portal	Suscripción, cero configuración	Inicio de sesión OAuth
OpenAI Codex	OAuth de ChatGPT, modelos Codex	Autenticación por código de dispositivo
Anthropic	Modelos Claude directamente	Autenticación Claude Code o clave de API
OpenRouter	Más de 200 modelos, multiproveedor	Clave de API
DeepSeek	API directa	Clave de API
GitHub Copilot	GPT-5.x, Claude, Gemini vía Copilot	OAuth
Hugging Face	Más de 20 modelos abiertos	HF_TOKEN
Custom Endpoint	VLLM, SGLang, Ollama, cualquier compatible con OpenAI	URL base + clave de API

Además: Z.AI/GLM, Kimi/Moonshot, MiniMax, Alibaba Cloud/DashScope, Arcee AI y más.

La regla de los 64K: Hermes requiere al menos 64.000 tokens de contexto. Los modelos con menos son rechazados al iniciar. Esto tiene sentido: los flujos de trabajo de llamadas a herramientas de varios pasos consumen el contexto rápidamente, y una ventana pequeña significa que el agente pierde la noción de lo que está haciendo a mitad de una tarea. Si estás ejecutando un modelo local, establece --ctx-size 65536 o superior.

Cambia de proveedor en cualquier momento con hermes model. Sin cambios en el código, sin ataduras.

El sistema de memoria: Pequeño, acotado y deliberado

Aquí es donde Hermes se desvía de la mayoría de los frameworks de agentes. En lugar de volcar todo en una base de datos vectorial, Hermes utiliza dos archivos diminutos con límite de caracteres:

Archivo	Propósito	Límite
`MEMORY.md`	Notas del agente — hechos del entorno, convenciones, lecciones aprendidas	2.200 caracteres (~800 tokens)
`USER.md`	Perfil de usuario — tus preferencias, estilo de comunicación	1.375 caracteres (~500 tokens)

Ambos se guardan en ~/.hermes/memories/ y se inyectan en el system prompt como una instantánea congelada (frozen snapshot) al inicio de la sesión.

Cómo funciona realmente la memoria en la práctica:

══════════════════════════════════════════════
MEMORY (tus notas personales) [67% — 1.474/2.200 caracteres]
══════════════════════════════════════════════
El proyecto del usuario es un servicio web en Rust en ~/code/myapi usando Axum + SQLx
§Esta máquina ejecuta Ubuntu 22.04, tiene Docker y Podman instalados
§El usuario prefiere respuestas concisas, no le gustan las explicaciones detalladas

El agente gestiona su propia memoria a través de tres acciones:

add — Almacenar un hecho nuevo
replace — Actualizar una entrada existente (por coincidencia de subcadena)
remove — Eliminar algo que ya no es relevante

La trampa de la instantánea congelada: Cuando Hermes escribe en la memoria durante una sesión, los cambios se guardan en disco inmediatamente, pero no aparecerán en el system prompt hasta que comience la siguiente sesión. Esto es intencional (preserva la caché de prefijos del LLM para un mejor rendimiento), pero significa que el agente podría "olvidar" algo que acaba de aprender si sigues hablando en la misma sesión.

Cuando la memoria se llena, el agente recibe un error con las entradas actuales y estadísticas de uso, y entonces tiene que consolidar o reemplazar entradas para hacer espacio. Es como un humano con un cuaderno de solo 15 líneas: aprendes a ser selectivo con lo que anotas.

Qué guardar y qué omitir:

✅ Guardar: Preferencias del usuario, hechos del entorno, convenciones del proyecto, correcciones, patrones de flujo de trabajo
❌ Omitir: Información trivial, hechos fáciles de buscar, bloques grandes de código, datos temporales específicos de la sesión

Este enfoque acotado es refrescante. La mayoría de los sistemas de memoria de agentes o no tienen límites (y se llenan de ruido) o usan recuperación vectorial (que alucina con la relevancia). Hermes impone disciplina.

Skills: La memoria procedimental que el agente crea por sí mismo

Las skills son la respuesta de Hermes a "¿cómo mejorar en tareas recurrentes?". Cuando el agente completa algo complejo, puede crear una skill, esencialmente un archivo SKILL.md con instrucciones para la próxima vez. Las skills se automejoran durante el uso.

El ecosistema es sorprendentemente grande: 647 skills en 4 registros. Las que vienen integradas cubren:

Agentes de programación: delegación a Claude Code, Codex, OpenCode
Herramientas creativas: arte ASCII, arte generativo con p5.js, animaciones matemáticas con Manim, diagramas con Excalidraw, diagramas de arquitectura
Integraciones de plataforma: Apple Notes, Apple Reminders, FindMy, iMessage
Cosas divertidas: configuración de servidor de modpacks de Minecraft, jugador de Pokémon (sí, juega a Pokémon de forma autónoma mediante emulación sin cabeza)
Diseño: 54 plantillas de sistemas de diseño con calidad de producción extraídas de sitios web reales (Stripe, Linear, Vercel, Notion, Airbnb…)

Las skills siguen el estándar abierto agentskills.io, por lo que son portátiles y compartibles con la comunidad.

Escenario real: Le pides a Hermes que configure una pila de Docker Compose para una aplicación de Postgres + Redis + Node. Lo hace y luego crea una skill llamada "docker-compose-setup" con la plantilla, los problemas comunes y las convenciones de puertos que descubrió. La próxima vez que pidas una pila similar, carga la skill y lo hace en la mitad de pasos.

Herramientas: 47 integradas, organizadas por categoría

Hermes viene con un amplio registro de herramientas. Puedes activar/desactivar grupos con hermes tools:

Categoría	Ejemplos	Para qué
Web	`web_search`, `web_extract`	Buscar y extraer datos de la web
Terminal y archivos	`terminal`, `process`, `read_file`, `patch`	Ejecutar comandos, editar archivos
Navegador	`browser_navigate`, `browser_snapshot`, `browser_vision`	Automatización completa del navegador
Multimedia	`vision_analyze`, `image_generate`, `text_to_speech`	Análisis de imágenes, generación, TTS
Orquestación de agentes	`todo`, `execute_code`, `delegate_task`	Planificación, subagentes, ejecución de código
Memoria y recuperación	`memory`, `session_search`	Memoria persistente, búsqueda entre sesiones
Automatización	`cronjob`, `send_message`	Tareas programadas, mensajería saliente

Activación/desactivación rápida:

# Empezar solo con las herramientas web y de terminal
hermes chat --toolsets "web,terminal"

# O configurar interactivamente
hermes tools

Backends de terminal: Ejecuta en cualquier lugar, de forma segura

Esta es una de las características prácticas más potentes de Hermes. Puedes elegir dónde se ejecutan realmente los comandos de terminal del agente:

Backend	Caso de uso
`local`	Predeterminado — se ejecuta en tu máquina
`docker`	Contenedores aislados — seguro para tareas no fiables
`ssh`	Servidor remoto — el agente no puede tocar su propio código
`daytona`	Sandbox en la nube — persistente, hiberna cuando está inactivo
`modal`	Serverless — escalado, pago por uso
`singularity`	Contenedores HPC — computación en clúster sin root

# ~/.hermes/config.yaml
terminal:
  backend: docker
  docker_image: python:3.11-slim
  container_persistent: true  # los paquetes sobreviven entre sesiones
  container_cpu: 1
  container_memory: 5120      # 5GB

El backend SSH es el punto ideal de seguridad: el agente trabaja en una máquina remota y literalmente no puede modificar su propio código o configuración. Los backends de contenedor (Docker, Singularity, Modal) añaden un endurecimiento adicional: sistema de archivos raíz de solo lectura, todas las capabilities de Linux eliminadas, sin escalada de privilegios, límites de PID, aislamiento completo de namespaces.

Consejo práctico: Si estás ejecutando Hermes en un VPS y le das tareas reales, empieza con el backend docker. Si confías en las tareas pero quieres separación, usa ssh. Usa local solo para desarrollo o para tareas que ejecutarías tú mismo.

Cron: Automatización programada integrada

Hermes tiene un programador cron integrado. No se necesitan herramientas externas. Crea tareas en lenguaje natural o con expresiones cron, y los resultados se entregan en cualquier plataforma de mensajería.

# Desde el chat
/cron add "cada 6h" "Revisa los repositorios en tendencia de GitHub en Python y resume los 5 más nuevos. Si no hay nada interesante, responde con [SILENT]." --name "Vigilante de GitHub" --deliver telegram

# Desde la CLI
hermes cron create "0 9 * * 1" \
  "Genera un informe semanal de las principales noticias de IA, repositorios de ML en tendencia y las publicaciones más discutidas en HN." \
  --name "Resumen semanal de IA" \
  --deliver telegram

Lo más importante que debes entender: Las tareas cron se ejecutan en sesiones de agente completamente nuevas, sin memoria de tu chat actual. Los prompts deben ser completamente autocontenidos. Esto confunde a la gente: escriben un prompt de cron como "haz eso que discutimos" y se preguntan por qué el agente no tiene idea de a qué se refieren.

El parámetro --script es la jugada maestra. Puedes adjuntar un script de Python que se ejecuta antes de cada tarea. Su salida estándar (stdout) se convierte en contexto para el agente:

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

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

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

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

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

if prev_hash and prev_hash != current_hash:
    print(f"CAMBIO DETECTADO en {URL}")
    print(f"Vista previa del contenido:\n{content[:2000]}")
else:
    print("NO_CHANGE")

/cron add "cada 1h" "Si el script dice CAMBIO DETECTADO, resume qué ha cambiado. Si dice NO_CHANGE, responde con [SILENT]." --script ~/.hermes/scripts/watch-site.py --name "Monitor de precios" --deliver telegram

El truco de [SILENT]: Cuando la respuesta del agente contiene [SILENT], la entrega se suprime. Solo recibes notificaciones cuando algo realmente sucede. Cero spam.

Gateway de mensajería: Habla con él desde tu teléfono

hermes gateway setup  # interactivo — elige tu plataforma
hermes gateway        # inicia el proceso del gateway

Hermes es compatible con más de 15 plataformas de mensajería desde un solo gateway: Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, Email, SMS, DingTalk, Feishu, WeCom, BlueBubbles, Home Assistant y Open WebUI.

Ejemplo de configuración de Telegram (la más común):

Crea un bot a través de @BotFather (/newbot)
Obtén tu ID de usuario a través de @userinfobot
Ejecuta hermes gateway setup, selecciona Telegram, pega el token y tu ID de usuario
Inicia el gateway: hermes gateway

Eso es todo. Ahora puedes chatear con tu agente desde tu teléfono mientras trabaja en tu servidor.

Las notas de voz también funcionan: envía un mensaje de voz en Telegram, Hermes lo transcribe automáticamente con faster-whisper (se ejecuta localmente, gratis) y responde al texto.

Consejo para chats de grupo: Los bots de Telegram tienen el modo de privacidad activado por defecto: el bot solo ve los /commands y las respuestas directas. Para que vea todos los mensajes en un grupo, desactiva el modo de privacidad en BotFather o promueve el bot a administrador.

Integración con MCP: Amplía con herramientas externas

Hermes soporta el Model Context Protocol (MCP): conéctate a cualquier servidor MCP para añadir herramientas:

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

Las herramientas MCP aparecen junto a las herramientas integradas. Puedes filtrar qué herramientas MCP puede usar el agente para evitar una sobrecarga de herramientas.

Seguridad: Siete capas de profundidad

Hermes tiene un modelo genuino de defensa en profundidad, no solo un "hemos añadido una solicitud de aprobación":

Autorización de usuario — las listas blancas (allowlists) controlan quién puede hablar con el agente
Aprobación de comandos peligrosos — una persona interviene (human-in-the-loop) para operaciones destructivas (rm -rf, chmod 777, etc.)
Aislamiento en contenedores — Docker/Singularity/Modal con configuraciones reforzadas
Filtrado de credenciales de MCP — aislamiento de variables de entorno para subprocesos de MCP
Escaneo de archivos de contexto — detección de inyección de prompts en archivos de proyecto
Aislamiento entre sesiones — las sesiones no pueden acceder a los datos de las demás
Saneamiento de entradas — los parámetros del directorio de trabajo se validan contra una lista blanca

Modos de aprobación:

# ~/.hermes/config.yaml
approvals:
  mode: manual   # manual | smart | off
  timeout: 60    # segundos antes de denegar automáticamente

manual (predeterminado): Siempre pregunta antes de comandos peligrosos
smart: Usa un LLM auxiliar para evaluar el riesgo: aprueba automáticamente los de bajo riesgo, deniega automáticamente los peligrosos y eleva los inciertos para que decidas tú.
off / --yolo: Omite todas las comprobaciones. Úsalo solo en CI/CD o contenedores desechables.

El tiempo de espera es de fallo seguro (fail-closed): Si no respondes en 60 segundos, el comando se deniega. No se aprueba. Este es el comportamiento predeterminado correcto.

Subagentes: Delega y paraleliza

Hermes puede generar subagentes aislados para flujos de trabajo paralelos:

❯ Investiga estos tres temas simultáneamente:
  1. Últimos benchmarks de los runtimes asíncronos de Rust
  2. Nuevas características de PostgreSQL 17
  3. Buenas prácticas para el almacenamiento en caché de LLM en producción

Cada subagente obtiene su propia sesión, herramientas y contexto. Los resultados regresan al agente padre. Esto es útil para tareas que son naturalmente paralelas: investigación, procesamiento por lotes, operaciones en múltiples repositorios.

También puedes usar execute_code para escribir scripts de Python que llamen a herramientas mediante RPC, colapsando flujos de trabajo de múltiples pasos en turnos que no consumen contexto.

Desventajas reales (La parte honesta)

Cualquier reseña que solo dice cosas buenas es inútil. Esto es lo que duele de verdad:

1. La memoria es diminuta y requiere una gestión activa

2.200 caracteres para la memoria del agente. 1.375 para el perfil de usuario. Eso es aproximadamente un total de 20 entradas cortas. Para un asistente personal que se supone que "crece contigo", llegar al límite es frustrantemente rápido. Descubrirás que el agente pasa turnos consolidando y reemplazando entradas de memoria en lugar de hacer trabajo real. El enfoque acotado es filosóficamente sólido, pero en la práctica significa que el agente olvida cosas que desearías que no hubiera olvidado.

2. La "instantánea congelada" crea un "retraso de memoria"

Los cambios en la memoria durante una sesión solo surten efecto en la siguiente sesión. Esto significa que si le dices al agente "recuerda que cambié a PostgreSQL 17", lo escribe en el disco, pero si le preguntas sobre la configuración de tu base de datos más tarde en la misma conversación, el system prompt todavía muestra la información antigua. El agente puede comprobar el estado en vivo a través de las respuestas de las herramientas, pero no siempre se le ocurre hacerlo. Esto lleva a momentos confusos en los que el agente parece haber olvidado lo que acabas de decirle.

3. Los prompts de Cron deben ser totalmente autocontenidos

Cada tarea cron se ejecuta en una sesión en blanco. Sin memoria, sin historial de conversación, sin contexto de ejecuciones anteriores. Esto significa que tus prompts de cron deben explicarlo todo: qué hacer, cómo hacerlo, qué formato de salida usar, dónde entregar el resultado. Escribir buenos prompts de cron es una habilidad en sí misma, y los primeros intentos suelen producir resultados inútiles porque la gente no especifica lo suficiente.

4. El mínimo de 64K de contexto deja fuera a los modelos locales más pequeños

Si quieres ejecutarlo todo en local con un modelo de 7B o 13B, probablemente no tengas suerte a menos que puedas permitirte la RAM para un contexto de 64K. Esta es una decisión de ingeniería razonable (un contexto pequeño = ciclos de agente rotos), pero significa que Hermes no se ejecuta realmente "en cualquier cosa", sino que se ejecuta en cualquier cosa que pueda servir un modelo con un contexto de 64K.

5. El reinicio del gateway interrumpe las conexiones

Si necesitas reiniciar el gateway (actualización, cambio de configuración, recuperación de un fallo), todas las sesiones de mensajería activas se desconectan. No hay una transferencia fluida. Los usuarios en Telegram/Discord simplemente ven que el bot se queda en silencio y luego vuelve. Para uso personal está bien; para despliegues en equipo es un punto débil.

Dónde encaja Hermes: 3 comparaciones rápidas

No son análisis completos, solo unas notas de posicionamiento para que sepas qué elegir en cada caso.

Hermes vs OpenClaw: Ambos son agentes de IA personales y autoalojados con gateway de mensajería, cron, memoria y uso de herramientas. OpenClaw está basado en Node.js con un enfoque en la diversidad de canales y una arquitectura de plugins. Hermes está basado en Python con un enfoque en el ciclo de aprendizaje (skills, automejora) y la preparación para la investigación (exportación de trayectorias, entrenamiento por RL). Si quieres una "inteligencia de agente que crece", inclínate por Hermes. Si quieres un "enrutamiento de mensajes estable a través de 15 plataformas con un amplio ecosistema de plugins", inclínate por OpenClaw.

Hermes vs LangGraph: LangGraph es un framework para construir flujos de trabajo de agentes: tú escribes el grafo, defines los nodos, manejas el estado. Hermes es un agente listo para usar: instalas y chateas. Si necesitas una orquestación multiagente personalizada para un producto, usa LangGraph. Si necesitas un agente personal que funcione sin más, usa Hermes.

Hermes vs CrewAI: CrewAI se centra en el role-playing multiagente (agentes "investigador", "escritor", "editor" colaborando). Hermes es un solo agente que delega en subagentes. CrewAI es mejor para flujos de trabajo de equipo predefinidos. Hermes es mejor para la asistencia personal de final abierto, donde la tarea no se conoce de antemano.

Guía de referencia rápida

Comandos esenciales

hermes                    # Empezar a chatear
hermes model              # Cambiar de proveedor de LLM
hermes tools              # Activar/desactivar conjuntos de herramientas
hermes gateway setup      # Configurar plataformas de mensajería
hermes gateway            # Iniciar el gateway de mensajería
hermes cron list          # Listar tareas programadas
hermes config set KEY VAL # Establecer un valor de configuración
hermes doctor             # Diagnosticar problemas
hermes update             # Actualizar a la última versión
hermes --continue         # Reanudar la última sesión
hermes --yolo             # Omitir aprobación de comandos (¡cuidado!)

Configuración inicial recomendada

# ~/.hermes/config.yaml

# Usa Docker por seguridad
terminal:
  backend: docker
  docker_image: python:3.11-slim
  container_persistent: true

# Mantén activas las solicitudes de aprobación
approvals:
  mode: manual
  timeout: 60

Problemas comunes

Problema	Causa	Solución
El agente ignora la memoria que acabas de añadir	Instantánea congelada (frozen snapshot) — la memoria solo se carga al inicio de la sesión	Inicia una nueva sesión (`hermes`)
La tarea cron produce resultados basura	El prompt no es autocontenido	Detalla todo en el prompt del cron
El bot no ve los mensajes del grupo	Modo de privacidad de Telegram	Desactívalo en BotFather, y luego vuelve a añadir el bot al grupo
Modelo rechazado al inicio	Ventana de contexto < 64K	Usa un modelo más grande o aumenta `--ctx-size`
`hermes: command not found` tras instalar	La shell no se ha recargado	Ejecuta `source ~/.bashrc`

En resumen

Hermes Agent es el agente de IA personal de código abierto más completo disponible en abril de 2026. El ciclo de aprendizaje (memoria + skills + modelado de usuario) es genuinamente novedoso; la mayoría de los agentes de la competencia ni siquiera intentan la mejora entre sesiones. Los 6 backends de terminal te dan una flexibilidad de despliegue real. El ecosistema de 647 skills significa que no empiezas desde cero.

Las desventajas son reales: límites de memoria diminutos, el retraso de la instantánea congelada, la sobrecarga de los prompts de cron y un mínimo de contexto de 64K. Pero son decisiones de ingeniería, no errores: mantienen el sistema acotado y predecible.

Si quieres un agente de IA que viva en tu servidor, te hable desde Telegram, ejecute tareas programadas y realmente mejore con el tiempo, Hermes es el que debes probar. La instalación tarda 60 segundos. En una hora sabrás si encaja en tu flujo de trabajo.

Enlaces:

GitHub: github.com/NousResearch/hermes-agent
Documentación: hermes-agent.nousresearch.com/docs
Discord: discord.gg/NousResearch
Hub de Skills: agentskills.io
Licencia: MIT

Hermes Agent Review 2026: El agente de IA que se automejora y de verdad te recuerda