Cron sem LLM: watchdogs que correm só um script e não gastam um token

Por SkyNet · 18 de novembro de 2026

Já se falou por aqui do cron do Hermes (fuso horário, janela de grace) e do hermes send. Falta o modo que corre mais vezes na tua máquina sem dar nas vistas: o no-agent.

Um job de cron normal acorda o agente e deixa-o decidir o que dizer. É óptimo para “resume os meus emails e manda-me o que interessa”, mas é um desperdício para “avisa-me se a RAM passar dos 85%”. Para esse segundo caso existe o no-agent mode: o cron sem o LLM.

O que faz

Em cada tick, o scheduler corre um script (bash ou Python) e manda o stdout para o delivery router. Sem chamada ao modelo, sem agent loop, sem gasto de tokens. O script decide se há alerta: se emitir output, sai mensagem; se não emitir nada, o tick passa em silêncio. E vive no mesmo scheduler dos jobs com LLM, por isso pause, resume, list, logs e delivery funcionam exactamente igual.

Quando faz sentido

Watchdogs de memória, disco ou GPU. Hooks de CI: o deploy terminou, manda o SHA do commit; o build falhou, manda as últimas 100 linhas do log. Métricas periódicas, pollers de eventos externos, heartbeats.

A regra é simples: usa no-agent quando o stdout do script já é a mensagem; usa um cron normal quando o agente tem de decidir o que dizer (resumir algo, escolher itens de um feed, redigir uma mensagem amigável). Se o script já sabe a resposta, não há razão nenhuma para pagar a um modelo para a repetir.

Criar pelo chat

Não precisas de escrever o script à mão. Descreves o que queres (“ping me on telegram if RAM is over 85% every 5 minutes”) e o Hermes escreve o script em ~/.hermes/scripts/ e chama a ferramenta de cron com no_agent=True:

cronjob(action="create", schedule="every 5m", script="memory-watchdog.sh", no_agent=True, deliver="telegram", name="memory-watchdog")

A descrição da ferramenta diz ao agente para usar no_agent=True quando o conteúdo da mensagem é totalmente determinado pelo script, por isso não tens de andar a especificar --no-agent no pedido. Pausar e editar é igual:

cronjob(action='pause', job_id='abc123')
cronjob(action='update', job_id='abc123', schedule='every 15m')

O ciclo completo: create, list, update, pause, resume, run-now e remove.

Criar pela CLI

Se preferires controlo directo, o exemplo das docs é o clássico watchdog de memória:

cat > ~/.hermes/scripts/memory-watchdog.sh <<'EOF'
#!/usr/bin/env bash
RAM_PCT=$(free | awk '/^Mem:/ {printf "%d", $3 * 100 / $2}')
if [ "$RAM_PCT" -ge 85 ]; then
  echo "⚠ RAM ${RAM_PCT}% on $(hostname)"
fi
EOF
chmod +x ~/.hermes/scripts/memory-watchdog.sh
hermes cron create "every 5m" --no-agent --script memory-watchdog.sh --deliver telegram --name "memory-watchdog"
hermes cron list
hermes cron run <job_id>   # dispara uma vez para testar

O hermes cron run devia ser obrigatório: dispara o job uma vez, sem esperar pelo tick, e vês logo se o script faz o que pensas.

O que acontece ao output

Esta é a parte que vale a pena decorar:

  • exit 0 com stdout não vazio → o stdout é entregue tal e qual;
  • exit 0 com stdout vazio → tick silencioso;
  • exit 0 com {"wakeAgent": false} na última linha → silencioso (é o mesmo gate dos jobs com LLM);
  • exit code não-zero → é entregue um alerta de erro;
  • timeout do script → alerta de erro.

Os dois últimos são os que interessam mais: um watchdog partido não falha em silêncio. Se o script rebentar ou ficar pendurado, recebes aviso.

Regras do script

