Automatisiere alles mit Cron

Wenn du unser Tutorial zum täglichen Briefing-Bot gelesen hast, kennst du bereits die Grundlagen von Cron-Jobs. Aber das ist nur die Spitze des Eisbergs. Heute gehen wir tiefer – fünf praxisnahe Automatisierungsmuster, die du für deine eigenen Workflows übernehmen und anpassen kannst.

Bevor wir loslegen, hier die goldene Regel: Cron-Jobs laufen in frischen Agent-Sitzungen ohne Erinnerung an deinen aktuellen Chat. Deine Prompts müssen vollständig in sich geschlossen sein. Gib dem Agenten alles, was er wissen muss – Befehle, Kontext, Erwartungen. Stell es dir vor wie Anweisungen für einen sehr schlauen Praktikanten, der gerade erst zur Tür hereinkommt.

Zero-Token-Alternativen (Spare deine LLM-Aufrufe)

Nicht jede Automatisierung braucht ein LLM. Zwei Optionen ermöglichen es dir, die Token-Kosten komplett zu umgehen:

Wiederkehrender Watchdog – wenn dein Skript bereits die exakte Nachricht erzeugt (Speicherwarnungen, Festplattenwarnungen, Heartbeats), nutze reine Skript-Cron-Jobs. Gleicher Scheduler, kein LLM. Frag einfach Hermes im Chat – das cronjob-Tool weiß, wann no_agent=True gewählt werden muss, und schreibt das Skript für dich.
Einmalig aus einem laufenden Skript – für CI-Schritte, Post-Commit-Hooks oder Deploy-Skripte nutze hermes send, um stdout oder eine Datei direkt an Telegram, Discord, Slack usw. zu senden. Kein Cron-Eintrag nötig.

Muster 1: Website-Änderungsmonitor

Beobachte eine URL und erhalte nur dann eine Benachrichtigung, wenn sich tatsächlich etwas ändert. Die Geheimwaffe hier ist der script-Parameter – ein Python-Skript läuft vor jeder Ausführung, und seine stdout-Ausgabe wird zum Kontext für den Agenten. Das Skript übernimmt die mechanische Arbeit (Abrufen, Vergleichen); der Agent übernimmt die Bewertung (ist diese Änderung interessant?).

Zuerst das Überwachungsskript erstellen:

mkdir -p ~/.hermes/scripts

import hashlib, json, os, urllib.request

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

# Fetch current content
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()

# Load previous state
prev_hash = None
if os.path.exists(STATE_FILE):
    with open(STATE_FILE) as f:
        prev_hash = json.load(f).get("hash")

# Save current state
with open(STATE_FILE, "w") as f:
    json.dump({"hash": current_hash, "url": URL}, f)

# Output for the agent
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")

Jetzt den Cron-Job einrichten:

/cron add "every 1h" "If the script output says CHANGE DETECTED, summarize what changed on the page and why it might matter. If it says NO_CHANGE, respond with just [SILENT]." --script ~/.hermes/scripts/watch-site.py --name "Pricing monitor" --deliver telegram

Der [SILENT]-Trick: Bei Überwachungs-Jobs sag dem Agenten, er soll nur mit [SILENT] antworten, wenn sich nichts geändert hat. Die Cron-Zustellung behandelt dies als Ruhe-Marker – du wirst nur benachrichtigt, wenn tatsächlich etwas passiert. Kein Spam in ruhigen Zeiten.

Muster 2: Wochenbericht

Sammle Informationen aus mehreren Quellen und fasse sie zu einem formatierten Bericht zusammen. Dieser läuft einmal pro Woche und liefert an deinen Heimkanal.

/cron add "0 9 * * 1" "Generate a weekly report covering:

1. Search the web for the top 5 AI news stories from the past week
2. Search GitHub for trending repositories in the 'machine-learning' topic
3. Check Hacker News for the most discussed AI/ML posts

Format as a clean summary with sections for each source. Include links.
Keep it under 500 words — highlight only what matters." --name "Weekly AI digest" --deliver telegram

Über die CLI:

hermes cron create "0 9 * * 1" \
  "Generate a weekly report covering the top AI news, trending ML GitHub repos, and most-discussed HN posts. Format with sections, include links, keep under 500 words." \
  --name "Weekly AI digest" \
  --deliver telegram

Der Ausdruck 0 9 * * 1 ist ein Standard-Cron-Ausdruck: 9:00 Uhr jeden Montag.

Muster 3: GitHub-Repository-Beobachter

Überwache ein Repository auf neue Issues, PRs oder Releases.

/cron add "every 6h" "Check the GitHub repository NousResearch/hermes-agent for:
- New issues opened in the last 6 hours
- New PRs opened or merged in the last 6 hours
- Any new releases

Use the terminal to run gh commands:
  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

Filter to only items from the last 6 hours. If nothing new, respond with [SILENT].
Otherwise, provide a concise summary of the activity." --name "Repo watcher" --deliver discord

In sich geschlossene Prompts sind wichtig. Beachte, wie der Prompt die exakten gh-Befehle enthält. Der Cron-Agent hat keinen Gesprächsverlauf aus früheren Läufen – schreibe alles aus. (Persistentes Gedächtnis wird geladen, sodass dauerhafte Präferenzen aus MEMORY.md übernommen werden, aber verlass dich nicht darauf für kritische Job-Details.)

Muster 4: Datensammel-Pipeline

Sammle Daten in regelmäßigen Abständen, speichere sie in Dateien und erkenne Trends über die Zeit. Dieses Muster kombiniert ein Skript (für die Sammlung) mit dem Agenten (für die Analyse).

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

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

# Fetch current data (example: crypto prices)
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())

# Append to history file
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")

# Output for the agent
print(f"Collected prices at {entry['timestamp']}: {data}")

Dann einen Cron-Job einrichten, der das Skript ausführt und den Agenten bittet, die gesammelten Daten zu analysieren:

/cron add "every 30m" "Run the collection script, then analyze the price history in ~/.hermes/data/prices/history.jsonl. If you notice a significant trend (more than 5% change in the last hour), summarize it. Otherwise respond with [SILENT]." --script ~/.hermes/scripts/collect-prices.py --name "Price tracker" --deliver telegram

Muster 5: Der „Einfach-fragen“-Ansatz

Keine Lust, Skripte zu schreiben oder Cron-Syntax zu lernen? Beschreibe einfach in normaler Sprache, was du willst:

/cron add "every 2h" "Check if there are any new articles about AI regulation on Google News. If there are, summarize the top 3. If nothing new, respond with [SILENT]." --name "AI regulation watch" --deliver telegram

Der Agent kümmert sich um den Rest – Websuche, Filtern der Ergebnisse und Formatieren der Ausgabe.

Zusammenfassung

Diese fünf Muster decken die häufigsten Automatisierungsszenarien ab: Überwachung, Berichte, Repo-Beobachtung, Datensammlung und einfache „Einfach-fragen“-Jobs. Die wichtigsten Erkenntnisse:

Skripte übernehmen die mechanische Arbeit – Abrufen, Vergleichen, Sammeln
Agenten übernehmen die Bewertung – ist das interessant? was hat sich geändert? warum ist das wichtig?
[SILENT] hält dich spamfrei – du wirst nur benachrichtigt, wenn es wirklich wichtig ist
In sich geschlossene Prompts sind ein Muss – der Agent startet jedes Mal frisch

Die vollständige Funktionsreferenz findest du in der Dokumentation zu Geplante Aufgaben (Cron). Viel Spaß beim Automatisieren!