Automatize Qualquer Coisa com Cron

O tutorial do bot de briefing diário cobre o básico. Este guia vai além — cinco padrões reais de automação que você pode adaptar aos seus próprios fluxos de trabalho.

Para a referência completa do recurso, veja Tarefas Agendadas (Cron).

Conceito-chave

Tarefas cron rodam em sessões novas do agente, sem memória do seu chat atual. Os prompts precisam ser completamente autossuficientes — inclua tudo o que o agente precisa saber.

Não precisa do LLM? Você tem duas opções com custo zero de token.

• Vigia recorrente em que o script já produz a mensagem exata (alertas de memória, alertas de disco, heartbeats): use tarefas cron só com script. Mesmo agendador, sem LLM. Você pode pedir ao Hermes no chat que monte uma para você — a ferramenta cronjob sabe quando escolher no_agent=True e escreve o script por você.
• Disparo único de um script que já está rodando (etapa de CI, hook de post-commit, script de deploy, monitor agendado externamente): use o hermes send para mandar a saída padrão ou um arquivo direto para Telegram / Discord / Slack / etc. sem criar uma entrada de cron.

---

Padrão 1: monitor de mudanças em site

Vigie uma URL em busca de mudanças e seja notificado só quando algo estiver diferente.

O parâmetro script é a arma secreta aqui. Um script Python roda antes de cada execução, e a saída padrão dele vira contexto para o agente. O script cuida do trabalho mecânico (buscar, comparar); o agente cuida do raciocínio (essa mudança é interessante?).

Crie o script de monitoramento:

mkdir -p ~/.hermes/scripts

~/.hermes/scripts/watch-site.py

import hashlib, json, os, urllib.request

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

# Busca o conteúdo atual
req = urllib.request.Request(URL, headers={"User-Agent": "Hermes-Monitor/1.0"})
content = urllib.request.urlopen(req, timeout=30).read().decode()
current_hash = hashlib.sha256(content.encode()).hexdigest()

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

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

# Saída para o agente
if prev_hash and prev_hash != current_hash:
    print(f"CHANGE DETECTED on {URL}")
    print(f"Previous hash: {prev_hash}")
    print(f"Current hash: {current_hash}")
    print(f"\nCurrent content (first 2000 chars):\n{content[:2000]}")
else:
    print("NO_CHANGE")

Monte a tarefa cron:

/cron add "every 1h" "Se a saída do script disser CHANGE DETECTED, resuma o que mudou na página e por que isso pode importar. Se disser NO_CHANGE, responda apenas [SILENT]." --script ~/.hermes/scripts/watch-site.py --name "Pricing monitor" --deliver telegram

O truque do [SILENT]

Em tarefas cron de monitoramento, oriente o agente a responder só [SILENT] quando nada mudou. A entrega do cron trata [SILENT] como marcador de silêncio, então você só é notificado quando algo realmente acontece — sem spam nas horas tranquilas.

---

Padrão 2: relatório semanal

Compile informações de várias fontes em um resumo formatado. Isto roda uma vez por semana e entrega no seu canal principal.

/cron add "0 9 * * 1" "Gere um relatório semanal cobrindo:

1. Busque na web as 5 principais notícias de IA da última semana
2. Busque no GitHub repositórios em alta no tópico 'machine-learning'
3. Verifique no Hacker News os posts de IA/ML mais discutidos

Formate como um resumo limpo, com seções para cada fonte. Inclua links.
Fique abaixo de 500 palavras — destaque só o que importa." --name "Weekly AI digest" --deliver telegram

Pela CLI:

hermes cron create "0 9 * * 1" \
  "Gere um relatório semanal com as principais notícias de IA, os repositórios de ML em alta no GitHub e os posts mais discutidos no HN. Formate com seções, inclua links, fique abaixo de 500 palavras." \
  --name "Weekly AI digest" \
  --deliver telegram

O 0 9 * * 1 é uma expressão cron padrão: 9:00 de toda segunda-feira.

---

Padrão 3: vigia de repositório do GitHub