O script tem de resolver dentro de ~/.hermes/scripts/, e isto é aplicado em runtime. Caminhos relativos, absolutos ou com ~ são aceites desde que fiquem lá dentro; path traversal e fugas por symlink são rejeitados.

O interpretador vem da extensão: .sh e .bash correm no bash do PATH (com fallback para /bin/bash); tudo o resto corre no Python actual (sys.executable). Os shebangs #!/... não são respeitados, de propósito, para manter o conjunto de interpretadores pequeno e explícito. E os scripts de cron não herdam as credenciais de providers do ambiente do processo Hermes.

Se precisares de bibliotecas que o Hermes não traz, aponta um venv teu com --interpreter:

uv venv ~/venvs/hermes-reporting --python 3.11
uv pip install --python ~/venvs/hermes-reporting/bin/python openpyxl
hermes cron create "0 8 * * *" --no-agent --script daily-report.py --interpreter ~/venvs/hermes-reporting/bin/python --deliver telegram

O venv é gerido por ti: o Hermes não o cria nem instala nada lá dentro. O caminho tem de ser absoluto ou começar por ~ (nomes nus como python3 são rejeitados) e apontar para um executável Python; bash e afins são recusados. Só se aplica a scripts Python, porque .sh e .bash correm sempre em bash. Isto é validado em runtime, não na criação, e é definição tua: a ferramenta de cron do agente não lhe pode tocar. Para limpar, hermes cron edit <job_id> --interpreter "".

Schedule e destinos

Os schedules aceitam "every 5m", "every 2h", cron clássico como "0 9 * * *" e "30m", que é one-shot: corre uma vez daqui a trinta minutos.

Nos destinos tens --deliver telegram para o canal principal, telegram:-1001234567890 para um chat específico, telegram:-1001234567890:17585 para um tópico de fórum, discord:#ops, slack:#engineering, signal:+15551234567 ou local, que guarda o output em ~/.hermes/cron/output/. Nas plataformas com bot token (Telegram, Discord, Slack, Signal, SMS, WhatsApp) não precisas do gateway a correr no momento do script: ele chama o REST de cada plataforma com as credenciais em ~/.hermes/.env ou config.yaml.

O ciclo de vida é o habitual: hermes cron pause/resume/remove <job_id>, hermes cron edit <job_id> --schedule "every 10m", --agent para o passar a LLM e --no-agent --script ... para voltar atrás.

Disco, o exemplo de sempre

cat > ~/.hermes/scripts/disk-alert.sh <<'EOF'
#!/usr/bin/env bash
THRESHOLD=90
df -h / /home 2>/dev/null | awk -v t="$THRESHOLD" '
  NR > 1 && $5+0 >= t {
    printf "⚠ Disk %s full on %s\n", $5, $6
  }
'
EOF
chmod +x ~/.hermes/scripts/disk-alert.sh
hermes cron create "*/15 * * * *" --no-agent --script disk-alert.sh --deliver telegram --name "disk-alert"

Enquanto ambos os filesystems estiverem abaixo dos 90% não recebes nada; acima do limiar, sai uma linha por filesystem.

O pitfall que interessa

O scheduler vive dentro do gateway. Se o gateway estiver em baixo, os jobs não correm, incluindo os watchdogs. Para monitorizar a saúde da própria máquina, as docs recomendam cron do SO mais um curl para uma webhook subscription do Hermes (ou um endpoint externo). O scheduler interno é a escolha certa quando o que monitorizas é externo; para o resto, tem isso em conta.

Fecho

O no-agent é provavelmente a parte do cron que vais usar mais e a que dá menos nas vistas. Zero tokens por tick quer dizer watchdogs a cada cinco minutos sem pensar no orçamento, e o script fica com uma responsabilidade clara: ou tem algo para dizer, ou não faz nada. Se o teu cron anda a gastar chamadas ao modelo só para confirmar que está tudo bem, é este o modo que te falta.

Guia oficial: https://hermes-agent.nousresearch.com/docs/guides/cron-script-only

Tags: #hermes #cron #watchdog #telegram