Si usas Hermes Agent y nunca has tocado su planificador cron, estás dejando sin usar una de sus funciones más potentes. Cron en Hermes no es una simple utilidad de “ejecuta este script cada hora” — es un framework de automatización completo que abarca programación en lenguaje natural, agentes respaldados por skills, pipelines multi-trabajo y vigilantes de solo script sin costo de tokens.

En esta guía aprenderás a:

• Programar tareas recurrentes y únicas con lenguaje natural o expresiones cron
• Adjuntar skills a un trabajo para que herede flujos de trabajo expertos
• Encadenar múltiples trabajos para que uno alimente al siguiente (el patrón pipeline)
• Ejecutar vigilantes de solo script que consumen cero tokens de LLM
• Configurar resúmenes diarios, monitores de GitHub y verificaciones de salud web listos para producción

Empecemos desde cero.

¿Qué hace diferente al Cron de Hermes?

La mayoría de las implementaciones de cron ejecutan un único script con un temporizador. El cron de Hermes ejecuta una sesión completa de agente con un temporizador — tu prompt se convierte en la tarea, el agente tiene acceso a todas sus herramientas (terminal, archivos, web, navegador, delegación), y el resultado se entrega a la plataforma de chat que elijas.

La idea clave: Un trabajo cron en Hermes es “una sesión programada de Hermes”. Todo lo que puedes pedirle a Hermes en el chat, puedes programarlo para que lo haga de forma autónoma.

Además, el cron de Hermes añade:

• Inyección de skills — carga uno o más skills en la sesión antes de que se ejecute el prompt
• Encadenamiento en pipeline — la salida de un trabajo se convierte en el contexto del siguiente
• Modo sin agente — ejecuta un script simple programado, cero tokens de LLM, stdout entregado textualmente
• Entrega multiplataforma — envía resultados a Telegram, Discord, Slack, correo, SMS, Feishu o cualquier plataforma configurada
• Gestión completa del ciclo de vida — pausar, reanudar, editar, activar bajo demanda, todo desde el chat o la CLI

El planificador se ejecuta dentro del demonio gateway de Hermes, haciendo tick cada 60 segundos. Los trabajos se almacenan en ~/.hermes/cron/jobs.json y usan un bloqueo de archivo (~/.hermes/cron/.tick.lock) para evitar ticks superpuestos.

Programación básica: Tres formas de crear un trabajo

Puedes crear un trabajo cron de tres maneras. Todos los caminos llevan al mismo planificador.

1. Desde el chat con /cron

La forma más rápida — escribe el comando slash /cron durante una sesión de chat:

/cron add "every 2h" "Check server status and report any issues"
/cron add "0 9 * * *" "Summarize yesterday's commits from the project repo"
/cron add "30m" "Remind me to stand up and stretch"

Con un skill adjunto:

/cron add "every 1h" "Check feeds for new posts" --skill blogwatcher

2. Desde la CLI independiente

La versión CLI funciona de manera idéntica y es programable:

hermes cron create "every 2h" "Check server status"
hermes cron create "0 9 * * *" "Summarize yesterday's commits" --name "daily-summary"

Con múltiples skills:

hermes cron create "every 1h" "Monitor feeds and maps" \
  --skill blogwatcher \
  --skill maps \
  --name "Multi-skill watcher"

3. Mediante conversación natural

Solo dile a Hermes lo que quieres:

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

Hermes usa la herramienta cronjob internamente para configurarlo — sin CLI, sin sintaxis que recordar.

Referencia de formato de programación

Hermes acepta cuatro formatos de programación:

Formato	Ejemplo	Comportamiento
Retraso relativo	30m, 2h, 1d	Único, se ejecuta una vez después del retraso
Intervalo	every 30m, every 2h, every 1d	Recurrente hasta que se elimine
Expresión cron	0 9 * * * (diario), 0 9 * * 1-5 (días laborables), 0 */6 * * * (cada 6h)	Recurrente en horario fijo
Timestamp ISO	2026-12-25T09:00:00	Único en un momento futuro específico

Puedes sobrescribir el conteo de repeticiones predeterminado:

cronjob(
    action="create",
    prompt="Check mailbox for urgent messages",
    schedule="every 2h",
    repeat=5,        # ejecutar solo 5 veces, luego auto-eliminar
)

Trabajos Cron respaldados por Skills

El verdadero poder comienza cuando adjuntas skills. Un skill codifica un flujo de trabajo reutilizable — cuando un trabajo cron lo carga, el agente hereda esa experiencia sin que tengas que meter instrucciones en el prompt.