Monitore um repositório em busca de novas issues, PRs ou releases.

/cron add "every 6h" "Verifique no repositório do GitHub NousResearch/hermes-agent:
- Novas issues abertas nas últimas 6 horas
- Novos PRs abertos ou mesclados nas últimas 6 horas
- Quaisquer novas releases

Use o terminal para rodar comandos gh:
  gh issue list --repo NousResearch/hermes-agent --state open --json number,title,author,createdAt --limit 10
  gh pr list --repo NousResearch/hermes-agent --state all --json number,title,author,createdAt,mergedAt --limit 10

Filtre só os itens das últimas 6 horas. Se não houver nada novo, responda [SILENT].
Caso contrário, dê um resumo conciso da atividade." --name "Repo watcher" --deliver discord

Prompts autossuficientes

Repare que o prompt inclui os comandos gh exatos. O agente do cron não tem histórico de conversa das execuções anteriores — escreva tudo por extenso. (A memória persistente é carregada, então preferências duradouras salvas no MEMORY.md continuam valendo, mas não conte com isso para detalhes críticos da tarefa.)

---

Padrão 4: pipeline de coleta de dados

Colete dados em intervalos regulares, salve em arquivos e detecte tendências ao longo do tempo. Esse padrão combina um script (para a coleta) com o agente (para a análise).

~/.hermes/scripts/collect-prices.py

import json, os, urllib.request
from datetime import datetime

DATA_DIR = os.path.expanduser("~/.hermes/data/prices")
os.makedirs(DATA_DIR, exist_ok=True)

# Busca os dados atuais (exemplo: preços de cripto)
url = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum&vs_currencies=usd"
data = json.loads(urllib.request.urlopen(url, timeout=30).read())

# Acrescenta ao arquivo de histórico
entry = {"timestamp": datetime.now().isoformat(), "prices": data}
history_file = os.path.join(DATA_DIR, "history.jsonl")
with open(history_file, "a") as f:
    f.write(json.dumps(entry) + "\n")

# Carrega o histórico recente para análise
lines = open(history_file).readlines()
recent = [json.loads(l) for l in lines[-24:]]  # Últimos 24 pontos de dados

# Saída para o agente
print(f"Current: BTC=${data['bitcoin']['usd']}, ETH=${data['ethereum']['usd']}")
print(f"Data points collected: {len(lines)} total, showing last {len(recent)}")
print(f"\nRecent history:")
for r in recent[-6:]:
    print(f"  {r['timestamp']}: BTC=${r['prices']['bitcoin']['usd']}, ETH=${r['prices']['ethereum']['usd']}")

/cron add "every 1h" "Analise os dados de preço da saída do script. Informe:
1. Preços atuais
2. Direção da tendência nos últimos 6 pontos de dados (subindo/caindo/estável)
3. Quaisquer movimentos notáveis (variação >5%)

Se os preços estiverem estáveis e nada for notável, responda [SILENT].
Se houver um movimento significativo, explique o que aconteceu." \
  --script ~/.hermes/scripts/collect-prices.py \
  --name "Price tracker" \
  --deliver telegram

O script faz a coleta mecânica; o agente acrescenta a camada de raciocínio.

---

Padrão 5: fluxo de trabalho com várias skills

Encadeie skills para tarefas agendadas complexas. As skills são carregadas em ordem antes de o prompt ser executado.

# Use a skill arxiv para achar artigos e depois a skill obsidian para salvar notas
/cron add "0 8 * * *" "Busque no arXiv os 3 artigos mais interessantes sobre 'language model reasoning' do último dia. Para cada artigo, crie uma nota no Obsidian com título, autores, resumo do abstract e a contribuição principal." \
  --skill arxiv \
  --skill obsidian \
  --name "Paper digest"

Direto pela ferramenta:

cronjob(
    action="create",
    skills=["arxiv", "obsidian"],
    prompt="Busque no arXiv artigos sobre 'language model reasoning' do último dia. Salve os 3 melhores como notas do Obsidian.",
    schedule="0 8 * * *",
    name="Paper digest",
    deliver="local"
)

