From Claude Code to Hermes Agent: The Journey to Find an AI Agent That Doesn't 'Forget' Itself Every Morning

On Monday morning, I opened Claude Code, typed claude in the terminal, waited 3 seconds for loading, and then realized: it didn’t remember anything.

I don’t know if this project uses Gin or Fiber. I don’t know where the validation layer is written. I don’t know what the convention for naming files is. The PR I was working on last week - it looks like a blank sheet of paper. So frustrating 💀

Claude Code is really cool - the model is cool, the tool coverage is great, writing code is fast. But every time I open a new session, I have to explain everything from the beginning. “Use Go, Gin framework, gRPC, repository pattern.” It nods and then 3 hours later decides to change GetMenuByID to fetchMenuByID - completely breaking the PascalCase convention of Go. It feels like I have to retrain an intern every morning.

Session Amnesia - A Common Disease of All AI Agents

A few months ago, I used Claude Code quite a lot. The code ran quickly, debugging was stable, but the most persistent problem was session amnesia - every time a new session was opened, the entire context was reset.

I tried OpenClaw because I heard that the tool had wide coverage and supported many providers. It was indeed good - a single command could run Claude, Gemini, OpenAI, and many other tools. However, it was completely stateless. Each session was a separate transaction, with no learning loop and no memory. Once a task was completed, it was done, and nothing was retained.

Then I discovered Claude-Mem - a plugin that helped Claude Code remember context. It was quite stable: it hooked into tool calls, compressed observations, stored them in SQLite, and injected them back into the next session. I even wrote a deep dive post about it. However, its fundamental nature was still that of a plugin - a workaround, not a native architecture.

What I need is an agent with built-in memory, not one that requires additional attachments.

What does a truly useful AI agent need?

Upon careful consideration, I realize that an AI agent that I can trust to handle daily tasks needs three things:

1. Remember context between sessions.
Not just the kind of “oh, I remember your name is Luân” - but rather remembering project structure, tech stack, conventions, decisions. Remembering how a bug was fixed previously to avoid making the same mistake again.

2. Automate repetitive tasks.
Every morning, searching for AI news, writing a blog, and posting it on Zalo - I don’t want to sit and wait for each conversation. I need a cronjob that can run automatically and deliver the results.

3. Learn from mistakes.
Writing code like a beginner, but not continuing to write code like a beginner the next time. A skilled agent is not one that never makes mistakes, but one that can remember its mistakes and adjust accordingly.

Most current agents can only do the first one at a basic level. Codex, Cursor, Copilot - are all editor-centric, tied to the IDE, and do not have a lifecycle outside of the editing session.

Discovering Hermes Agent

One weekend evening, I was browsing GitHub and stumbled upon the NousResearch/hermes-agent repository with 204k stars. It’s open source, under the MIT license. I dug into the documentation and immediately came across this line:

“The only agent with a built-in learning loop - it creates skills from experience, improves them during use, nudges itself to persist knowledge, and builds a deepening model of who you are across sessions.”

After reading that sentence, I knew this was what I had been looking for.

204k stars, 36.6k forks, 13K commits, 1,557 contributors - the numbers are impressive. I’m surprised that the Vietnamese AI community rarely mentions Hermes, though. Meanwhile, we’ve been struggling with Claude Code, Copilot, and Cursor.

What’s different about Hermes Agent?

I’ve been using Hermes for about 2 months now, with ~20K requests/month, ~502M input tokens, and ~9.2M output tokens. Here are the key differences I’ve noted:

1. Native Memory, not a plugin

Hermes uses Honcho for user modeling - it not only stores what you say but also builds a model of your behavior over time. It also comes with FTS5 session search and LLM summarization: typing hermes session search "that rate limiting delivery service" allows it to find the old context from 2 months ago.

It’s not the kind of “injecting the entire history into the context” that wastes tokens. Instead, it uses progressive disclosure - similar to L1/L2/L3 cache. It quickly finds the index (50 tokens), timeline (~200 tokens), and only fetches the full details when needed (~1000 tokens). I’ve discussed this pattern in detail in my Claude-Mem article, and Hermes does it in the same way, but built-in straight into the core 🦞

2. Skills - Procedural Memory

This is the feature I like the most. After completing a complex task, Hermes can automatically create a skill. A skill is a unit of knowledge that can be: reused, improved over time, and shared on agentskills.io.

For example, when I first started using Hermes, I asked it to write a blog post in the style of “research → propose outline → write → review → publish Hugo”. The first time it did it a bit clumsily - it forgot to generate a caption for the image and forgot to set the front matter tags. I gave it feedback, and the next time it remembered, no need to remind it.

Later, I exported that workflow into a skill called blog-writer-v2. Now, when I want to write a blog post, I just need to say “run blog-writer-v2 with topic X” and it will automatically research on the web, propose an outline, ask for my approval, and run the entire pipeline. 5-gate review - it writes and reviews it 5 times before publishing. Auto caption. Auto commit Hugo. 🔥

3. Built-in Cron - no external system needed

Hermes has a built-in cron scheduler with natural language scheduling. hermes cron create is all you need.

