Tarefas Cron Só com Script (sem LLM)

Tarefas Cron Só com Script

Às vezes você já sabe exatamente qual mensagem quer enviar. Não precisa de um agente para raciocinar sobre ela — você só precisa de um script rodando num timer, e da saída dele (se houver) chegando no Telegram / Discord / Slack / Signal.

O Hermes chama isso de modo no-agent. É o sistema de cron menos o LLM.

   ┌──────────────────┐          ┌──────────────────┐
   │ disparo agendado │  a cada  │ roda o script    │
   │(a cada N minutos)│ ──────▶ │ (bash ou python) │
   └──────────────────┘          └──────────────────┘
                                          │
                                          │ stdout
                                          ▼
                                 ┌──────────────────┐
                                 │ roteador de envio│
                                 │ (telegram/disc…) │
                                 └──────────────────┘

• Nenhuma chamada de LLM. Zero tokens, zero laço de agente, zero gasto com modelo.
• O script é a tarefa. O script decide se alerta ou não. Emitiu saída → a mensagem é enviada. Não emitiu nada → tique silencioso.
• Bash ou Python. Arquivos .sh / .bash rodam sob o bash do PATH quando disponível, senão sob /bin/bash; qualquer outra extensão roda sob o interpretador Python atual. Os caminhos precisam resolver dentro de ~/.hermes/scripts/ (formas relativas, absolutas ou com ~ valem, desde que fiquem nesse diretório). Scripts de cron não herdam as credenciais de provedor do ambiente do processo do Hermes.
• Mesmo agendador. Vive no cronjob ao lado das tarefas com LLM — pausar, retomar, listar, logs e escolha de destino funcionam do mesmo jeito.

Quando usar

Use o modo no-agent para:

• Vigias de memória / disco / GPU. Rodam a cada 5 minutos e alertam só quando um limite é ultrapassado.
• Ganchos de CI. Deploy terminou → publique o SHA do commit. Build falhou → envie as últimas 100 linhas do log.
• Métricas periódicas. "Receita diária do Stripe às 9h" como uma simples chamada de API + impressão formatada.
• Sondas de eventos externos. Consulte uma API e alerte quando o estado mudar.
• Batimentos. Pingue um painel a cada N minutos para provar que a máquina está viva.

Use uma tarefa de cron normal (guiada por LLM) quando você precisa que o agente decida o que dizer — resumir um documento longo, escolher itens interessantes de um feed, redigir uma mensagem amigável. O caminho no-agent é para os casos em que o stdout do script já É a mensagem.

Criar uma pelo chat

A grande vantagem do modo no-agent é que o próprio agente monta o vigia para você — sem editor, sem shell, sem decorar flags de CLI. Você descreve o que quer, o Hermes escreve o script, agenda e avisa quando vai disparar.

Exemplo de conversa

Você: me avise no telegram se a RAM passar de 85% a cada 5 minutos

Hermes: (escreve ~/.hermes/scripts/memory-watchdog.sh e depois chama cronjob(...) com no_agent=true)

Pronto. Roda a cada 5 min e alerta o Telegram só quando a RAM passa de 85%. Script: memory-watchdog.sh. ID da tarefa: abc123.

Por baixo dos panos, o agente faz duas chamadas de ferramenta:

# 1. Escreve o script de verificação
write_file(
    path="~/.hermes/scripts/memory-watchdog.sh",
    content='''#!/usr/bin/env bash
ram_pct=$(free | awk '/^Mem:/ {printf "%d", $3 * 100 / $2}')
if [ "$ram_pct" -ge 85 ]; then
  echo "RAM ${ram_pct}% em $(hostname)"
fi
# stdout vazio = tique silencioso; nenhuma mensagem enviada.
''',
)

# 2. Agenda — no_agent=True pula o LLM em todo tique
cronjob(
    action="create",
    schedule="every 5m",
    script="memory-watchdog.sh",
    no_agent=True,
    deliver="telegram",
    name="memory-watchdog",
)

Daí em diante todo tique sai de graça: o agendador roda o script, manda o stdout para o Telegram se não estiver vazio, e nunca encosta num modelo.

O que o agente decide por você

Quando você formula um pedido do tipo "me alerte quando X" ou "a cada N minutos confira Y e me diga se Z", a descrição da ferramenta cronjob do Hermes manda ele recorrer a no_agent=True sempre que o conteúdo da mensagem for inteiramente determinado pelo script. Ele volta para o caminho normal, guiado por LLM, quando o pedido exige raciocínio ("resuma as issues novas", "escolha as manchetes mais interessantes", "redija um lembrete simpático").

Você não precisa especificar --no-agent você mesmo. Basta descrever o comportamento.

Gerenciar os vigias pelo chat

O agente pode pausar, retomar, editar e remover tarefas do mesmo jeito que as cria:

Você: pare o vigia de memória por esta noite

Hermes: (chama cronjob(action='pause', job_id='abc123'))

Pausado. Retome com "ligue de novo" ou pelo hermes cron resume abc123.

Você: mude para a cada 15 minutos

Hermes: (chama cronjob(action='update', job_id='abc123', schedule='every 15m'))

O ciclo de vida completo (criar / listar / atualizar / pausar / retomar / rodar agora / remover) fica disponível para o agente sem que você aprenda nenhum comando de CLI.

Criar uma pela CLI

Prefere o shell? O caminho pela CLI dá o mesmo resultado com três comandos:

# 1. Escreva seu script
cat > ~/.hermes/scripts/memory-watchdog.sh <<'EOF'
#!/usr/bin/env bash
# Alerta quando o uso de RAM passa de 85%. Silencioso no resto do tempo.
RAM_PCT=$(free | awk '/^Mem:/ {printf "%d", $3 * 100 / $2}')
if [ "$RAM_PCT" -ge 85 ]; then
  echo "⚠ RAM ${RAM_PCT}% em $(hostname)"
fi
# stdout vazio = execução silenciosa; nenhuma mensagem enviada.
EOF
chmod +x ~/.hermes/scripts/memory-watchdog.sh

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

# 3. Confira
hermes cron list
hermes cron run <job_id>    # dispare uma vez para testar

É só isso. Sem prompt, sem skill, sem modelo.

Como a saída do script vira entrega

Comportamento do script	Resultado
Saída 0, stdout não vazio	o stdout é entregue literalmente
Saída 0, stdout vazio	Tique silencioso — nada é entregue
Saída 0, stdout com {"wakeAgent": false} na última linha	Tique silencioso (mesma trava das tarefas com LLM)
Código de saída diferente de zero	Um alerta de erro é entregue (para um vigia quebrado não falhar em silêncio)
Tempo do script esgotado	Um alerta de erro é entregue

O comportamento "silencioso quando vazio" é a chave do padrão clássico de vigia: o script fica livre para rodar a cada minuto, mas o canal só vê uma mensagem quando algo realmente precisa de atenção.

Regras dos scripts

Os scripts precisam ficar em ~/.hermes/scripts/. Isso é exigido tanto na criação da tarefa quanto na execução — caminhos absolutos, expansão de ~/ e padrões de travessia de diretório (../) são rejeitados. O mesmo diretório é compartilhado com a trava de script de pré-verificação usada pelas tarefas com LLM.

A escolha do interpretador é pela extensão do arquivo:

Extensão	Interpretador
.sh, .bash	bash do PATH (reserva /bin/bash)
qualquer outra	sys.executable (o Python atual)

Nós deliberadamente NÃO honramos shebangs #!/... — manter o conjunto de interpretadores explícito e pequeno reduz a superfície em que o agendador confia.

Sintaxe de agendamento

A mesma de todas as outras tarefas de cron:

hermes cron create "every 5m"        # intervalo
hermes cron create "every 2h"
hermes cron create "0 9 * * *"       # cron padrão: 9h todo dia
hermes cron create "30m"             # disparo único: roda uma vez daqui a 30 minutos

Veja a referência do recurso cron para a sintaxe completa.

Destinos de entrega

O --deliver aceita tudo que o gateway conhece. Alguns formatos comuns:

--deliver telegram                       # canal padrão da plataforma
--deliver telegram:-1001234567890        # conversa específica
--deliver telegram:-1001234567890:17585  # tópico de fórum específico do Telegram
--deliver discord:#ops
--deliver slack:#engineering
--deliver signal:+15551234567
--deliver local                          # só salva em ~/.hermes/cron/output/

Nenhum gateway em execução é necessário na hora de rodar o script para plataformas com token de bot (Telegram, Discord, Slack, Signal, SMS, WhatsApp) — a ferramenta chama direto o endpoint REST de cada plataforma usando as credenciais que já estão em ~/.hermes/.env / ~/.hermes/config.yaml.

Edição e ciclo de vida

hermes cron list                                    # ver todas as tarefas
hermes cron pause <job_id>                          # para de disparar, mantém a definição
hermes cron resume <job_id>
hermes cron edit <job_id> --schedule "every 10m"    # ajusta a cadência
hermes cron edit <job_id> --agent                   # muda para o modo LLM
hermes cron edit <job_id> --no-agent --script …     # volta atrás
hermes cron remove <job_id>                         # apaga

Tudo que funciona nas tarefas com LLM (pausar, retomar, disparo manual, mudança de destino de entrega) funciona também nas tarefas no-agent.

Exemplo prático: alerta de espaço em disco

cat > ~/.hermes/scripts/disk-alert.sh <<'EOF'
#!/usr/bin/env bash
# Alerta quando / ou /home passa de 90% de uso.
THRESHOLD=90
df -h / /home 2>/dev/null | awk -v t="$THRESHOLD" '
  NR > 1 && $5+0 >= t {
    printf "⚠ Disco %s cheio em %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"

Silencioso enquanto os dois sistemas de arquivos estiverem abaixo de 90%; dispara exatamente uma linha por sistema de arquivos acima do limite quando um enche.

Comparação com outros padrões

Abordagem	O que roda	Quando usar
cronjob --no-agent (esta página)	Seu script no agendador do Hermes	Vigias / alertas / métricas recorrentes que não precisam de raciocínio
cronjob (padrão, com LLM)	Agente com script opcional de pré-verificação	Quando o conteúdo da mensagem exige raciocinar sobre dados
Cron do sistema + curl para uma assinatura de webhook	Seu script no agendador do sistema	Quando o Hermes pode estar com problema (justamente o que você monitora)

Para vigias críticos de saúde do sistema que precisam disparar mesmo com o gateway fora do ar, use o cron do sistema operacional com um curl simples para uma assinatura de webhook do Hermes (ou qualquer endpoint externo de alerta) — eles rodam como processos independentes do sistema e não dependem de o Hermes estar de pé. O agendador dentro do gateway é a escolha certa quando o que está sendo monitorado é externo.

Relacionados

• Automatize qualquer coisa com cron — padrões de cron guiados por LLM.
• Referência de Tarefas Agendadas (Cron) — sintaxe completa de agendamento, ciclo de vida, roteamento de entrega.
• Assinaturas de Webhook — pontos de entrada HTTP do tipo dispare-e-esqueça para agendadores externos.
• Gateway por dentro — o interior do roteador de entrega.

---