Hermes Agent #13: Cron Jobs — Automating Recurring Tasks

After exploring multiple profiles and configurations, let's dive into a feature that transforms Hermes Agent from a reactive assistant into a truly proactive one: cron jobs. This system allows you to schedule recurring or one-time tasks that run automatically, without any human intervention.

What is the Hermes Agent cron system?

Hermes Agent's cron system is comparable to Linux's traditional cron daemon, but with significantly enhanced capabilities. While classic cron executes shell scripts, Hermes runs autonomous AI agents capable of reasoning, using tools, browsing the web, and producing intelligent reports.

Specifically, cron jobs can:

• Schedule one-shot or recurring tasks
• Load one or multiple skills to leverage reusable workflows
• Deliver results to your Telegram, Discord, Slack chats, or local files
• Run in no-agent mode (pure script, no LLM) for simple tasks like monitoring
• Execute within a specific project directory to use its context (AGENTS.md, CLAUDE.md)

Important: Cron sessions cannot create new cron jobs recursively. Hermes disables cron management tools during scheduled executions to prevent infinite scheduling loops.

Anatomy of a cron job

Each cron job is defined by three fundamental elements:

• Action: what the scheduler should do (create, list, update, pause, resume, remove, run)
• Schedule: when to execute the task
• Prompt: what the agent should accomplish

Available actions

All operations go through a single cronjob tool with an action parameter:

• create — Create a new scheduled job
• list — List all existing jobs
• update — Modify an existing job (schedule, prompt, skills, etc.)
• pause — Suspend a job without deleting it
• resume — Re-enable a paused job
• run — Manually trigger a job on the next scheduler tick
• remove — Permanently delete a job

Schedule formats

Hermes Agent accepts four flexible scheduling formats:

Relative delays (one-shot):

30m    → Run once in 30 minutes
2h     → Run once in 2 hours
1d     → Run once in 1 day

Intervals (recurring):

every 30m  → Every 30 minutes
every 2h   → Every 2 hours
every 1d   → Every day

Classic cron expressions:

0 9 * * *      → Daily at 9:00 AM
0 9 * * 1-5    → Weekdays at 9:00 AM
0 */6 * * *    → Every 6 hours
30 8 1 * *     → First of every month at 8:30 AM
0 0 * * 0      → Every Sunday at midnight

ISO timestamps (one-shot):

2026-06-15T09:00:00  → One-time on June 15, 2026 at 9:00 AM

By default, one-shots execute once, while intervals and cron expressions run indefinitely until removed. The repeat parameter limits execution count.

Creating a cron job: different methods

From chat with /cron

/cron add 30m "Check server status"
/cron add "every 2h" "Fetch AI news and summarize"
/cron add "every 1h" "Analyze blog RSS feeds" --skill blogwatcher

From the command line

hermes cron create "every 2h" "Check server status"
hermes cron create "0 9 * * *" "Morning SEO report" \
  --workdir /home/user/projects/seo \
  --deliver telegram \
  --name "seo-morning-report"

Via natural conversation

Instead of technical syntax, simply ask:

Every morning at 9am, check Hacker News for AI news
and send me a summary on Telegram.

Hermes uses the cronjob tool internally to create the appropriate job.

Advanced cron job options

repeat — Limit executions

cronjob(action="create", prompt="Weekly report",
  schedule="every 1w", repeat=4)

deliver — Result destination

When creating a job, you specify where results are sent:

• "origin" — Back to where the job was created (default on messaging platforms)
• "local" — Save to ~/.hermes/cron/output/ (default in CLI)
• "telegram" — Main Telegram channel (via TELEGRAM_HOME_CHANNEL)
• "telegram:123456" — Specific Telegram chat by ID
• "discord", "slack", "whatsapp", "email", etc.

model and skills — Customize execution

You can assign a specific model and load skills:

