Introduction

I came across the Hermes Agent project around the end of last year and gave it a try. I’ve been using it for over half a year now, and I can’t live without it. Today I’ll talk about how I use it.

What Hermes Is, and How I Installed It

Simply put, Hermes is a local AI assistant CLI. You chat with it through Telegram, and behind the scenes it calls a large language model, then directly operates your computer — reading files, writing code, checking servers, calling APIs.

The biggest difference from ChatGPT: it can actually take action. You say “check the alerts for me,” and it queries Grafana on its own, analyzes the PromQL, and sends you the results. No need to copy-paste error messages or look up docs manually.

Installation is simple — one command:

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

After installing, you can just run hermes and start chatting. If you want it running long-term in the background (for example, connected to Telegram), install it as a gateway service:

hermes gateway install   # install as a background service
hermes gateway start     # start it

Configuration mainly falls into three parts: model, channel, and tools.

For the model, I tried Claude Sonnet — it works well but is too slow; checking an alert takes 10 seconds. Later I switched to deepseek-v4-flash, which is more than twice as fast, and I don’t worry about tokens.

For the channel, I connected Telegram — fill in the bot token and your Telegram ID in the config file, and it automatically listens for your messages. You can also skip Telegram and just use the CLI.

Tools are the essence of Hermes. It comes with dozens of built-in tools organized into multiple toolsets — file operations, terminal commands, web search, browser automation, code execution, all usable out of the box. You can also extend it with MCP servers; for example, I’ve hooked up a Grafana MCP and some database MCPs, so I can query monitoring and databases just by asking. Built-in plus MCP, I now have dozens of tools available — I haven’t even counted exactly how many.

What I Use It For Every Day

1. Checking alerts

This is what I use it for most. Every morning when I get to my desk, I start with “check the alerts,” and Hermes goes straight to Alertmanager to pull the active alert list. The output looks something like this:

3 critical alerts
  - ArgoCD Sync failed × 2 (production, staging)
  - K8s Pod unhealthy × 1 (project-13-dev)
27 warning alerts
  - Container memory over 90% × 8
  - Host disk almost full × 3
  ...

Then it analyzes which are old recurring issues and which are newly appeared ones, and prioritizes them for me. This saves me from opening Grafana and flipping through everything every morning.

2. Replying to Feishu messages

Colleagues often ask me questions on Feishu. Hermes operates Feishu through the local lark-cli (Feishu’s official open-source CLI tool) — it can send messages, search chat history, look up contacts, and more.

Configuration is a two-step process: first initialize the app credentials, then log in and authorize.

lark-cli config init     # initialize (generates an authorization link, complete it in the browser)
lark-cli auth login      # login and authorize

A typical use case is just saying “reply to XX’s message for me,” and it will:

1. Pull the recent conversations from Feishu
2. Figure out what the other person is asking
3. Answer directly if it has the knowledge; ask me first if something needs confirmation
4. Send the reply

Then it automatically scans for new messages and handles them as needed. It answers technical questions directly and forwards uncertain ones to me for confirmation — I barely have to type anymore.

It’s not just DMs either — for some monitoring groups, I have it do weekly review summaries, pulling historical messages from the Feishu group and organizing them into reports.

3. Watching the market

I’ve added some scheduled tasks. Every morning at 6:00, Hermes automatically sends a “Ningbo Morning Brief” to Telegram:

• Weather (Open-Meteo)
• Gold price (Shanghai Gold Exchange quote, ¥/g)
• A-share market indices
• Zhejiang fuel prices
• DeepSeek account balance
• Hermes version

After reading that message, I basically know where things stand for the day.

4. Writing and modifying code

This one I didn’t expect to be so good. When I hit a bug, I just throw the error at it, and it goes through the code, checks the logic, pinpoints the cause, and gives me a fix.

The most memorable time was troubleshooting a SkyWalking OAP startup failure. It checked the Pod logs, checked the config, checked the ArgoCD commit history on its own, and finally pinpointed a config file format issue, even providing the fix command along the way. The whole process took 5 minutes; doing it myself would have taken half an hour.

5. Writing blog posts

Yes, what you’re reading right now was written by it. I said “write a blog post about how I use Hermes,” and it looked at my blog’s format and the layout of my previous posts, then wrote this one.

The earlier Ghostty config, push-up workout records, and JVM parameter tuning posts were all first drafts by it too. I polished them a bit and published.

6. Managing scheduled tasks

