---
title: "Automation Templates: making cron jobs smart with Hermes Agent"
canonical: "https://agenticup.dev/posts/hermes-automation-templates/"
pubDate: "2026-06-12T00:00:00.000Z"
description: "Cron jobs are dumb. They run at 2am and dump output to a file you never read. Hermes Agent's Automation Templates fix that — an LLM evaluates the output, decides if it matters, and delivers a summary to Telegram. Here's how to set one up in 5 minutes."
tags: [hermes, automation, cron, webhooks, agents, devops]
---

Cron jobs are reliable. They run on schedule. They never complain.

They're also dumb. A cron job runs a script at 2am, dumps output to a log file, and moves on. If something breaks, you find out when a user tells you — not when the cron job runs.

Hermes Agent's new Automation Templates fix this by putting an LLM between the script and the output. Instead of dumping to a log, the script's output goes to an LLM that decides: is this important? Should I alert someone? Can I stay silent?

The result is a cron job that thinks before it speaks.

> **Key takeaways:**
> - Automation Templates are pre-built recipes for cron + LLM workflows — copy, paste, run
> - Three trigger types: schedule, GitHub events, API calls
> - LLM evaluates output and decides: alert, summarize, or stay silent
> - Works with any model — the LLM is only evaluating structured data
> - Six official templates: triage, PR review, docs audit, security audit, deploy verify, uptime monitor

## The problem with dumb cron jobs

Every team has them. A nightly backup check that emails a log. A weekly dependency audit that dumps to a file. A monitoring script that pages you at 3am for every minor blip.

The common pattern: run script → dump output → hope someone reads it.

Automation Templates flip this to: run script → LLM evaluates output → deliver only what matters.

The LLM isn't doing heavy lifting here. It's reading structured output (a list of issues, a diff, a status page) and making a binary decision: alert or stay silent. If it alerts, it writes a one-paragraph summary. If nothing's wrong, it says nothing at all.

This is the perfect job for an LLM. It's not creative work. It's triage.

## Setting up a nightly issue triage

The simplest template to start with is the nightly backlog triage. It runs every night, checks for new GitHub issues, and sends a summary to Telegram.

```bash
hermes cron create "0 2 * * *" \
  "You are a project manager triaging the repo.
  1. Run: gh issue list --repo owner/repo --state open --json number,title,labels,author,createdAt --limit 30
  2. Identify issues opened in the last 24 hours
  3. For each new issue: suggest a priority label (P0-P3) and category (bug, feature, docs, security), write a one-line triage note
  4. Summarize: total open, new today, breakdown by priority
  Format as a clean digest. If no new issues, respond with [SILENT]." \
  --name "Nightly backlog triage" \
  --deliver telegram
```

The `[SILENT]` token is the key detail. If there are no new issues, the LLM returns `[SILENT]` and Hermes sends nothing. If there are issues, you get a Telegram message with a summary. No empty reports, no noise.

## Automatic PR code review

The PR review template hooks into GitHub webhooks. When a PR is opened, Hermes fetches the diff, runs it through an LLM review prompt, and posts a comment directly on the PR.

```bash
hermes webhook subscribe github-pr-review \
  --events "pull_request" \
  --prompt "Review PR #{pull_request.number}: {pull_request.title}
  Fetch diff: curl -sL {pull_request.diff_url}
  Review for: security issues, performance concerns, code quality, missing tests.
  If trivial docs/typo change, say so briefly." \
  --skill github-code-review \
  --deliver github_comment
```

The webhook route is set up in one command. No server config, no middleware. Hermes listens on its webhook port and routes the event to the LLM prompt.

## Dependency security audit

This one runs daily and checks for vulnerabilities:

```bash
hermes cron create "0 6 * * *" \
  "Run: pip audit && npm audit
  Flag any CVEs with CVSS >= 7.0
  Check if upgrades are available
  Note whether each dependency is direct or transitive
  If clean, respond with [SILENT]" \
  --name "Dependency security audit" \
  --deliver telegram
```

The LLM parses the `pip audit` and `npm audit` output, filters by severity, and summarizes only the critical findings. A clean audit produces zero noise.

## Why this pattern works

Automation Templates work because they match the shape of the problem to the shape of the tool:

| Problem | Solution |
|---|---|
| Cron output nobody reads | LLM evaluates and summarizes |
| Alert fatigue from noisy monitors | LLM filters by severity, stays silent when clean |
| PRs merged without review | LLM reviews and posts comments automatically |
| Security advisories buried in email | LLM surfaces only CVSS >= 7.0 |

The LLM isn't replacing a human reviewer for complex judgment calls. It's replacing the log file you never read with a Telegram message you actually see.

## Setting up your own

To use Automation Templates, you need Hermes Agent running with:

1. The cron scheduler enabled (default)
2. A delivery target configured (Telegram, Slack, Discord, or email)
3. The webhook platform enabled (if using event-driven triggers)

Delivery targets are configured in `config.yaml` or `~/.hermes/config.yaml`:

```yaml
platforms:
  telegram:
    enabled: true
    bot_token: "..."
    chat_id: "..."
```

That's it. The templates handle the rest.

## Related Posts

- [How to set up Hermes Agent](/posts/how-to-set-up-hermes-agent/) — Getting Hermes running from scratch
- [How to build your first AI agent in 2026](/posts/how-to-build-first-ai-agent-2026/) — The fundamentals of agent loops
- [AI agent error handling patterns](/posts/ai-agent-error-handling-patterns/) — Building reliable production agents

---

*This article was published on Agentic Up (https://agenticup.dev) — practical guides for developers and founders building with AI agents. Reach me at hello@agenticup.dev.*