cronjob(action="create",
  name="ai-watch",
  schedule="0 9 * * 1-5",
  model="gpt-4o",
  skills=["blogwatcher", "seo-analyzer"],
  prompt="Check configured sources, analyze today's AI trends,
  and produce a structured report.")

workdir — Work within a specific project

With workdir, the cron job inherits the project's context:

• AGENTS.md, CLAUDE.md, .cursorrules are injected into the system prompt
• terminal, read_file, write_file, etc. use this directory as cwd
• Jobs with workdir execute sequentially (not in parallel) to avoid cwd conflicts

enabled_toolsets — Fine-grained tool control

cronjob(action="create",
  name="news-summary",
  schedule="every sunday 9am",
  enabled_toolsets=["web", "file"],
  prompt="Summarize this week's AI news.")

This limits available tools per job to reduce costs and response times.

context_from — Chaining jobs

A job can consume another job's completed results:

cronjob(action="create",
  name="daily-digest",
  schedule="every day 7am",
  context_from=["ai-news-fetch", "github-prs-fetch"],
  prompt="Write the daily digest using the results above.")

Self-contained prompts: the golden rule

Cron jobs run in a completely fresh agent session. There is no conversation history, no shared context. The prompt must contain everything the agent needs.

❌ Bad example:

"Check the server issue"

✅ Good example:

"SSH to server 192.168.1.100 as user 'deploy', 
check if nginx is running with 'systemctl status nginx', 
and confirm that https://example.com returns HTTP 200. 
If an issue is detected, detail it."

Real-world use cases

1. Automated SEO monitoring

hermes cron create "0 8 * * 1-5" \
  "Analyze the top 10 keyword rankings for 
  https://example.com via the Ahrefs API. Compare with 
  last week's results. Generate a markdown report with 
  changes, new opportunities and threats. 
  Format: table with keyword, current position, change, trend." \
  --deliver telegram \
  --name "seo-daily-report" \
  --workdir /home/user/projects/seo

2. Daily system health report

hermes cron create "every 6h" \
  "SSH to the VPS server (see credentials in 
  /root/.ssh/config, host 'prod'). Run: df -h, free -m, 
  uptime, systemctl status nginx mysql redis. If any service 
  is down or disk exceeds 85%, flag it as ALERT at the top. 
  Otherwise, respond with [SILENT]." \
  --deliver telegram \
  --name "server-health-check"

3. RAM monitoring in no-agent mode

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

The memory-watchdog.sh script (stored in ~/.hermes/scripts/) checks RAM and only produces output if it exceeds 85%. Zero LLM cost.

4. Weekly multi-source digest

cronjob(action="create",
  name="weekly-ai-digest",
  schedule="every sunday 10am",
  skills=["blogwatcher", "maps"],
  context_from=["ai-news-fetch", "github-trending"],
  deliver="telegram",
  prompt="Write a weekly AI news digest. Structure: 
  1) Major events, 2) Popular GitHub projects, 
  3) Emerging trends, 4) What to watch next week. 
  Maximum 800 words. Concise and informative style.")

5. Automatic database backup

hermes cron create "0 2 * * *" \
  "Create a backup of the 'production' MySQL database 
  on the prod server (host 'prod' in ~/.ssh/config). 
  Use mysqldump, compress as gz, and transfer to 
  /backups/db/ with a filename including today's date. 
  Delete backups older than 30 days. 
  Confirm success or report the error." \
  --workdir /home/user/projects/backup \
  --name "daily-db-backup"

Essential best practices

Self-contained prompts

Every prompt must be complete and autonomous. Include all URLs, server identifiers, file paths, and necessary instructions. Don't hesitate to be verbose: a detailed 200-word prompt is far better than an ambiguous 10-word one.

No recursive scheduling

A cron job cannot create another one. If you need to chain tasks, use context_from so the second job consumes the first one's results.

Use [SILENT] for monitoring

For monitoring jobs that should only alert on problems, end the prompt with: "If everything is normal, respond only with [SILENT]." Output is saved locally for audit, but no message is sent.

