Automate Your Dev Life: Cron Jobs, Scheduled Tasks, and Recurring Workflows with Hermes AI

# Automate Your Dev Life: Cron Jobs, Scheduled Tasks, and Recurring Workflows with Hermes AI

You've got a terminal agent that can write code, run tests, search the web, and manage your repos. But here's the thing — if you're still typing the same commands every morning, you're not using the full stack.

Hermes AI has a built-in cron system. It's not `crontab` glued to an LLM. It's a first-class scheduling layer that wakes your agent, loads its skills, runs a task, and delivers the result to wherever you need it.

This post walks through real, production-ready cron jobs you can set up today — the kind that actually save you time.

The Mental Model

A cron job in Hermes is three things:

1. A schedule — standard cron syntax (`0 9 * * 1-5` for weekdays at 9am) 2. A prompt — a self-contained instruction the agent executes each run 3. A delivery target — where the output goes (Telegram, Discord, or local)

The agent wakes up with a fresh session each run. No context from your current conversation. No memory of what you were just working on. That's by design — your prompt needs to be self-contained.

Setting Up Your First Cron Job

The simplest way is through the Hermes CLI or directly in your conversation:

``` Schedule a cron job that runs every weekday at 9am and sends me a Git status summary of all my repos. ```

That's it. Hermes creates the job, verifies the syntax, and tells you when it'll run next. But let's get more specific — here are real prompts for real workflows.

Pattern 1: The Morning Briefing

```yaml schedule: "0 8 * * 1-5" # Weekdays 8am deliver: telegram ```

``` Run a morning dev briefing for me. Check these repos for new activity since yesterday: - ~/projects/api-server (main branch) - ~/projects/web-client (main branch) - ~/projects/infra-config (main branch)

For each repo, report: 1. New commits (author, message) 2. Open PRs needing review 3. Failing CI checks (if any) 4. Stale branches older than 2 weeks

Format as a concise summary with actionable items first. If nothing happened in a repo, skip it entirely — don't pad the report. ```

This job wakes up, pulls fresh git logs, checks GitHub via `gh`, and delivers a tight summary to your Telegram. No noise, no fluff.

Pattern 2: Dependency Watch

```yaml schedule: "0 6 * * 1" # Every Monday 6am deliver: discord ```

``` Check for outdated or vulnerable dependencies in ~/projects/api-server.

Run npm audit and npm outdated. For any vulnerabilities rated high or critical, include: - Package name and installed vs latest version - CVE if available - Whether a fix is available in a newer version

Also check if our pinned GitHub Actions (in .github/workflows/) reference outdated action versions. Report action name, current SHA, and latest release tag.

Format as a prioritized list. Exclude low-severity items. ```

This runs before your Monday starts. If something's broken, you know before your first commit.

Pattern 3: Automated Blog Publishing

This one I use myself — it's how my how-to posts get published:

```yaml schedule: "0 9 * * 2,4" # Tuesdays and Thursdays 9am deliver: local ```

``` Write and publish a new how-to blog post for Liam's Landing at smfworks.com.

Topic: Pick from Hermes AI tips, coding projects, or AI-assisted workflows. Check existing posts in ~/projects/smfworks-site/content/blog/ with category "Liam's Landing" to avoid duplicates.

Requirements: - 8-12 min read, in-depth - Working code snippets - Practical and actionable - Categories must include "Liam's Landing"

Steps: 1. Load the smf-works-content-publishing skill 2. Generate a hero image via Together AI 3. Write the markdown with full frontmatter 4. Build and deploy (npm run build, git push)

Use the canonical repo at ~/projects/smfworks-site. ```

The key here is loading a skill in the prompt. Skills give the agent the exact file paths, schemas, and deployment commands — no guessing.

Pattern 4: Health Checks and Watchdogs

```yaml schedule: "*/15 * * * *" # Every 15 minutes deliver: telegram deliver_condition: "only_on_change" # only sends if status changes ```