I currently have a bunch of cron jobs running on it:

(I’ll cover the benefits of those two Feishu tasks in the “Memory system” section below.)

The Skills System

Hermes has a Skills mechanism — you can save complex operations you’ve done as a “skill manual,” and next time you encounter a similar problem, it automatically loads the skill and executes it.

For example, I wrote a “Grafana alert check” skill that records:

• The Alertmanager URL
• Alert grouping rules (grouped by alertname into 6 receivers)
• The alert types I care about (ArgoCD / container memory / host CPU / K8s Pod health)
• Analysis preferences (distinguish old vs new alerts, sort by severity)

Now every time I say “check the alerts,” it loads this skill and checks and analyzes the way I’m used to, without me describing it again.

Skills grow thicker over time. After fixing a new pitfall, I write a skill on the spot, and next time it’s automatically avoided.

The Memory System

Hermes has built-in memory (MEMORY.md + USER.md) that loads automatically at the start of every conversation. You can also hook up an external memory backend to strengthen it — I’m currently using OpenViking, a memory service I self-hosted on the internal network.

Several ways of remembering:

1. User Profile — a quick-reference card stored in built-in memory: what my name is, what I do, what my preferences are. Loaded automatically every conversation, so I don’t repeat myself.
2. Memory (assistant notes) — memos stored in built-in memory: environment configs, tool usage. For example, it knows my Grafana address and my wg-easy architecture.
3. OpenViking — an external memory service running on a machine on the internal network. During conversations it automatically extracts facts, entities, and events, indexes and stores them, and you can also manually write conclusions. It can hold much more than built-in memory — my daily Feishu chat records are also imported into it on a schedule.
4. Conversation history search — Hermes’ built-in session_search can directly search past conversations. For example, if I ask “how did that JVM parameter issue get resolved later,” it can dig out the discussion and conclusion from historical sessions. SQLite + FTS5, pretty fast.

How to configure it

Built-in memory is on by default. To switch to an external backend, run:

hermes memory setup

Just pick the backend — for OpenViking, fill in the service address. After that, it silently builds indexes in the background during conversations, and you can also proactively write conclusions in.

From my experience, automatic accumulation covers about 70% of scenarios; the remaining 30% needs to be written proactively: preference corrections, environment details, work habits. After a week or two of tuning, you basically never have to say it twice.

Benefits of saving work reviews into memory

As mentioned, the Feishu daily work review is automatically saved into OpenViking, which tags each day’s work. Over a few weeks, you accumulate a string of “what I did today” records.

Benefits:

• No need to recall for weekly reports — on Friday, have it pull and summarize the reviews from these days; everything done each day is clear, no need to dig through chat history.
• Issues are traceable — “how was that alert on last Wednesday finally handled” — the review likely recorded the conclusion, and a session_search brings it right up.
• Context never breaks — for problems I left half-debugged, it still remembers the context the next day, no need to re-describe.

In short, it automatically sediments the fragmented information of daily ops into a searchable knowledge base. Short-term, it saves a few keystrokes; long-term, no investigation record is ever lost.

Pitfalls I’ve Hit

1. The model can’t be chosen just for speed. deepseek-v4-flash is fine for daily use, but for complex reasoning (multi-step code refactoring, long-chain call analysis) it’s clearly worse than Claude. Now I switch by scenario — flash for daily alert checks and message replies, and temporarily switch to something stronger for complex tasks. There’s no perfect model, only the right one.

2. Scripting is more stable than an agent. Some scheduled tasks initially had the agent fetch things live, which was unstable — the model’s output format varied, APIs timed out. Later I changed to writing Python scripts with no_agent=True; data collection goes through scripts, and the agent only handles formatting. Rock solid.

Summary

My biggest takeaway from half a year of using Hermes: whether an AI assistant is good doesn’t depend on how strong the model is, but on how well it’s glued to you. No matter how powerful the model, if it can’t operate your computer, can’t see your databases, can’t reply to messages on Feishu for you, then it’s just a smarter chat box.

Hermes, for me, is an “AI that can take action.” I wake up in the morning and open Telegram — the morning brief is already there. If I have a problem, I just say it, and it handles most of it on its own.

But it’s not omnipotent either. Long reasoning chains that need strong inference are still not its strong suit, and too many tool calls can easily go wrong. But as a daily assistant, it has already far exceeded my initial expectations.

Follow my blog www.bboy.app

Have Fun