Limit toolsets

Only assign necessary tools to each job via enabled_toolsets. A web monitoring job doesn't need browser or delegation tools. This reduces prompt schema cost and speeds up execution.

Choose the right mode

• Agent mode (default): for tasks requiring reasoning, analysis, synthesis
• No-agent mode: for watchdogs, threshold checks, heartbeats — zero LLM cost

Troubleshooting

Checking logs

hermes cron list          # View all jobs and their status
hermes cron status        # Scheduler state
hermes gateway            # Real-time logs

Job outputs are saved in ~/.hermes/cron/output/{job_id}/{timestamp}.md for post-mortem audit.

Paused jobs

A paused job retains its configuration but stops triggering. To re-enable:

/cron resume <job_id>
hermes cron resume <job_id>

Failed executions

Failed jobs generate an automatic alert (except in no-agent mode where empty stdout = silent tick). Common causes:

• Incomplete prompt: the agent lacks information to complete the task
• Timeout: scripts take too long (configurable via cron.script_timeout_seconds)
• Provider rate limit: Hermes automatically falls back to an alternate provider if configured
• Workdir issue: the specified path doesn't exist or isn't absolute

Provider resilience

Cron jobs inherit your fallback providers and credential rotation. If the primary API key is rate-limited, Hermes automatically switches to an alternate provider. Configure fallback_providers in config.yaml for maximum resilience.

Technical architecture

Cron job execution is managed by the gateway daemon. The scheduler ticks every 60 seconds:

1. Loads jobs from ~/.hermes/cron/jobs.json
2. Checks next_run_at against current time
3. Starts a fresh AIAgent session for each due job
4. Injects attached skills if applicable
5. Runs the prompt to completion
6. Delivers the final response
7. Updates metadata and next scheduled time

A file lock at ~/.hermes/cron/.tick.lock prevents overlapping ticks from double-running the same job batch.

To install the gateway:

hermes gateway install                    # User service
sudo hermes gateway install --system      # System service (VPS)

If you're hosting Hermes on a VPS, [Hostinger](https://hostinger.fr?REFERRALCODE=AIMASTER) offers excellent performance for running the gateway 24/7.

Conclusion

Hermes Agent's cron system radically transforms how you interact with AI. Instead of manually triggering every task, you delegate complete workflows that run autonomously. Whether for SEO monitoring, server monitoring, automated backups, or weekly digests, cron jobs enable Hermes to become a truly proactive assistant.

Key takeaways:

• Use detailed, self-contained prompts for every job
• Leverage no-agent mode for deterministic tasks with zero LLM cost
• Chain jobs with context_from for intelligent pipelines
• Limit toolsets to optimize costs and performance
• Monitor your logs and use [SILENT] for non-intrusive monitoring

With this feature, Hermes Agent is no longer just a tool you consult — it becomes an autonomous agent that works for you around the clock. To dive deeper into your environment setup, check out our guide on multiple profiles and configurations or learn how to connect Telegram to Hermes Agent to receive your cron reports directly.

Conclusion

Cron jobs transform Hermes Agent from a reactive assistant into a proactive system that works around the clock. Whether it's daily reports, service monitoring, or automated publishing, this feature covers a wide range of use cases.

Key takeaways:

• Use self-contained prompts for each job — cron sessions have no conversation context
• Chain jobs with context_from to build intelligent pipelines
• Limit toolsets to reduce costs and speed up execution
• Monitor logs and use [SILENT] for non-intrusive monitoring

To go further, discover how webhooks complement cron jobs by triggering actions from external services.

Conclusion

Hermes Agent cron jobs transform your AI agent into a true automation system. The ability to schedule recurring tasks, chain them together with context_from, and target delivery to any platform opens up vast possibilities. Whether automating reports, monitoring, or scheduled publications, cron jobs integrate naturally into the Hermes ecosystem. Key takeaways: self-contained prompts, measured toolset usage, and regular log monitoring to ensure the reliability of your automations.