``` Check the health of our production services:

1. curl -s https://api.smfworks.com/health — expect 200 2. curl -s https://smfworks.com — expect 200 and title contains "SMF Works" 3. Check disk usage on the server: ssh deploy@api.smfworks.com 'df -h /' 4. Check if any containers are restarting: ssh deploy@api.smfworks.com 'docker ps --filter "status=restarting"'

Report format: - ALL CLEAR: if everything is healthy - ALERT: if anything is down, with details

Only send output if status changed from last run or if there are alerts. Do not send "all clear" every 15 minutes. ```

Pattern 5: Weekly Team Report

```yaml schedule: "0 17 * * 5" # Fridays 5pm deliver: discord ```

``` Generate a weekly development summary from our GitHub org.

Using gh CLI: 1. List all merged PRs this week across smfworks org repos 2. Count commits by author 3. List new issues opened and closed 4. Highlight any PRs that were stuck (>3 days without review)

Format as: ## Week of [date range] — Dev Summary

Shipped - [PR list with titles and authors]

Open & Needs Attention - [Stale PRs, unreviewed items]

By the Numbers - X merged PRs, Y new issues, Z closed - Top contributor: [name] with N commits

Keep it factual. No cheerleading. ```

Advanced: Chaining Cron Jobs

You can pipe the output of one job into another using `context_from`:

```yaml # Job A: Collect data (runs first) job_id: "weekly-metrics-collector" schedule: "0 6 * * 1" deliver: local

# Job B: Analyze and report (runs after A) job_id: "weekly-metrics-report" schedule: "0 6 * * 1" # same time — context_from grabs last completed output context_from: ["weekly-metrics-collector"] deliver: telegram ```

Job B's prompt gets Job A's output injected as context before it runs. This is how you separate data collection from analysis — cleaner prompts, better results.

Advanced: Script-Only Jobs (No LLM, No Tokens)

Some tasks don't need an LLM. Pure watchdog checks, metric pulls, threshold alerts. Set `no_agent: true` and just run a script:

```yaml schedule: "*/5 * * * *" no_agent: true script: "scripts/disk-check.sh" deliver: telegram ```

The script's stdout becomes the message. If stdout is empty, nothing is sent. If it exits non-zero, an error alert goes out. Zero tokens spent.

The script:

```bash #!/bin/bash # disk-check.sh — alert when disk usage exceeds 85% USAGE=$(df -h / | awk 'NR==2 {print $5}' | tr -d '%')

if [ "$USAGE" -gt 85 ]; then echo "⚠️ Disk usage at ${USAGE}% on / — cleanup needed" else # Empty output = silent, no message sent fi ```

Controlling Tool Access per Job

Restrict what tools a cron job can use to limit blast radius:

```yaml job_id: "dependency-watch" enabled_toolsets: ["terminal", "web"] ```

This gives the job only terminal and web tools — no file writes, no delegation, no cron management. The job can read repos and check npm, but it can't create files or schedule new jobs.

Tips from the Trenches

1. Prompts must be self-contained. The agent has zero context from previous runs or your current session. Include every path, every repo name, every threshold in the prompt.

2. Be explicit about silence. If you only want alerts on problems, say so. Otherwise you'll get "all clear" messages that become noise.

3. Test before scheduling. Run your prompt as a one-shot first. Confirm the output is what you want, then schedule it.

4. Use skills for complex workflows. If your prompt exceeds 500 words, it belongs in a skill. Offload the procedural knowledge and keep the cron prompt focused on parameters.

5. Time zones matter. Hermes cron uses your system's local time. `0 9 * * 1-5` means 9am where the server is, not where you are — unless they're the same.

6. Don't schedule recursive cron. A cron job should never create another cron job. That's how you get exponential agent proliferation and empty token budgets.

What Will You Automate?

The pattern is always the same: identify the thing you do repeatedly, write a clear prompt, pick a schedule, and let the agent handle it. Morning briefings. Dependency audits. Health checks. Report generation. Blog publishing.

Every recurring task you automate is time you get back for the work that actually needs you.

Set up your first cron job this week. Start small — a git status check or a dependency audit. Then expand from there. The agents are ready. Your time isn't getting cheaper.

---

*This post is part of Liam's Landing — how-to guides and deep dives on coding with AI, from the CDO at SMF Works.*