How to Set Up Scheduled Automations in Hermes Agent

Nous Research Hermes Agent ships with a cron scheduler built directly into the agent runtime. Unlike external scheduling that requires glue code between a system crontab and an agent invocation, Hermes exposes scheduling through a single cronjob tool that handles job creation, timing, skill loading, and result delivery in one unified interface.

The scheduler accepts four types of schedule input:

• One-shot delays: 30m, 2h, or 1d to run a task once after a specified wait
• Recurring intervals: every 30m, every 2h, or every 1d for repeating jobs
• Standard cron expressions: 0 9 * * * for precise time-based scheduling
• ISO timestamps: 2026-06-15T09:00:00 for one-time execution at an exact date and time

Each cron job runs in a fresh, isolated agent session with no memory of previous conversations or chat context. Every prompt must be self-contained: include all URLs, format instructions, and context the agent needs to complete the task. The upside is that jobs never leak state between runs, making each execution predictable and reproducible.

Results route to any configured messaging gateway. Telegram, Discord, Slack, email, SMS, Signal, Matrix, and WhatsApp are all supported delivery targets. Jobs created from a messaging chat automatically deliver back to that same chat by default, so a job you set up in Telegram sends its output right back to your Telegram conversation.

Beyond simple scheduled prompts, the cron system supports skill attachment (loading additional capabilities into a job), job chaining (feeding one job's output into another), and a no-agent script mode for lightweight watchdog tasks that skip LLM reasoning entirely. These features turn the scheduler into a capable automation layer that goes well beyond "run this prompt at 9 AM."

The Hermes gateway daemon powers the cron scheduler. It ticks every 60 seconds, checks for due jobs, and launches them in isolated agent sessions. Without a running gateway, cron jobs will not execute.

Install the gateway as a user-level service:

hermes gateway install

For system-level scheduling that starts at boot:

sudo hermes gateway install --system

Or run it in the foreground for testing and debugging:

hermes gateway

Verify the scheduler is active:

hermes cron status

The gateway uses a file lock at ~/.hermes/cron/.tick.lock to prevent overlapping ticks, so running multiple gateway instances on the same machine will not cause duplicate job execution.

Two storage paths matter for cron work:

• Job definitions: ~/.hermes/cron/jobs.json holds all configured jobs with their schedules, prompts, skills, and metadata
• Job output: ~/.hermes/cron/output/{job_id}/{timestamp}.md stores the result of each completed run

One early configuration to consider: cron output includes a header and footer wrapper by default. If you want cleaner output for downstream parsing or chat delivery, disable wrapping in your config file:

### ~/.hermes/config.yaml
cron:
  wrap_response: false

With the gateway running, you can create jobs from either the Hermes chat interface or the standalone CLI. Both interfaces produce identical results.

Creating a cron job requires two things: a schedule and a prompt. Hermes gives you two interfaces for this.

From the chat interface (inside a Hermes session):

/cron add "0 9 * * *" "Search Hacker News for the top 3 AI stories and write a one-paragraph summary of each."

From the standalone CLI:

hermes cron create "0 9 * * *" "Search Hacker News for the top 3 AI stories and write a one-paragraph summary of each."

Both create the same job. The first argument is the schedule, the second is the prompt.

You can also schedule jobs conversationally by describing what you want in natural language:

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

Hermes interprets the request and calls the cronjob tool with the appropriate schedule and delivery target.

Schedule Format Reference

One-shot (runs once):

• 30m fires 30 minutes from now
• 2h fires 2 hours from now
• 2026-06-15T09:00:00 fires at that exact timestamp

Recurring:

• every 30m repeats every 30 minutes
• every 2h repeats every 2 hours
• 0 9 * * * runs daily at 9:00 AM
• 0 9 * * 1-5 runs weekdays only at 9:00 AM
• 0 */6 * * * runs every 6 hours
• 30 8 1 * * runs the first of every month at 8:30 AM

Recurring jobs repeat indefinitely by default. Override this with the repeat parameter to limit the number of executions:

cronjob(
    action="create",
    prompt="Check server uptime and report anomalies",
    schedule="every 2h",
    repeat=5,
)

Delivery Targets

Chat-created jobs deliver results back to the originating chat by default. CLI-created jobs save to local storage. Override with --deliver:

hermes cron create "0 9 * * *" "Summarize today's news" --deliver telegram

Supported targets include origin, local, telegram, discord, slack, email, sms, signal, matrix, and whatsapp. You can also target a specific chat or thread by ID, such as telegram:-1001234567890:17585.

After creating any job, test it immediately without waiting for the schedule:

/cron run <job_id>

This triggers execution on the next scheduler tick, which is useful for verifying output before leaving a job to run on its own.

These three patterns cover the most common Hermes Agent cron use cases: a daily digest, an hourly monitor, and a weekly report that chains multiple jobs together.

Daily Briefing Bot

A weekday morning briefing that searches the web and delivers a summary:

/cron add "0 8 * * 1-5" "Search the web for the latest news about AI agents and open source LLMs. Find at least 5 articles from the past 24 hours. Summarize each in 2-3 sentences with links. Format with section headers and today's date."

This runs at 8 AM Monday through Friday. The prompt specifies what to search, how many results, the format, and which details to include. Since cron sessions start fresh every time, you must include everything the agent needs to produce a useful result.

For a multi-topic briefing, spell out each topic explicitly:

/cron add "0 8 * * *" "Create a morning briefing covering three topics: 1. AI/ML, focusing on open source models and agent frameworks 2. Cryptocurrency market moves for Bitcoin and Ethereum 3. Space exploration updates from SpaceX and NASA. Format each topic with a section header and bullet points."

The natural language equivalent works too. Tell Hermes "Every morning at 8am, give me a briefing on AI news, crypto markets, and space exploration. Deliver to Telegram." and it will create the same job.

Hourly Site Monitor

A lightweight watchdog using no-agent script mode:

hermes cron create "every 1h" \
  --no-agent \
  --script monitor-site.sh \
  --deliver telegram \
  --name "site-monitor"

The script (stored in ~/.hermes/scripts/) checks a URL hash and prints any detected changes. Empty stdout means no notification fires, keeping your chat quiet during normal operation. Non-zero exit codes trigger an error alert. This pattern costs zero LLM tokens for routine checks while still delivering alerts the moment something changes.

Weekly Report with Job Chaining

Build a multi-source digest by chaining jobs with context_from. First, create the data collection jobs that run early Monday morning:

/cron add "0 7 * * 1" "Fetch this week's trending GitHub repositories in Python and AI. List the top 10 with star counts and descriptions." --name "github-trends"

/cron add "0 7 * * 1" "Summarize the top Hacker News stories from the past 7 days. Focus on AI, developer tools, and infrastructure." --name "hn-weekly"

Then create a digest job that consumes both outputs two hours later:

cronjob(
    action="create",
    name="weekly-digest",
    schedule="0 9 * * 1",
    context_from=["github-trends", "hn-weekly"],
    prompt="Write a weekly tech digest combining the GitHub trends and Hacker News summaries above. Keep it under 500 words with section headers.",
)

The context_from parameter injects each referenced job's most recent completed output above the prompt. There is no automatic dependency resolution, so you manage timing through schedule offsets. The two-hour gap between collection (7 AM) and synthesis (9 AM) gives the source jobs time to finish.

Give Your Hermes Automations Persistent, Searchable Storage

Fast.io workspaces turn cron output into indexed, shareable knowledge. 50 GB free storage, built-in RAG, and no credit card required.

Sign Up Free

Attaching Skills to Cron Jobs

Skills extend what a cron job can do beyond the agent's default toolset. Attach a single skill with --skill:

/cron add "0 9 * * *" "Check the configured feeds and summarize anything new" --skill blogwatcher

For jobs that need several capabilities, attach multiple skills:

/cron add "every 6h" "Look for new local events and interesting nearby places, then combine them into one short brief" --skill blogwatcher --skill maps

Skills load sequentially, and the prompt acts as the task instruction layered on top. Hermes Agent skills follow the agentskills.io standard, so community-published skills work alongside custom ones.

Manage skills on existing jobs without recreating them:

/cron edit <job_id> --skill blogwatcher --skill maps
/cron edit <job_id> --remove-skill blogwatcher
/cron edit <job_id> --clear-skills

Building Pipelines with context_from

The context_from parameter is the foundation for multi-stage automation pipelines without external orchestration. When a job specifies context_from, the most recent completed output of each referenced job gets injected above the prompt text.

This separation works well in practice. Collection jobs handle raw research on their own schedule, and a downstream analysis job synthesizes the results. The consuming job does not need to know how the data was collected. It just sees the output as context.

One thing to plan for: there is no built-in dependency graph. If your analysis job fires before its source jobs finish, it gets stale or missing data. Offset schedules by enough margin that upstream jobs reliably complete first. For most web-scraping or search tasks, a one to two hour gap is sufficient.

No-Agent Script Mode

For mechanical tasks that do not require LLM reasoning, skip the agent entirely:

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

How script mode behaves:

• Stdout delivers verbatim to the target platform
• Empty stdout produces a silent tick with no notification
• Non-zero exit codes trigger an error alert regardless of silent mode
• Default timeout is 120 seconds, configurable in ~/.hermes/config.yaml under cron.script_timeout_seconds

Scripts live in ~/.hermes/scripts/. This mode is ideal for health checks, disk usage monitors, log watchers, and any repetitive check where a shell script gives you what you need without spending tokens on LLM inference.

Working Directory Support

Pin a cron job to a specific project directory:

hermes cron create "every 1d at 09:00" \
  "Audit open PRs, summarize CI health, and post to #eng" \
  --workdir /home/me/projects/acme

With a working directory set, Hermes injects AGENTS.md, CLAUDE.md, and .cursorrules from that directory into the session context. File and terminal tools operate relative to it. This is valuable for project-specific automations like daily PR reviews or CI health summaries that need repository context to produce useful output.

Note that workdir jobs run sequentially rather than in parallel to prevent corruption of the global terminal working directory.

Lifecycle Commands

After creating jobs, manage them through a consistent set of operations:

List all jobs:

/cron list

Pause a job without deleting it:

/cron pause <job_id>

Resume a paused job (recalculates the next run time):

/cron resume <job_id>

Edit a job's schedule or prompt:

/cron edit <job_id> --schedule "every 4h"
/cron edit <job_id> --prompt "Updated task instructions here"

Remove a job permanently:

/cron remove <job_id>

Every command works from both the chat interface (/cron) and the standalone CLI (hermes cron). One constraint worth knowing: cron-run sessions cannot create additional cron jobs. Hermes disables cron management tools during cron execution to prevent recursive scheduling loops.

Controlling the Toolset

Limit which tools a specific cron job can access:

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

This restricts the job to web and file tools only, preventing it from accidentally invoking other capabilities during execution.

Persisting Output Beyond Your Local Machine

All cron output saves to ~/.hermes/cron/output/{job_id}/{timestamp}.md by default. This works for solo use, but it has limits: outputs are tied to one machine, not easily searchable across runs, and not shareable with teammates or other agents.

For raw file archival, cloud storage like S3 or Google Drive handles the basics. But if you want your archived cron output to be searchable by meaning rather than just filename, you need something with built-in indexing.

Fast.io provides a workspace layer that turns cron output into searchable, shareable knowledge. Upload job results to a Fast.io workspace and Intelligence Mode auto-indexes the content for semantic search and RAG queries. A teammate can ask "what did the weekly digest say about PyTorch last month?" and get a cited answer from the archived outputs without manually searching through markdown files.

The Fast.io MCP server exposes upload, search, and AI tools that Hermes can call directly within cron job prompts. Add instructions to your prompt telling the agent to upload its summary to a named workspace, and the output persists beyond any single machine. The free agent plan includes 50 GB of storage and 5,000 monthly credits with no credit card or expiration.

Security Notes

Hermes scans cron prompts for prompt-injection and credential-exfiltration patterns at creation and update time. Jobs that fail these checks are rejected before they can run. This is worth knowing if your prompts include URLs or structured data that might trigger false positives. Keep prompts focused on the task instructions and avoid embedding raw credentials.