Hermes Agent Use Cases: 9 Real-World Workflows

What makes a good Hermes use case

Most AI tools answer one request and stop. Hermes is built around a gateway process that stays up, and that changes what it is good for. According to the upstream repo and docs, one gateway connects to your messaging platforms, keeps sessions, runs cron jobs and delivers replies. Around that sit persistent memory, a skills system, subagent delegation, MCP support and a terminal tool that can run locally, in Docker or over SSH.

So a good Hermes use case usually has at least one of these traits:

• It happens in a chat app, not an IDE.
• It repeats, on a schedule or whenever something happens.
• It benefits from the agent remembering you, your team or your setup.
• It should keep running when nobody is at a keyboard.

If none of those apply, a one-shot tool may be the better fit. There is a comparison table at the end.

1. A personal assistant in your chat app

The most common setup: Hermes on Telegram, WhatsApp, Discord or another platform you already use, answering questions, drafting messages, searching the web and running small tasks. Upstream lists more than twenty platforms, including Telegram, Discord, Slack, WhatsApp, Signal, Email, Matrix, Microsoft Teams, Feishu/Lark, WeCom and Weixin.

Memory is what makes it feel like an assistant rather than a chatbot. Hermes keeps two small curated files, MEMORY.md for its own notes about your environment and USER.md for your preferences, and loads them at the start of every session. For older details it can search past conversations with its session_search tool. Tell it once that you prefer short answers, or which city you live in, and it carries that forward.

Setup guides: Telegram, Discord, WhatsApp.

2. A shared team assistant

One bot for a whole team, reachable from Slack, Discord or Telegram. Each person gets their own session, and access is locked down. The upstream team tutorial shows two ways to authorize people on Telegram: a numeric allowlist in ~/.hermes/.env, or DM pairing, where a new user gets a one-time code and the owner approves it:

# Allowlist
TELEGRAM_ALLOWED_USERS=123456789,987654321

# Or approve a pairing code a teammate received
hermes pairing approve telegram XKGH5N7P
hermes pairing list

Good team jobs include answering “how do we deploy X” from shared docs, drafting replies, summarizing long threads and posting a daily standup prompt to a channel. See Hermes Agent + Slack.

3. Daily briefings and scheduled research

This is where Hermes pulls ahead of a chat window. Its cron scheduler runs a fresh agent session on a timer and delivers the result to a chat, a file or another platform. You can set it up by just asking:

Every morning at 8am, check the news on AI agents and send me a 5-bullet summary on Telegram.

Or be explicit, in chat or from the CLI:

/cron add "every 1h" "Summarize new feed items" --skill blogwatcher
hermes cron create "every 2h" "Check server status"

Jobs can attach one or more skills, and you can pause, edit, trigger or remove them later. Two details from the docs worth knowing: an unpinned job runs on whatever your main model is when it fires, so pin a model if a job must stay on a particular one; and before each run Hermes checks that credentials, skills and delivery targets are in place, so a misconfigured job sends one alert instead of burning tokens. Upstream’s “Daily Briefing Bot” tutorial walks through the full recipe.

4. Server monitoring and light DevOps

Hermes’s terminal tool can run commands locally, in Docker, over SSH, or in hosted sandboxes such as Modal and Daytona. Combined with cron, that gives you an ops assistant: check disk and memory, tail a log for errors, confirm a service answers, and message you only when something is wrong.

For pure watchdogs you do not even need the model. A no-agent cron job runs a script on schedule and delivers its output verbatim, with empty output meaning “all fine, stay quiet”:

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

That costs no tokens, and a script that crashes still triggers an alert. When you do let the agent run commands, keep approvals.mode on smart or manual. Upstream warns that off removes every safety check and belongs only in a trusted sandbox.

5. GitHub pull request review

Upstream documents two patterns. The simple one is a cron job that polls your repos with the gh CLI every couple of hours, reviews new PRs and sends a summary to Telegram or Discord. It needs no public endpoint, so it works behind NAT. The real-time one uses Hermes’s webhook platform: GitHub posts an event when a PR opens, Hermes pulls the diff and comments on the PR.

One caution from the docs: PR titles, descriptions and commit messages are attacker-controlled text, so a public webhook is a prompt-injection surface. Run that gateway in a sandboxed backend such as Docker or SSH, not on your main machine. See also Hermes Agent + GitHub.