As skills são carregadas em ordem — primeiro arxiv (ensina o agente a buscar artigos), depois obsidian (ensina a escrever notas). O prompt amarra as duas.

---

Gerenciar as suas tarefas

# Lista todas as tarefas ativas
/cron list

# Dispara uma tarefa na hora (para testar)
/cron run <job_id>

# Pausa uma tarefa sem apagá-la
/cron pause <job_id>

# Edita o agendamento ou o prompt de uma tarefa em execução
/cron edit <job_id> --schedule "every 4h"
/cron edit <job_id> --prompt "Descrição atualizada da tarefa"

# Adiciona ou remove skills de uma tarefa existente
/cron edit <job_id> --skill arxiv --skill obsidian
/cron edit <job_id> --clear-skills

# Remove uma tarefa em definitivo
/cron remove <job_id>

---

Destinos de entrega

A opção --deliver controla para onde vão os resultados:

Destino	Exemplo	Caso de uso
origin	--deliver origin	O mesmo chat que criou a tarefa (padrão)
local	--deliver local	Salva apenas em arquivo local
telegram	--deliver telegram	Seu canal principal do Telegram
discord	--deliver discord	Seu canal principal do Discord
slack	--deliver slack	Seu canal principal do Slack
Chat específico	--deliver telegram:-1001234567890	Um grupo específico do Telegram
Em thread	--deliver telegram:-1001234567890:17585	Uma thread de tópico específica do Telegram
Bot Chat	--deliver bot-chat	Injeta a saída no Bot Chat canônico deste perfil — o bot lê e responde
Bot Chat (nomeado)	--deliver bot-chat:research	O Bot Chat de outro perfil local

Entrega no Bot Chat

Destinos bot-chat entregam a saída da tarefa na sessão canônica "Bot Chat" de um perfil como uma mensagem de verdade — o bot a recebe como qualquer outra mensagem, age no que precisar de ação e responde nesse chat. É o destino a usar quando você quer que um bot veja e reaja a uma saída agendada, em vez de apenas arquivá-la no histórico de execuções.

O que você precisa saber:

• É local à máquina. O perfil precisa existir na máquina que roda o agendador (hermes profile list). Os nomes são validados na criação; perfis em outros gateways/máquinas não podem ser usados como destino.
• Custa um turno do bot. Cada entrega roda um turno completo do agente no Bot Chat do bot de destino — planeje o orçamento no caso de tarefas de alta frequência.
• Dá para combinar. --deliver bot-chat,telegram publica no bot E no seu canal principal do Telegram. O token all nunca se expande para destinos bot-chat.
• A mensagem entregue vem com um prefixo para o bot saber que veio de uma tarefa agendada, e não de você.

---

Dicas

Faça prompts autossuficientes. O agente de uma tarefa cron não tem memória das suas conversas. Inclua URLs, nomes de repositório, preferências de formato e instruções de entrega direto no prompt.

Use [SILENT] de propósito. Em tarefas de monitoramento, inclua instruções como "se nada mudou, responda apenas [SILENT]". Não peça ao agente que explique o token nos casos silenciosos — o cron trata [SILENT] como marcador de supressão de entrega.

Use scripts para coletar dados. O parâmetro script deixa um script Python cuidar das partes chatas (requisições HTTP, entrada e saída de arquivos, controle de estado). O agente só vê a saída padrão do script e aplica raciocínio em cima dela. Isso é mais barato e mais confiável do que fazer o agente buscar os dados sozinho.

Teste com /cron run. Antes de esperar o agendamento disparar, use /cron run <job_id> para executar na hora e conferir se a saída está certa.

Expressões de agendamento. Formatos aceitos: atrasos relativos (30m), intervalos (every 2h), expressões cron padrão (0 9 * * *) e timestamps ISO (2025-06-15T09:00:00). Linguagem natural como daily at 9am não é aceita — use 0 9 * * * no lugar.

---

Para a referência completa do cron — todos os parâmetros, casos-limite e detalhes internos — veja Tarefas Agendadas (Cron).

---