# How to Set Up Scheduled Automations in Hermes Agent

Hermes Agent includes a built-in cron scheduler that runs automated tasks on any recurring schedule. This guide covers creating jobs with natural language or cron expressions, attaching skills, chaining job outputs, and delivering results to Telegram, Discord, Slack, or email.

Source: https://fast.io/resources/hermes-agent-scheduled-automations-cron/
Last reviewed: 2026-05-05

## What the Hermes Agent Cron Scheduler Does

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."

## Run the Gateway Daemon

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:

```bash
hermes gateway install
```

For system-level scheduling that starts at boot:

```bash
sudo hermes gateway install --system
```

Or run it in the foreground for testing and debugging:

```bash
hermes gateway
```

Verify the scheduler is active:

```bash
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:

```yaml
### ~/.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.

## Schedule Formats and Job Creation

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:**

```bash
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:

```python
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`:

```bash
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.

## Three Practical Automation Patterns

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:

```bash
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:

```python
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.

## Skills, Job Chaining, and Script Mode

### 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](https://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:

```bash
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:

```bash
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.

## Managing Jobs and Persisting Output

### 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:

```python
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.

[Fastio](https://fast.io) provides a workspace layer that turns cron output into searchable, shareable knowledge. Upload job results to a Fastio 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 [Fastio MCP server](/storage-for-agents/) 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 [Business Trial](/pricing/) includes generous storage and monthly credits during the trial 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.

## Frequently asked questions

### How do I schedule automated tasks in Hermes Agent?

Use the /cron add command in chat or hermes cron create from the CLI. Provide a schedule (cron expression like 0 9 * * *, interval like every 2h, or natural language) and a self-contained prompt with all context the agent needs. The Hermes gateway daemon must be running for jobs to execute on schedule.

### Can Hermes Agent send scheduled reports to Telegram?

Yes. Add --deliver telegram when creating a cron job, or create the job from within a Telegram chat where Hermes is connected. Jobs created from a messaging platform deliver results back to the originating chat by default. You can also target specific chats or threads by ID.

### How do I chain multiple cron jobs in Hermes Agent?

Use the context_from parameter to inject one job's output into another. Create collection jobs that run at an earlier time, then create a downstream job with context_from referencing those job names. Offset the schedules so collection jobs reliably complete before the downstream job fires.

### What is the no-agent script mode in Hermes Agent cron?

No-agent mode runs a shell script directly without invoking the LLM, keeping token costs at zero. Create one with --no-agent --script scriptname.sh. The script's stdout delivers verbatim to the target platform, empty output stays silent, and non-zero exit codes trigger error alerts. Scripts live in ~/.hermes/scripts/ with a default 120-second timeout.

### Where does Hermes Agent store cron job output?

Job definitions live in ~/.hermes/cron/jobs.json. Each completed run saves its output to ~/.hermes/cron/output/{job_id}/{timestamp}.md. For persistent, team-accessible storage, you can instruct cron jobs to upload results to a cloud workspace like Fastio, where Intelligence Mode indexes the content for semantic search.

### Can I attach skills to a Hermes Agent cron job?

Yes. Use --skill skillname when creating or editing a job. Multiple skills can be attached to a single job and they load sequentially. Manage skills on existing jobs with /cron edit using --remove-skill or --clear-skills without needing to recreate the job.

## About Fast.io

Fast.io provides shared workspaces where people and AI agents work on the same files, with built-in semantic search and citation-backed chat over what they hold. Agents reach it through a remote MCP server at https://mcp.fast.io/mcp, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli.