Long-Running Work in Hermes — Scheduled Jobs, Goals & Kanban

Which one do you need?

Scheduled jobs with hermes cron

Cron jobs are run by the gateway. It checks the schedule every 60 seconds and starts each due job in a fresh agent session. If the gateway isn't running, nothing fires. Keep it running as a service:

hermes gateway install      # user service (systemd on Linux, launchd on macOS)
sudo hermes gateway install --system   # Linux servers: start at boot
hermes gateway start

Creating a job

The easiest way is to ask: "Every morning at 9am, check Hacker News for AI news and send me a summary on Telegram." Hermes creates the job itself. Or be explicit:

# in a chat
/cron add "every 2h" "Check server status"
/cron add "every 1h" "Summarize new feed items" --skill blogwatcher

# from the shell
hermes cron create "every 2h" "Check server status" --deliver telegram --name "server-check"
hermes cron create "0 9 * * 1-5" "Morning brief: calendar, inbox, weather" --deliver telegram

Schedules can be relative one-shots (in 30m, in 1d), intervals (every 2h), plain English (every monday 9am, weekdays at 9am, daily at 7am), cron expressions (0 9 * * 1-5) or an ISO timestamp for a single run.

Write self-contained prompts. Each run starts with no memory of your chat. "Check on that server issue" fails. "SSH into 192.168.1.100 as deploy, check systemctl status nginx, and confirm https://example.com returns 200" works. Put reusable know-how in a skill and attach it with --skill.

Where results go

The final reply is delivered automatically; the prompt doesn't need to tell the agent to send anything. Set the target with --deliver:

• origin: back to the chat that created the job (the default on messaging platforms)
• local: saved to ~/.hermes/cron/output/ only (the default from the CLI)
• telegram, discord, slack, email and others: that platform's home channel. telegram:123456 or discord:#engineering picks a specific chat.
• telegram,discord sends to several places; all sends to every connected home channel.

Only hear about problems. Tell a monitoring job to reply with just [SILENT] when everything is fine. Successful silent runs send nothing, though output is still saved locally. Failed runs always notify you.

Jobs that remember (v0.21.0+)

Normally every run starts from scratch, so a news scout reports the same stories again. With --continuity, each run sees what it reported last time and can skip repeats:

hermes cron create "every 6h" "Scan for new AI agent releases; skip anything already reported" --continuity
hermes cron edit <job> --no-continuity

Which model a job uses, and keeping cost down

Each run picks its model in this order: the job's own pin, then cron.model in config, then your main chat model. Set a cheaper default for all your jobs so switching your chat model never moves them:

hermes config set cron.model <model-name>
hermes cron create "every 1h" "…" --reasoning-effort low   # per-job thinking level

Jobs can't create other cron jobs (this prevents runaway scheduling loops), and prompts are scanned for injection and credential-exfiltration patterns when a job is created or edited.

Script-only jobs: no model, no tokens

For disk alerts, heartbeats and CI pings, skip the AI entirely. The script's output is sent as-is, and empty output means nothing is sent:

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

Scripts must live in ~/.hermes/scripts/. They don't inherit your provider API keys, and a script that fails or times out sends an error alert, so a broken watchdog can't fail silently.

Managing jobs

hermes cron list                  # all jobs; "Overdue" means the scheduler stopped
hermes cron status                # is the scheduler alive, and what runs next
hermes cron run <job>             # run on the next tick
hermes cron pause|resume <job>
hermes cron edit <job> [flags]    # schedule, prompt, delivery, skills
hermes cron remove <job>
hermes cron doctor                # failed runs, failed deliveries, missing scripts
hermes pause / hermes resume      # emergency stop for everything scheduled

Jobs can be named instead of using IDs. To test a new job without it firing on its own, create it with --paused, then hermes cron resume it once you're happy. If jobs stop firing: hermes cron status flags anything more than 15 minutes overdue. Restart the gateway with hermes gateway restart, or run the job now with hermes cron run. A run that worked but whose message never arrived is recorded as delivery_failed, not ok.

Keep one task going: /goal

/goal gives Hermes a standing objective in the current conversation. After each turn, a small judge model checks whether it's done. If not, Hermes keeps working until the goal is met, you pause it, or the turn budget (20 by default) runs out. Use it for jobs where you'd otherwise type "keep going" three times:

/goal Fix every failing test in tests/api/ and make sure the test suite passes
/goal gate add pytest tests/api   # a command that must pass before it can be called done
/subgoal also add a regression test for the bug you just fixed
/goal status
/goal pause | /goal resume | /goal clear

/goal stays in one conversation. It never creates kanban tasks or hands work to other agents.

Many tasks, many agents: kanban

The kanban board is a task list stored in ~/.hermes/kanban.db and shared by all your Hermes profiles. Assign a task to a profile, and a dispatcher running inside the gateway starts that profile as a separate worker. Tasks survive crashes, can be blocked and unblocked, and keep a full history.

hermes kanban init
hermes gateway start                                              # hosts the dispatcher
hermes kanban create "research AI funding landscape" --assignee researcher
hermes kanban watch                                               # live activity
hermes kanban list

Compared with asking the agent to delegate to a subagent, kanban tasks are durable, resumable, and can be commented on or unblocked by you at any point. A subagent is anonymous and gone once it returns. The desktop app's Bot Mode (v0.21.0) puts the same idea in a chat-style interface: named bots in shared rooms that can message each other.

Safety for unattended work

• Approvals still apply. Flagged commands are checked by the smart-approval reviewer (on by default since v0.19.0). Your own deny rules block commands even in yolo mode.
• No step limit by default: agent.max_turns is unlimited out of the box, so a turn runs until it finishes. For jobs that shouldn't run long, set a number, or a time limit with agent.run_budget_seconds. See hardening.
• Know how to stop everything: hermes pause blocks new cron runs, kanban tasks and gateway turns without killing work already running.