6. Hand coding jobs to Claude Code, Codex or OpenCode

Hermes can edit files itself, but for serious repo work it can also act as a dispatcher. Upstream bundles skills for Claude Code, Codex and OpenCode. The Claude Code skill prefers print mode, a one-shot run through the terminal tool:

claude -p 'Add error handling to all API calls in src/' --allowedTools 'Read,Edit' --max-turns 10

For longer, multi-turn work the skill drives an interactive session inside tmux. The practical result: you message your bot “fix the failing test in the billing repo and tell me when it passes” from your phone, Hermes hands it to the coding CLI, and it reports back in chat. The coding CLI needs its own install and login on the same machine as Hermes. Google’s Gemini CLI has no bundled skill, but works the same way. See Hermes + Gemini CLI.

7. Research with parallel subagents

For questions that split cleanly, Hermes’s delegate_task tool spawns child agents with their own context and terminal sessions. Only each child’s final summary comes back to the parent, so a broad research task does not flood the main conversation. A batch looks like this in the docs:

delegate_task(tasks=[
    {"goal": "Research topic A", "context": "Focus on recent primary sources"},
    {"goal": "Research topic B", "context": "Compare the leading explanations"},
])

Tasks can also carry an output_schema so each child returns structured JSON. Typical uses: competitor scans, comparing vendors, or reading several long documents at once. Web search is built in, with providers such as Firecrawl, SearXNG, Tavily and Exa. See Hermes Agent web search.

8. A hub for your other tools via MCP

If a tool already has an MCP server, Hermes can use it without a native integration. Add it under mcp_servers in ~/.hermes/config.yaml:

mcp_servers:
  filesystem:
    command: "npx"
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"]

Stdio and HTTP servers both work, and you can filter which tools each server exposes. It also works the other way round: hermes mcp serve turns Hermes into a stdio MCP server, so an editor agent on the same machine can read and send messages on your connected chat platforms. And if you want your own front end, Hermes has an OpenAI-compatible API server. Details in Hermes Agent + MCP.

9. Workflows that turn into skills

Skills are Hermes’s reusable playbooks, stored in ~/.hermes/skills/ and loaded only when needed. You can install them from registries (hermes skills browse, hermes skills search, hermes skills install), invoke one with /skill-name, or attach them to cron jobs.

The interesting part is that Hermes writes them too. A background review after conversations can save a workflow that worked as a new skill, and /learn distills a directory, URL or notes into one. Over weeks, the bot gets better at your recurring jobs specifically. For bigger multi-agent projects, Hermes also has a Kanban board where worker profiles claim tasks. More in Hermes Agent skills.

When a one-shot coding CLI is enough

Hermes is not the right tool for everything. If the job starts and ends in one terminal session, the gateway, memory and scheduler are overhead you do not need.

The OpenClaw equivalent

OpenClaw, the other open-source agent we host, covers much of the same ground with its own mechanisms: chat channels such as Telegram, Discord, Slack and WhatsApp; a gateway scheduler managed with openclaw cron; skills from ClawHub; a bundled coding-agent skill that hands work to Codex, Claude Code or OpenCode as background workers; and openclaw mcp serve to expose its channels over MCP. The config formats are different, so do not copy settings from one to the other. If you are choosing between them, see Hermes vs OpenClaw.

Running these use cases on OpenClaw Launch

Every workflow above that involves chat, schedules or memory needs the Hermes gateway running around the clock. You can do that on your own VPS (see Deploy Hermes Agent), or let OpenClaw Launch run it: pick Hermes or OpenClaw, choose a model, connect Telegram or Discord from the dashboard, and the bot keeps its memory and cron jobs between sessions. Coding delegation is the one exception worth planning for, since it needs a coding CLI installed and logged in next to the agent. A simple split is to keep the coding CLI on your own machine and let the hosted bot handle the always-on part. For a comparison of hosting options, see Best Hermes Hosting.

Hermes Agent use cases FAQ

Related guides

• What Is Hermes Agent?
• Install Hermes Agent
• Hermes Agent Skills
• Hermes Agent CLI
• Deploy Hermes Agent
• Best Hermes Hosting
• Managed Hermes Hosting