Skill único

cronjob(
    action="create",
    skill="blogwatcher",
    prompt="Check the configured feeds and summarize anything new.",
    schedule="0 9 * * *",
    name="Morning feeds",
)

Múltiples skills

Los skills se cargan en orden. El prompt se convierte en la instrucción final sobre todos los skills cargados:

cronjob(
    action="create",
    skills=["blogwatcher", "maps"],
    prompt="Look for new local events and interesting nearby places, then combine them into one short brief.",
    schedule="every 6h",
    name="Local brief",
)

Consejo práctico: Usa skills para separar responsabilidades. Un skill “recolector de datos” obtiene datos sin procesar; un skill “formateador” los embellece; un skill “entrega” los enruta. Mézclalos y combínalos en diferentes trabajos.

Ejecutar dentro de un directorio de proyecto

Por defecto, los trabajos cron se ejecutan en modo detached — no se carga ningún CLAUDE.md o AGENTS.md. Pasa --workdir (CLI) o workdir= (llamada de herramienta) para que el trabajo se ejecute dentro de un repositorio específico:

hermes cron create "every 1d at 09:00" \
  "Audit open PRs, summarize CI health, and post to #eng" \
  --workdir /home/me/projects/acme

Cuando workdir está configurado, los archivos de contexto del proyecto de ese directorio se inyectan en el prompt del sistema, y todas las herramientas de archivo/terminal usan ese directorio como base de trabajo.

Nota de serialización: Los trabajos con workdir se ejecutan secuencialmente (no en el pool paralelo) porque cambian el estado global del terminal del proceso. Los trabajos sin workdir siguen ejecutándose en paralelo.

Avanzado: Pipelines multi-trabajo con context_from

Los trabajos cron se ejecutan en sesiones aisladas sin memoria de ejecuciones anteriores. Pero a veces la salida de un trabajo es exactamente lo que necesita el siguiente. El parámetro context_from establece esa conexión automáticamente.

El patrón Pipeline

Aquí hay un pipeline de noticias de IA de 3 etapas — recolección, clasificación y entrega:

# Paso 1: Encuentra el ID del trabajo recolector
cronjob(action="list")

# Paso 2: Crea un trabajo de clasificación que recibe la salida del recolector
cronjob(
    action="create",
    prompt="Read ~/.hermes/data/briefs/raw.md. Score each story 1-10 for engagement and novelty. Output top 5 to ~/.hermes/data/briefs/ranked.md.",
    schedule="30 7 * * *",
    context_from="<collector_job_id>",
    name="AI News Triage",
)

# Paso 3: Crea un despachador que recibe la salida de clasificación
cronjob(
    action="create",
    prompt="Read ~/.hermes/data/briefs/ranked.md. Write 3 tweet drafts (hook + body + hashtags).",
    schedule="0 8 * * *",
    context_from="<triage_job_id>",
    deliver="telegram:7976161601",
    name="AI News Brief",
)

Cómo funciona context_from:

• Cuando el Trabajo B se dispara, Hermes lee la salida más reciente del Trabajo A desde ~/.hermes/cron/output/{job_a_id}/*.md
• Esa salida se antepone al prompt del Trabajo B automáticamente
• La cadena puede tener cualquier longitud: A → B → C → …
• Puedes pasar un solo ID (string) o una lista de IDs para patrones fan-in

Cuándo usar pipelines:

• Procesamiento multi-etapa (recolectar → filtrar → formatear → entregar)
• Tareas dependientes donde el paso N necesita los resultados del paso N−1
• Fan-out/fan-in: un trabajo agregador recopila resultados de varios recolectores

Modo sin agente: Vigilantes de solo script

Para tareas recurrentes que no necesitan un LLM — vigilantes clásicos de sistema, alertas de disco/memoria, heartbeats, pings de CI — pasa no_agent=True. El planificador ejecuta tu script programado y entrega stdout directamente, cero tokens, cero llamadas de inferencia.

Configuración CLI

hermes cron create "every 5m" \
  --no-agent \
  --script memory-watchdog.sh \
  --deliver telegram \
  --name "memory-watchdog"

Configuración impulsada por el agente

Solo dile a Hermes en el chat:

“Ping me on Telegram if RAM is over 85%, every 5 minutes.”

Hermes escribe el script de verificación en ~/.hermes/scripts/ y configura el trabajo cron automáticamente.

Semántica del modo sin agente

Condición	Comportamiento
Script stdout (no vacío)	Entregado textualmente como mensaje
stdout vacío	Tick silencioso — no se envía nada (el patrón watchdog)
Salida no cero o timeout	Alerta de error entregada (para que los watchdog rotos no fallen silenciosamente)
Última línea {"wakeAgent": false}	Tick silencioso (misma puerta que usan los trabajos LLM)

Archivos de script:

• .sh / .bash → se ejecuta bajo /bin/bash
• Cualquier otra cosa → se ejecuta bajo el intérprete Python actual (sys.executable)
• Deben residir en ~/.hermes/scripts/

Ejemplo real — un script watchdog de memoria:

#!/bin/bash
# ~/.hermes/scripts/memory-watchdog.sh
THRESHOLD=85
USAGE=$(free | awk '/^Mem:/ {printf "%.0f", $3/$2 * 100}')
if [ "$USAGE" -gt "$THRESHOLD" ]; then
    echo "⚠️  RAM alert: ${USAGE}% used (threshold: ${THRESHOLD}%)"
    echo "Top processes:"
    ps aux --sort=-%mem | head -6
fi
# Si está por debajo del umbral, el script no produce stdout → tick silencioso

Este script produce salida solo cuando la memoria excede el 85%. En días tranquilos, no envía nada — sin spam, sin atención desperdiciada.

Gestión del ciclo de vida

Cada trabajo cron tiene un ciclo de vida completo. Lo gestionas todo desde la CLI o desde el chat.

Comandos CLI

hermes cron list              # Listar todos los trabajos (--all para deshabilitados)
hermes cron pause my-digest   # Pausar por nombre o ID
hermes cron resume my-digest  # Reactivar
hermes cron run my-digest     # Disparar en el próximo tick del planificador
hermes cron edit my-digest --schedule "every 4h"  # Cambiar programación
hermes cron edit my-digest --prompt "Revised task"
hermes cron edit my-digest --add-skill maps       # Añadir un skill
hermes cron edit my-digest --remove-skill maps    # Eliminar un skill
hermes cron edit my-digest --clear-skills          # Eliminar todos los skills
hermes cron remove my-digest  # Eliminar completamente
hermes cron status            # Estado del planificador
hermes cron runs my-digest --limit 20  # Historial de ejecución

Desde el chat

/cron list
/cron pause <job_id>
/cron resume <job_id>
/cron run <job_id>
/cron edit <job_id> --schedule "every 4h"
/cron remove <job_id>

Búsqueda por nombre: Todos los comandos aceptan el ID hexadecimal del trabajo o el nombre del trabajo (sin distinción de mayúsculas/minúsculas). Si un nombre coincide con varios trabajos, el comando imprime los candidatos para que puedas desambiguar.

Historial de ejecución

Hermes registra cada ejecución cron en ~/.hermes/cron/executions.db. Cada intento pasa por claimed → running → uno de completed, failed o unknown (después del reinicio del proceso). Inspecciona con hermes cron runs [job-id] --limit 20.

Recuperación de proveedor y fijación de modelo

Los trabajos cron heredan tus proveedores de respaldo configurados y la rotación del pool de credenciales. Si la clave API principal tiene límite de tasa, el trabajo automáticamente recurre a un proveedor alternativo o rota a la siguiente credencial del pool.

Importante — comportamiento de fijación de modelo: Cuando creas un trabajo cron sin especificar proveedor/modelo, Hermes guarda una instantánea de tu valor predeterminado global actual en el trabajo. Si luego cambias el valor predeterminado global, el trabajo falla de forma segura — omite la ejecución y te avisa para que fijes el proveedor/modelo explícitamente. Esto evita que trabajos desatendidos cambien silenciosamente a un proveedor de pago o a un modelo diferente:

# Fijar un modelo específico a un trabajo
cronjob(
    action="update",
    job_id="<job_id>",
    provider="openrouter",
    model="anthropic/claude-sonnet-4",
)

Para ejecuciones desatendidas, hermes setup --portal (Nous Portal OAuth) es la opción de menor fricción — la actualización OAuth es automática.

Regla de seguridad: Las sesiones ejecutadas por cron no pueden crear nuevos trabajos cron. Hermes deshabilita las herramientas de gestión de cron dentro de las ejecuciones cron para evitar bucles de programación descontrolados.

Configuración de entrega

Segmentación por plataforma

Al programar un trabajo, especifica dónde va el resultado mediante el parámetro deliver:

# Entregar a Telegram
cronjob(action="create", ..., deliver="telegram")

# Entregar a un canal específico de Discord
cronjob(action="create", ..., deliver="discord:#engineering")

# Entregar a múltiples plataformas
cronjob(action="create", ..., deliver="telegram,discord")

# Distribuir a todos los canales principales conectados
cronjob(action="create", ..., deliver="all")

# Entregar al origen más todos los canales
cronjob(action="create", ..., deliver="origin,all")

Los destinos compatibles incluyen Telegram, Discord, Slack, WhatsApp, Signal, SMS, correo electrónico, Feishu, DingTalk, WeCom, Matrix y otros.

El patrón silencioso

Si la respuesta final del agente contiene [SILENT], la entrega se suprime por completo. La salida aún se guarda localmente para auditoría, pero no se envía ningún mensaje:

# Texto del prompt:
"Check if nginx is running. If everything is healthy, respond with only [SILENT]. Otherwise, report the issue."

Los trabajos fallidos siempre se entregan independientemente del silenciador — solo las ejecuciones exitosas pueden silenciarse.

Envoltorio de respuesta

Por defecto, la salida cron entregada se envuelve con un encabezado/pie:

Cronjob Response: Morning feeds
-------------

<salida del agente aquí>

Note: The agent cannot see this message, and therefore cannot respond to it.

Para entregar salida sin procesar sin el envoltorio:

# ~/.hermes/config.yaml
cron:
  wrap_response: false

Trabajos continuables (Responder a un Cron)

Por defecto, una entrega cron es de tipo dispara-y-olvida. Configura un trabajo como continuable (mediante attach_to_session=True) y podrás responderle — el resumen se convierte en una conversación:

# ~/.hermes/config.yaml
cron:
  mirror_delivery: true

O por trabajo mediante la herramienta:

cronjob(
    action="create",
    ...,
    attach_to_session=True,
)

En plataformas con capacidad de hilos (temas de Telegram, hilos de Discord), cada entrega abre un hilo dedicado. En plataformas solo DM (WhatsApp, Signal), el resumen se refleja en la sesión DM.

Playbook de producción: Tres configuraciones probadas en batalla

1. Resumen diario personal

Un resumen matutino que recopila actividad de GitHub, clima y eventos del calendario:

hermes cron create "0 8 * * 1-5" \
  "1. Check my GitHub notifications for any PRs requesting my review
   2. Check the weather forecast for today
   3. Summarize anything from my calendar that needs attention
   4. Format everything into a clean morning brief" \
  --deliver telegram \
  --name "daily-briefing"

Por qué funciona: Se ejecuta solo en días laborables (1-5), utiliza las herramientas integradas de búsqueda web y archivos de Hermes, y entrega directamente a Telegram donde puedes leerlo mientras tomas café.

2. Watchdog de repositorio GitHub

Un script sin agente que te avisa cuando cambia el último release de un repositorio:

#!/bin/bash
# ~/.hermes/scripts/github-watchdog.sh
REPO="NousResearch/hermes-agent"
CACHE_FILE="$HOME/.hermes/cron/output/latest_release.txt"
LATEST=$(curl -s "https://api.github.com/repos/$REPO/releases/latest" | grep -o '"tag_name": *"[^"]*"' | head -1)

if [ ! -f "$CACHE_FILE" ]; then
    echo "$LATEST" > "$CACHE_FILE"
    echo "📦 Initialized watcher for $REPO — latest: $LATEST"
    exit 0
fi

PREVIOUS=$(cat "$CACHE_FILE")
if [ "$LATEST" != "$PREVIOUS" ]; then
    echo "$LATEST" > "$CACHE_FILE"
    echo "🚀 New release detected for $REPO!"
    echo "   Previous: $PREVIOUS"
    echo "   Latest:   $LATEST"
    echo "   View: https://github.com/$REPO/releases/tag/$LATEST"
fi

Configúralo:

hermes cron create "every 6h" \
  --no-agent \
  --script github-watchdog.sh \
  --deliver telegram \
  --name "github-release-watchdog"

Costo cero de tokens. El script se ejecuta cada 6 horas, solo envía un mensaje cuando un release realmente cambia.

3. Verificador de salud de sitio web

Un pipeline multi-etapa: verificación web → análisis de logs → entrega de alerta.

Etapa 1 — Recolector (script sin agente):

#!/bin/bash
# ~/.hermes/scripts/health-check.sh
URL="https://hermes-agent-lab.com"
STATUS=$(curl -s -o /dev/null -w "%{http_code}" --max-time 10 "$URL")
TIME=$(curl -s -o /dev/null -w "%{time_total}" --max-time 10 "$URL")
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
echo "[$TIMESTAMP] $URL → HTTP $STATUS (${TIME}s)"

hermes cron create "every 30m" \
  --no-agent \
  --script health-check.sh \
  --name "site-health-collector"

Etapa 2 — Análisis (impulsado por LLM, encadenado desde el recolector):

hermes cron create "0 */2 * * *" \
  "Review the last 4 health checks for hermes-agent-lab.com.
   Are any failures or slow responses apparent?
   If everything is healthy, respond with only [SILENT].
   If there is an issue, write a summary of the problem and deliver it." \
  --context_from "<collector_job_id>" \
  --name "site-health-analyst"

El recolector se ejecuta cada 30 minutos (gratis, sin tokens). El analista se ejecuta cada 2 horas, recibe la salida del recolector como contexto y solo envía un mensaje cuando algo está mal.

Errores comunes y cómo evitarlos

1. Olvidar que el Gateway debe estar funcionando

La ejecución de cron es manejada por el demonio gateway. Si el gateway no está funcionando, tus trabajos no se dispararán:

hermes gateway install     # Instalar como servicio de usuario
hermes gateway status      # Verificar que está funcionando
hermes gateway run         # O ejecutar en primer plano para pruebas

2. Confusión entre retraso relativo e intervalo

• 30m = único en 30 minutos
• every 30m = recurrente cada 30 minutos

Este es un error común. Usa every explícitamente cuando quieras recurrencia.

3. Trabajos silenciosos que nunca hablan

Si tu trabajo se ejecuta pero nunca ves salida, el agente probablemente respondió con [SILENT] (caso de éxito) o el script no produjo stdout (caso sin agente). Revisa la salida local:

ls ~/.hermes/cron/output/
cat ~/.hermes/cron/output/<job_id>/*.md

4. Modelo/Proveedor que de repente no funciona

Los trabajos no fijados toman una instantánea del valor predeterminado actual al crearse. Si cambiaste de proveedor (hermes model), el trabajo te avisa para fijar explícitamente. Siempre fija los trabajos de producción:

hermes cron edit my-job --provider openrouter --model anthropic/claude-sonnet-4

5. Tiempos de pipeline superpuestos

Al encadenar trabajos con context_from, asegúrate de que el trabajo upstream termine antes de que comience el downstream. Si el Trabajo A se ejecuta a 0 7 * * * (7:00) y el Trabajo B a 0 7 * * * (también 7:00), el Trabajo B obtiene la salida del Trabajo A del día anterior — o un archivo vacío si es la primera ejecución. Desfásalos al menos 15–30 minutos.

6. Trabajos con Workdir bloqueándose entre sí

Los trabajos con workdir configurado se ejecutan secuencialmente. Diseña tus pipelines para que los trabajos con workdir no se conviertan en un cuello de botella — mantenlos cortos o usa trabajos intermedios sin workdir para procesamiento pesado.

Resumen

El cron de Hermes te transforma de operador manual a alguien que configura y olvida. Aquí está la hoja de referencia:

Tarea	Enfoque	Costo LLM
Resumen diario personal	Trabajo LLM único con búsqueda web	Bajo
Monitor de releases de GitHub	Script sin agente	Cero
Verificación de salud web + alerta	Pipeline: recolector sin agente → analista LLM	Bajo (cada 2 horas)
Pipeline de noticias de IA	Cadena multi-trabajo con context_from	Moderado
Watchdog de disco/memoria	Script sin agente	Cero
Difusión multiplataforma	Trabajo único con deliver="all"	Bajo

La combinación de sesiones completas de agente, inyección de skills, modo script sin agente y pipelines multi-trabajo hace que el cron de Hermes sea una de las herramientas de automatización más versátiles disponibles en cualquier framework de agentes de IA.

Comandos de inicio rápido

# Incorporación en 1 minuto: programa tu primer trabajo
hermes cron create "every 1d at 09:00" "Give me a 3-sentence summary of what happened on GitHub with NousResearch/hermes-agent since yesterday" --deliver telegram

# Listar y verificar
hermes cron list
hermes cron status

# Verlo ejecutarse en tiempo real
hermes cron run my-job-name

Para más información sobre la automatización de Hermes, consulta la documentación oficial de cron, nuestra guía de instalación y la comparativa de funcionalidades.