hermes cron create \
  --name "daily-ai-digest" \
  --schedule "every day at 7:00 AM" \
  --skill "ai-digest" \
  --params '{"topics": ["LLM", "agent", "open-source"]'

The cron job runs, and Hermes searches the web → summarizes → writes a blog post → sends it to Zalo. I don’t need to do anything. At 7:00 AM, I wake up to see a new post on my blog with a notification on Zalo. 100% automated.

4. Multi-platform Gateway - one process, 20+ platforms

CLI, Telegram, Zalo, Discord, Slack, WhatsApp, Signal, Matrix, Email, SMS… all running on the same process. This is useful because:

• Messages on Zalo and Telegram are in the same session - I can ask on Telegram and respond on Zalo, and it still works
• Cron jobs deliver results to Zalo groups, Telegram channels, and email at the same time
• Voice memo transcription is automatic (send audio to Zalo → Hermes transcribes → processes)

5. Delegation - spawn sub-agent independently

Complex tasks that require multiple steps to be processed in parallel? Hermes spawns a sub-agent with an isolated context. One agent researches, one implements, one reviews. Code review PR comes with github-pr-workflow skill + delegate_task - spawn sub-agent to review code instead of doing it sequentially.

6. Model-agnostic - 20+ providers

Nous Portal, OpenRouter, NovitaAI, NVIDIA NIM, Xiaomi MiMo, Kimi, MiniMax, Hugging Face, OpenAI… switch models without needing to reconfigure the agent.

7. 5 sandbox backends

Local, Docker, SSH, Singularity, Modal. Run it anywhere. I deploy it on a $5/month VPS + serverless Modal for heavy tasks.

Web UI - no need for terminal

This June 2026, Hermes introduced Web UI (Desktop) - a native app for macOS, Windows, and Linux. Based on Electron, but runs smoother than expected.

The good thing: it shares the same session with CLI and gateway. Meaning, in the morning, I can chat with Hermes on the terminal to code. At noon, I can open Web UI on my iPad and still see the conversation from the morning. Streaming tool output - see what the agent is doing in real-time. Preview pane for image files, markdown, and code diff.

The file browser is integrated - no need to type ls and cd anymore if you just want to take a look at the project structure. Voice I/O is also available, but I haven’t used it much.

Before, I lived in the terminal, but I have to admit: having Web UI for simple tasks (reading news, checking cron status, viewing logs) is still more convenient. Saves me from having to remember command syntax.

Real usecases - Hermes in daily dev life

1. Blog automation (blog-writer-v2 skill)

As described above. Bottom line: from idea to publication takes 15 minutes instead of 1-2 hours. The skill automatically reviews 5 gates: grammar, technical accuracy, SEO, structure, and final polish. Auto-publishes to Hugo and generates captions.

# Example config for blog-writer-v2 skill (simplified)
name: blog-writer-v2
description: "Write blog posts for blog.luandnh.com, publish to Hugo"
steps:
  - research topic using web_search
  - propose outline → ask user for approval
  - write full post with front matter
  - review: 5-gate pipeline
  - generate caption for images
  - hugo commit + push
delivery:
  - zalo: notify after publish
  - telegram: send summary link

2. AI Daily Digest

A cron job runs at 7:00 AM every day:

1. Searches Google, ArXiv, and Hacker News for the latest AI news (LLM, agent, open-source tooling)
2. Compiles the results into a short blog post (500-700 words)
3. Commits the post to the Hugo blog and publishes it
4. Sends a link and summary to personal Zalo and Telegram group
5. Archives the post to ~/brain/daily-digest/

Fully automated. All you need to do is read. If you find an interesting post, you can ask Hermes to “write a deep dive for this paper,” and it will research further.

3. Personal DMS (Digital Memory System)

Occasionally, you have ideas, links, or emotions that you want to jot down. Previously, you would write them in the Notes app, but never revisit them. Now, you can send them to Hermes via Zalo: “save this to brain.” Hermes automatically classifies them:

• ~/brain/Life/ - personal stories, emotions, reflections
• ~/brain/Work/ - tech decisions, architecture notes, meeting recaps
• ~/brain/Study/ - papers read, course notes, key learnings
• ~/brain/Research/ - AI ideas, experiments, findings
• ~/brain/Misc/ - everything else

Automatically tags and timestamps entries. You can search using FTS5. You can ask Hermes to “search in brain for the Kafka vs RabbitMQ note from last month” - and it will find it in 2 seconds.

4. Multi-platform messaging

You primarily use Zalo (VNmese dev community), but Hermes also supports Telegram, Pushover, and Web UI. Zalo DM and group chats are supported. If you forget to check Telegram, Hermes will send a notification via Zalo. Same session, no need to repeat.

5. Memory & Context

After 2 months, Hermes knows:

• Your tech stack: Go, Gin, gRPC, PostgreSQL, Redis, Docker
• Your blog config: Hugo theme, domain, deploy workflow
• Your meeting schedule: team standup at 9:30 AM, 1-2-1 on Thursday
• Your home address, coffee preferences, and regular working hours

No need to repeat yourself. Every time you set up a new agent, this is the most tedious part - explaining your life again. With Hermes, you only need to do it once, and it will remember.

6. Skills ecosystem

Currently, you have ~20 skills, not just blog-writer-v2:

• github-pr-workflow - clone PR, review code, comment, auto-fix minor issues, request changes for major issues
• deploy-check - pre-deploy checklist: tests passed? migration safe? rollback plan?
• daily-triage - morning check: important emails? PRs to review? issues to respond to?
• code-review-go - specialized review skill for Go projects, checks convention, error handling, context propagation

Each skill improves on its own. If a skill encounters a pitfall (makes a mistake or misses a step), Hermes can patch the skill itself. No need for your intervention.

7. Code review & PR

You use the github-pr-workflow skill combined with delegate_task. When a new PR is created, a sub-agent is spawned:

1. Clones the code to a private sandbox
2. Runs go vet and golangci-lint
3. Reviews the diff and comments on each issue
4. Fixes minor issues directly and requests changes for major issues
5. Updates the PR status

The sub-agent is isolated and doesn’t affect the main session. Once the PR is complete, it’s cleaned up.

Practical Setup - $10/month for 13 models

No kidding, not an advertisement. I use OpenCode GO ($10/month) for Hermes, accessing 13 models. Simple configuration:

# Provider setup
hermes config set provider opencode-go
hermes config set opencode_go.api_key "sk-go-xxx"

# Choose default model
hermes config set model opencode-go/deepseek-v4-flash

My model strategy:

DeepSeek V4 Flash is my favorite for light tasks - cheap and fast. I spend ~$10/month, comfortably using ~500M input tokens. GLM-5.2 is for important tasks, using more tokens but providing high quality.

I have explained this in detail in the OpenCode GO models guide. Those who have read it know I’m not just advertising randomly 😬

Skill system workflow:

# Install skill from agentskills.io
hermes skill install blog-writer-v2

# Load skill into current session
hermes skill load blog-writer-v2

# Use skill
/blog-writer-v2 topic="Từ Claude Code đến Hermes Agent"

# Check skill status
hermes skill list
hermes skill inspect blog-writer-v2 --verbose

# Schedule with skill
hermes cron create \
  --name "weekly-review" \
  --schedule "every Sunday at 10:00 PM" \
  --skill "code-review-go" \
  --params '{"repo": "my-project", "days": 7}'

3 Lessons After 2 Months of Living with Hermes

1. AI Agents Don’t Need to be Perfect - They Need to be CONSISTENT

The first day I used Hermes, it also coded poorly in many places. It forgot conventions and wrote incorrect patterns. But because it has memory, it corrected itself the next time. Each time I provided feedback, its skills improved. There are agents that do things correctly from the start but then forget later - they’re useless.

Consistency beats perfection. Always.

2. Memory + Skills > Model Power

GLM-5.2 with a blank context loses to DeepSeek V4 Flash with skills and memory. A powerful model without old context and reusable skills has to think from zero every time. Having skills and memory, a weaker model can produce more stable output.

I’d rather use DeepSeek V4 Flash with Hermes than Claude 4 Sonnet with a bare terminal.

3. Automation Requires Trust, Trust Comes from Consistency

Initially, did I trust Hermes to run cron auto-publishing my blog? No. I checked each step. But after ~50 times it ran correctly without errors, and even reported errors when they occurred, I started to trust it. Now AI Daily Digest has been running for 3 weeks without me needing to lift a finger.

Trust doesn’t come from AI claiming “I’m trustworthy”. Trust comes from it doing things correctly so many times that you stop checking.

Cons? There are a few

No tool is perfect:

• Initial learning curve: The Skill system takes time to understand. It took me ~1 week to get used to writing skills, debugging failed skills.
• Gateway setup is a bit complicated: Zalo gateway setup requires a few steps to configure tokens, webhooks. Not difficult but requires careful reading of the documentation.
• Memory can be too conservative: Sometimes it doesn’t dare to remember things that it should. Need to manually remind it with /learn.
• Web UI is still immature: As of 06/2026, there are still small bugs. It’s usable but not as smooth as the terminal.

But overall, the trade-off is still worth it.

In summary

Hermes Agent is the first agent I’ve used that doesn’t require me to recount my life story every morning. It has memory, self-improving skills, background cron jobs, a multi-platform gateway, and now a Web UI for browser use.

I’m not saying this is the best agent for everyone. But if you’re also tired of opening your agent every morning and it looks at you like a stranger - try Hermes.

GitHub: NousResearch/hermes-agent
Docs: hermes-agent.nousresearch.com/docs
Install: curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

Which agent are you using? Claude Code? Codex? Or still relying on manual work? Share your experience in the comments with 🦞🔥

This article is a personal experience. I have no affiliation with Hermes or Nous Research, and I was not paid to write this article. I pay $10/month for OpenCode GO out of my own pocket, and my code runs on my $5 VPS. If you find this helpful, please share; if you find any errors, please comment so I can correct them.