I've Been Using Hermes Agent for a Month — Is This "Horse" Really Getting Smarter?

Abstract: Hermes Agent is an open-source self-evolving AI agent developed by Nous Research, launched in February 2026 and accumulating over 48,000 GitHub stars within two months. Unlike typical chatbots, its core value proposition is "persistent memory + automatic skill accumulation" — the longer you use it, the better it understands you. This article provides a one-month deep-dive experience review, covering its three-layer memory system, skill self-evolution loop, multi-platform gateway, practical use cases, and pitfalls encountered along the way.

Regular AI has goldfish memory; Hermes is like a cat that actually remembers you.

Why Hermes? Not Just Another Chatbot

The AI agent赛道 in 2026 has become incredibly crowded. From AutoGPT to OpenClaw to various Code Agents, new players enter the market every month. But most agents share a common fatal flaw: goldfish memory. Each conversation is independent; once the context window closes, previous interactions disappear. You teach it something today, and tomorrow it's forgotten.

Hermes Agent attempts to solve this fundamentally. Instead of "another agent that can run tools," it takes memory, reflection,沉淀, and reuse seriously as long-term collaboration capabilities. The name comes from the Greek god Hermes, and the community has given it an approachable nickname — "爱马仕" (Hermès).

There are only two core selling points: persistent memory and automatic skill accumulation. The longer you use it, the better it understands you, and the more efficient repetitive task execution becomes. Open-source and free (MIT license), you can deploy, modify, and even use it commercially without restrictions.

文章配图

The Three-Layer Memory System: Not Just Remembering, But Recalling

Hermes's memory isn't simply "storing conversations" — it's structured in three layers:

Layer 1: Working Memory

This is the current conversation's context, identical to a regular ChatBot. It disappears when the session ends, but triggers extraction before closing.

Layer 2: Long-term Memory

All historical conversations are stored using SQLite database with full-text search capability. When a new conversation starts, Hermes automatically retrieves relevant content from long-term memory and loads it into working memory. You don't need to re-explain "my project uses Vue3 with TypeScript" — it automatically reads from previous memory files.

Layer 3: Reflective Memory

This is the most unique layer. Hermes periodically reflects on historical conversations, extracting patterns, preferences, and experiential lessons to form higher-level abstractions. For example, if you consistently ask it to focus on performance over style in code reviews across three consecutive sessions, it records in reflective memory that "this user prefers performance optimization" and defaults to that direction in future work.

How the Layers Work Together: A Real-World Walkthrough

Let me walk you through a concrete scenario that demonstrates all three layers in action. I was working on a KaiheAiBox content pipeline project over multiple sessions:

Session 1 (Monday): I told Hermes, "My project uses Python 3.11, the API key is stored in environment variables, and I prefer type hints in all code." This went into working memory. At session end, Hermes extracted key facts into long-term memory, creating a file like:

# memory/2026-03-15.md
- User project: content pipeline for KaiheAiBox
- Tech stack: Python 3.11, FastAPI, SQLAlchemy
- Preferences: type hints required, PEP 8 compliance
- API key location: env vars, never hardcoded

Session 2 (Wednesday): I started a new session asking Hermes to write a data migration script. Without any re-explanation, it automatically retrieved the long-term memory, knew to use Python 3.11 syntax, included type hints, and accessed env vars properly. The retrieval query looked something like:

# Hermes internally performs FTS5 search on memory files
search_query = "Python project preferences coding style"
# Returns: memory/2026-03-15.md with relevance score 0.87

Session 3 (Friday): After three sessions where I consistently corrected Hermes about preferring async/await over threading, the reflective memory kicked in. It generated an abstraction:

# memory/reflective.md
## Coding Preferences
- Strong preference for async/await patterns over threading
- Always use asyncio for I/O-bound operations
- Prefer explicit type hints even for simple functions
- Performance optimization takes priority over code style aesthetics

From that point on, every new session defaulted to async patterns without me mentioning it. That's the reflective layer doing its job — distilling behavioral patterns from repeated interactions.

Memory File Structure

One of Hermes's most pragmatic design choices is making all memory files human-readable and editable. The file structure looks like this:

~/.hermes/
├── memory/
│   ├── 2026-03-15.md    # Daily memory files
│   ├── 2026-03-16.md
│   └── reflective.md    # Reflective abstractions
├── skills/              # Auto-generated skill files
└── config.yaml          # Agent configuration

You can directly edit any of these files with a text editor. I've done this multiple times — for example, when Hermes incorrectly recorded that I prefer JavaScript for backend work (I don't), I simply opened the reflective memory file and changed it. The next session immediately reflected the correction.

Memory Retrieval Under the Hood

Hermes uses SQLite's FTS5 (Full-Text Search) for memory retrieval. When you start a new conversation, it:

Extracts keywords from your first message
Searches across all memory files using FTS5
Ranks results by relevance and recency
Injects the top-K results into the system prompt as context

The retrieval quality depends heavily on the underlying model's ability to extract meaningful keywords. With DeepSeek-V3, I found retrieval accuracy around 85%; with Claude Sonnet, it improved to roughly 92%. This is one reason model selection matters.

In practice: Memory retrieval is sometimes imprecise, especially when you're simultaneously managing multiple projects — it occasionally confuses contexts. For instance, when I was working on both a Python backend and a Vue.js frontend simultaneously, Hermes sometimes mixed up which project's conventions to follow. The solution was to explicitly mark project boundaries in memory files:

# memory/2026-03-20.md
## Project: KaiheAiBox Backend (Python)
- Using FastAPI with async routes
- Database: PostgreSQL via SQLAlchemy

## Project: KaiheAiBox Dashboard (Vue.js)
- Using Composition API with TypeScript
- State management: Pinia

With this explicit separation, cross-project confusion dropped significantly. The memory files themselves are visible and editable, so you can manually correct mistakes — a very pragmatic design choice.

Skill Self-Evolution: Use Once, Remember Forever

This is Hermes's most distinctive design. When a workflow has been validated (calling tools 5+ times), Hermes automatically creates the entire solution process as a Markdown-formatted Skill file. Next time you encounter a similar requirement, it directly loads the skill and skips the trial-and-error phase.

A concrete example: setting up a GitHub Actions CI pipeline. The first time I asked Hermes to do this, it experienced the entire process — searching documentation, writing YAML, debugging permission errors, and finally getting it running — taking about 15 minutes. Upon completion, it automatically abstracted the entire process into a skill file named github-actions-ci-setup.

The second time I had a similar requirement, it loaded this skill directly and completed the task in 3 minutes. Community users have reported approximately 40% efficiency improvements on repetitive development tasks, and based on my own experience, this figure is credible for high-repetition scenarios.

Even more interesting: if subsequent usage discovers better approaches, Hermes updates the skill documentation. This isn't a static knowledge base — it's a self-iterating knowledge system.

Suitable sub-scenarios: - Code review templates with fixed formats - Weekly data processing scripts that run on schedule - Deployment process standardization

Not suitable for: - Completely one-off tasks that never repeat — the skill library grows but is almost never reused, with limited effect

Deep Dive: How Skill Files Are Structured

When Hermes auto-generates a skill, it creates a Markdown file following a standardized structure. Let me show you the actual github-actions-ci-setup skill it created:

# Skill: github-actions-ci-setup
# Generated: 2026-03-10
# Trigger: "set up CI for my repo"
# Usage Count: 4

## Prerequisites
- GitHub repository with admin access
- Node.js 18+ or Python 3.10+

## Steps
1. Check if `.github/workflows/` directory exists; create if not
2. Generate `ci.yml` based on project language:
   - Node.js: npm install → npm test
   - Python: pip install → pytest
3. Configure branch triggers (push to main, PR to main)
4. Test workflow with `act` locally if available
5. Commit and push; verify in GitHub Actions tab

## Common Errors
- **Permission denied**: Add `permissions: contents: write` to workflow
- **npm cache fails**: Use `actions/cache@v3` with correct key
- **Python version mismatch**: Pin version in `setup-python@v4`

## Last Updated
2026-03-22: Added Python poetry support after user request

Notice the "Common Errors" section — this was populated after I encountered and resolved those issues. The skill literally learned from my mistakes. The "Usage Count" tracks how often the skill is invoked, which helps with later triage.

Skill Evolution in Action: A Three-Iteration Story

Here's a more complex example showing how a skill evolves across multiple uses:

Iteration 1 (Week 1): I asked Hermes to deploy a FastAPI app to a VPS. It went through the entire process: SSH setup, Nginx config, systemd service, SSL certificates with Let's Encrypt. The whole process took 25 minutes. Hermes created deploy-fastapi-vps.

Iteration 2 (Week 2): A similar deployment, but this time I needed Docker. Hermes loaded the existing skill, recognized the Docker requirement as a variant, and adapted the process. It added Docker-specific steps while reusing the SSL and Nginx configuration knowledge. Time: 12 minutes. The skill file was updated with a "Variants" section:

## Variants
- **Bare Metal**: Direct deployment via systemd (original)
- **Docker**: Docker Compose with Nginx reverse proxy (added 2026-03-18)

Iteration 3 (Week 3): Deployment to a different VPS provider. Hermes loaded the skill, asked clarifying questions about the provider's firewall rules, and completed the deployment in 8 minutes. The skill now includes multi-provider notes.

This progressive refinement is the real magic. Each iteration makes the next one faster and more reliable. It's not just remembering — it's compounding knowledge.

Creating Skills Manually

You can also create skills manually for workflows you've already mastered. The format is straightforward:

# Skill: content-publishing-pipeline
# Created: 2026-03-20
# Trigger: "publish article" OR "batch publish"

## Context
Automated content publishing pipeline for KaiheAiBox blog.

## Steps
1. Write article content (Chinese + English)
2. Generate cover image via Seedream API
3. Upload images to CDN
4. Replace PLACEHOLDER references in content
5. Publish via API (check for duplicates first)
6. Verify article is live on website
7. Update topic tracking system status

## API Endpoints
- Publish: POST https://agentaibox.com/api/articles
- Upload: POST https://agentaibox.com/api/media/upload
- Query: GET https://agentaibox.com/api/articles

I created this skill manually after running the pipeline manually several times. Once registered, Hermes could execute the entire 7-step pipeline from a single command. What previously took 15 minutes of manual work now completes in about 2.5 minutes.

Skill Library Anti-Patterns

After a month, I've identified several anti-patterns to avoid:

Over-granular skills: Creating a separate skill for "deploy to AWS us-east-1" vs "deploy to AWS us-west-2" — combine them into one parameterized skill instead.
Stale skills: Skills for tools you no longer use just add noise. Archive them.
Missing trigger keywords: If your skill only triggers on "set up database" but you usually say "initialize DB," it won't be loaded. Add synonyms.
No error documentation: Skills without "Common Errors" sections mean Hermes re-derives solutions each time, defeating the purpose.

Multi-Platform Gateway: Telegram, Discord, Terminal, One Agent Manages Everything

Hermes supports six execution environments: Terminal CLI, Telegram, Discord, Web UI, Slack, and API. Each platform can independently configure tool permissions.

My most used combination is Terminal CLI for writing code + Telegram for receiving scheduled task notifications. In the terminal, hermes command starts a session; in Telegram, @HermesBot receives results anytime. Both entry points share the same memory system and skill library, with seamless switching.

Security design is solid: Dangerous operations trigger manual approval, and it includes container isolation and context scanning. This is more reliable than relying on the large model's own judgment capability to avoid risks — framework-level security protection doesn't depend on the model's "conscience."

Platform-by-Platform Configuration Guide

Terminal CLI (Primary Development Interface)

The terminal is where you'll spend most of your time for serious work. Configuration is straightforward:

# Install Hermes CLI
pip install hermes-agent

# Initialize with your API key
hermes init --model deepseek-v3 --api-key $DEEPSEEK_API_KEY

# Start a session
hermes chat

The CLI supports several useful flags: - --model: Override the default model for this session - --memory-limit: Control how much context is loaded from long-term memory - --skill-dir: Point to a custom skill directory - --no-auto-skill: Disable automatic skill loading (useful for debugging)

My typical workflow is running hermes chat in a terminal pane alongside my editor. The CLI maintains conversation history within a session, and you can use /memory to inspect what's been loaded, /skills to see active skills, and /reflect to manually trigger memory reflection.

Telegram Bot (Notifications & Quick Commands)

Telegram is ideal for receiving notifications and issuing quick commands on the go. Setting it up takes about 10 minutes:

Create a Bot: Message @BotFather on Telegram, send /newbot, and follow the prompts. Save the bot token.
Configure Hermes:

# ~/.hermes/config.yaml
gateways:
  telegram:
    enabled: true
    token: "your-bot-token-here"
    mode: webhook  # or polling for local testing
    webhook_url: "https://your-domain.com/webhook"
    allowed_users:
      - your_telegram_id  # Restrict access to yourself

Security: The allowed_users field is critical — without it, anyone who finds your bot can issue commands. Get your Telegram ID by messaging @userinfobot.
Start the gateway:

hermes gateway start telegram

I primarily use Telegram for three things: receiving cronjob results (e.g., daily PR summaries), quick lookups ("what's the status of deployment?"), and getting approval requests for dangerous operations when I'm away from my computer.

Discord Bot (Team Collaboration)

Discord setup follows a similar pattern but adds server-level permissions:

Create a Discord Application at discord.com/developers/applications
Generate a bot token and invite it to your server with appropriate permissions
Configure:

gateways:
  discord:
    enabled: true
    token: "your-discord-bot-token"
    allowed_channels:
      - "#hermes-commands"
      - "#deployment-logs"
    admin_roles:
      - "Engineering"

The allowed_channels restriction prevents the bot from responding in every channel, which keeps things organized. The admin_roles field controls who can approve dangerous operations.

Web UI (Casual Conversations & Visualization)

Hermes includes a built-in web interface for browser-based interaction:

hermes web --port 8080 --auth

The --auth flag enables basic authentication. The Web UI is useful when you want to have a conversation without opening a terminal, or when you want to visually browse your memory files and skill library. It's not as powerful as the CLI for complex operations, but it's approachable for casual use.

Cross-Platform Memory Synchronization

All platforms share the same underlying memory and skill storage. When I start a conversation on Telegram asking Hermes to check server logs, and later continue in the terminal asking for analysis, it remembers the Telegram conversation because it's all in the same long-term memory pool. This seamless switching is one of Hermes's most underrated features.

The synchronization is near-instant for file-based storage. If you're running Hermes on multiple machines, you can sync the ~/.hermes/ directory via rsync, Syncthing, or a cloud storage mount. The community has also built an experimental Git-based sync plugin that commits memory changes to a private repository.

24-Hour Scheduled Tasks: A True 7×24 Assistant

Hermes has a built-in cronjob tool for setting scheduled tasks. For example, checking GitHub repository PR status every morning at 8 AM, generating weekly report drafts every Monday, or checking server logs for anomalies every hour.

This naturally aligns with KaiheAiBox A1's 7×24-hour running philosophy — a small device that doesn't shut down running Hermes Agent with scheduled tasks always online. While you sleep, it's working.

Cronjob Configuration Examples

Hermes's cronjob system uses a familiar cron-like syntax with natural language shortcuts. Here are the actual scheduled tasks I have running on my KaiheAiBox A1:

# ~/.hermes/cronjobs.yaml
jobs:
  - name: "morning-pr-summary"
    schedule: "0 8 * * *"          # Every day at 8 AM
    task: "Check all my GitHub repos for new PRs and summarize them"
    notify: telegram

  - name: "weekly-report-draft"
    schedule: "0 18 * * 5"          # Every Friday at 6 PM
    task: "Generate a weekly report draft based on this week's git commits and calendar events"
    notify: telegram
    model: claude-sonnet           # Use stronger model for complex task

  - name: "hourly-log-check"
    schedule: "0 * * * *"           # Every hour
    task: "Check server logs for anomalies, specifically 5xx errors and OOM events"
    notify: telegram
    model: deepseek-chat           # Cheaper model for routine checks

  - name: "content-pipeline-daily"
    schedule: "30 9 * * 1-5"        # Weekdays at 9:30 AM
    task: "Run the content publishing pipeline: check for new articles, generate images, publish"
    skill: "content-publishing-pipeline"
    notify: telegram
    model: claude-sonnet

  - name: "dependency-audit"
    schedule: "0 2 * * 0"           # Every Sunday at 2 AM
    task: "Audit npm and pip dependencies for known vulnerabilities"
    notify: email

Each job supports several key parameters: - model: Override the default model for this specific task (cost optimization) - skill: Pre-load a specific skill before executing - notify: Where to send results (telegram, discord, email, or none) - timeout: Maximum execution time before killing the task

Managing Cronjobs via Chat

You don't have to edit the YAML file manually. Hermes can manage cronjobs through natural language:

Me: "Set up a daily check for new GitHub issues at 9 AM"
Hermes: "Created cronjob 'daily-github-issues' — schedule: 0 9 * * *. 
        Notify via: telegram. Model: deepseek-chat. 
        Say 'confirm' to activate or adjust settings."
Me: "confirm"
Hermes: "Cronjob activated."

You can also list, pause, and delete jobs: - "Show me all scheduled tasks" → Lists all cronjobs with their status - "Pause the log check job" → Disables without deleting - "Delete the weekly report job" → Permanently removes

Running on KaiheAiBox A1: The Always-On Setup

The KaiheAiBox A1 is purpose-built for this kind of workload. Here's how I configured it:

Installation: Installed Hermes Agent directly on the A1's Linux environment via SSH
Auto-start: Configured systemd to start Hermes automatically on boot:

# /etc/systemd/system/hermes.service
[Unit]
Description=Hermes Agent Daemon
After=network.target

[Service]
Type=simple
User=hermes
WorkingDirectory=/home/hermes
ExecStart=/usr/local/bin/hermes daemon --gateway telegram
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Resource monitoring: The A1 typically uses about 200-400MB RAM running Hermes with the Telegram gateway active. CPU usage is minimal between cronjobs, spiking briefly during task execution.
Power consumption: The A1 draws about 5-8 watts — roughly $3-5/year in electricity. Compare that to leaving your main workstation running 24/7.
Reliability: In a month of operation, I've had zero crashes and only two missed cronjobs (both due to my ISP having brief outages). Hermes automatically retries failed tasks with exponential backoff.

The combination of Hermes + KaiheAiBox A1 genuinely delivers on the "AI assistant that never sleeps" promise. I wake up to find PR summaries waiting in my Telegram, weekly reports drafted and ready for review, and monitoring alerts that were handled overnight. It's a small thing, but it compounds.

Pitfall Records: An Imperfect Experience

Pitfall 1: Small Models Perform Poorly

Hermes is model-agnostic — it can use any OpenAI-compatible API. However, if using models below 4B parameters, memory retrieval and skill creation quality significantly degrades. It's recommended to use at least DeepSeek-V3 or Claude Sonnet level models.

Reproduction steps: 1. Configure Hermes with a small model (e.g., Phi-3-mini-3.8B via Ollama) 2. Have a multi-turn conversation about a project 3. End the session and start a new one 4. Ask about the previous conversation's content

What happens: The small model fails to extract meaningful keywords for memory retrieval, returns irrelevant context, and often hallucinates connections. Skill creation is worse — the generated skill files are incomplete, missing error documentation, and sometimes contain fabricated steps.

Solution: - Minimum viable: DeepSeek-Chat (67B) for daily use - Recommended: Claude Sonnet or DeepSeek-V3 for skill creation and reflection - Use model routing (covered in Advanced Configuration) to assign stronger models to critical tasks

Quantitative comparison from my testing:

Model	Memory Retrieval Accuracy	Skill Quality	Cost/Month (est.)
Phi-3-mini (3.8B)	~45%	Poor	Free (local)
DeepSeek-Chat (67B)	~85%	Good	~$8
Claude Sonnet	~92%	Excellent	~$25
GPT-4o	~90%	Very Good	~$35

Pitfall 2: Memory Retrieval Sometimes Imprecise

When simultaneously advancing multiple projects, contexts get confused. You need to manually mark project boundaries in memory files.

Reproduction steps: 1. In session A, work on a Python FastAPI backend project 2. In session B (same day), work on a Vue.js frontend project 3. In session C, ask Hermes to help with the backend — it may suggest Vue.js patterns

Root cause: Hermes's FTS5 search returns results based on keyword relevance, not project context. When both projects share terms like "API" or "deployment," results from both get mixed.

Solutions (ranked by effectiveness): 1. Explicit project tags in memory files (most effective): Prefix each memory entry with [project:backend] or [project:frontend] 2. Separate Hermes instances: Run two instances with separate memory directories for different projects 3. Session initialization: Start each session by explicitly stating which project you're working on 4. Memory cleanup: Regularly archive old project memory that's no longer relevant

Pitfall 3: Gateway Sometimes Times Out Connecting to Telegram

With unstable network, Telegram Bot responses may delay by several minutes. It's recommended to use Webhook mode instead of long polling.

Reproduction steps: 1. Configure Hermes Telegram gateway in polling mode (default) 2. Run on a network with occasional latency spikes (>5s) 3. Send a message to the bot 4. Observe delays of 2-5 minutes before response, or duplicated responses

Root cause: Long polling holds connections open; when the network hiccups, the connection drops and must be re-established, causing a retry cascade.

Solution — switch to Webhook mode:

# In config.yaml
gateways:
  telegram:
    mode: webhook
    webhook_url: "https://your-domain.com/webhook/telegram"
    webhook_port: 8443

You'll need a domain with SSL (Telegram requires HTTPS for webhooks). I use Cloudflare Tunnel for this — free and no need to expose ports:

cloudflared tunnel --url http://localhost:8443

After switching, response latency dropped from 2-5 minutes to under 3 seconds consistently.

Pitfall 4: Windows Installation Requires Special Handling

Many people step into a pitfall at the very first step on Windows. Although Git Bash executes official commands, it prompts that PowerShell must be used. The official installation documentation recommends PowerShell 7+ for the best experience.

Reproduction steps: 1. Open Git Bash on Windows 2. Run the official install command: curl -fsSL https://hermes.dev/install.sh | bash 3. Script fails with: "Error: PowerShell 7+ required. Please run in pwsh." 4. Even in PowerShell 5.1 (Windows default), some commands fail due to missing features

Complete solution:

# Step 1: Install PowerShell 7
winget install Microsoft.PowerShell

# Step 2: Open pwsh (not the default PowerShell)
pwsh

# Step 3: Install Hermes
irm https://hermes.dev/install.ps1 | iex

# Step 4: Verify
hermes --version

Common sub-pitfalls on Windows: - Long path names: If your username has spaces, wrap paths in quotes in config - Line endings: Hermes generates LF files, but some Windows editors convert to CRLF — this can break YAML parsing. Configure your editor to preserve LF - Firewall: Windows Defender may block Hermes's first outbound connection — allow it through - Node.js dependency: Some Hermes plugins require Node.js 18+. Install via winget install OpenJS.NodeJS.LTS

Pitfall 5: Skill Naming Can Cause Conflicts

When Hermes automatically creates skills, it generates names based on task content. If similar tasks use different naming conventions, skills may not be reused effectively. It's recommended to periodically review and consolidate the skill library.

Reproduction steps: 1. Ask Hermes to "set up a database" → Creates skill database-setup 2. Later, ask to "initialize PostgreSQL" → Creates skill postgresql-init instead of loading database-setup 3. Now you have two overlapping skills, and neither is complete

Solutions: 1. Periodic review: Every 2 weeks, run hermes skills list and check for overlaps 2. Manual naming: When creating skills, use explicit, consistent naming conventions 3. Skill aliases: Add trigger synonyms to existing skills:

# Skill: database-setup
# Triggers: "set up database", "initialize database", "create database", "init postgres", "setup postgresql"

Consolidation: Merge overlapping skills manually, keeping the more comprehensive one

Comparison with OpenClaw: Complementary, Not Competitive

Hermes and OpenClaw represent two different approaches: OpenClaw is an "all-in-one gateway," emphasizing platform integration and tool orchestration; Hermes is a "self-evolving agent," emphasizing memory and skill accumulation.

If you need multi-platform content distribution, scheduled task scheduling, and team collaboration, OpenClaw is more suitable. If you need a personal AI assistant that understands you better over time, Hermes is stronger. The two can be combined — OpenClaw handles execution and scheduling, while Hermes handles learning and accumulation.

Detailed Comparison

Dimension	Hermes Agent	OpenClaw
Core Philosophy	Self-evolving, memory-first	Gateway-first, tool orchestration
Memory System	Three-layer (working, long-term, reflective)	Session-based, limited persistence
Skill System	Automatic skill creation from workflows	Manual skill definition
Platform Support	6 platforms (Telegram, Discord, etc.)	Extensive platform gateway
Model Support	Model-agnostic (any OpenAI-compatible)	Flexible model routing
Target User	Individual developers wanting AI "partner"	Teams needing automation pipeline
Setup Complexity	Moderate (memory tuning takes time)	Higher (gateway configuration)
Cost Efficiency	High (self-hosted, model-agnostic)	Moderate (platform fees may apply)
Community Size	48K+ GitHub stars, growing rapidly	Established community, enterprise adoption
Extensibility	Skill-based, self-generating	Plugin-based, manually created
Offline Capability	Full (local memory + local models)	Partial (depends on cloud services)
Data Privacy	All data stays local by default	Depends on gateway configuration

When to Use Which (Or Both)

Choose Hermes when: - You're a solo developer who wants an AI that learns your patterns - Memory persistence across sessions is critical for your workflow - You value self-evolving knowledge over pre-configured pipelines - Privacy matters — you want all data stored locally

Choose OpenClaw when: - You need multi-platform content distribution at scale - Team collaboration with shared configurations is important - You want pre-built integrations with enterprise tools - Scheduled task orchestration across multiple services is your primary need

Use both when: - OpenClaw handles your publishing and distribution pipeline - Hermes serves as your personal coding and thinking assistant - They share data through the file system (Hermes writes, OpenClaw distributes)

I actually run both: OpenClaw powers the KaiheAiBox content pipeline (writing articles, generating images, publishing to the website), while Hermes handles my personal development workflow (code reviews, debugging, documentation). They coexist peacefully — OpenClaw on the production pipeline, Hermes on my development machine and KaiheAiBox A1.

Best Practices After One Month

Practice 1: Regular Memory Cleanup

Every two weeks, manually review memory files to remove outdated information and correct errors. This keeps retrieval accuracy high.

Practice 2: Skill Library Triage

Every month, review the skill library, merge similar skills, and archive rarely-used ones. This prevents the skill library from becoming bloated.

Practice 3: Choose the Right Model

For daily conversations, use cheaper models like DeepSeek-Chat. For complex reasoning or skill creation, switch to stronger models. This balances cost and capability.

Practice 4: Combine with KaiheAiBox

Running Hermes Agent on KaiheAiBox A1 achieves true 7×24-hour operation. The device's low power consumption makes it ideal for always-on AI assistants. Scheduled tasks run reliably without requiring your main computer to be powered on.

Practice 5: Use Model Routing Strategically

Don't use one model for everything. Configure Hermes to route different tasks to appropriate models:

# ~/.hermes/config.yaml
model_routing:
  default: deepseek-chat          # Daily conversations
  skill_creation: claude-sonnet    # Creating new skills
  reflection: claude-sonnet        # Memory reflection
  cronjob_simple: deepseek-chat    # Routine scheduled tasks
  cronjob_complex: claude-sonnet   # Complex scheduled tasks
  code_review: deepseek-v3         # Code-specific tasks

This can cut your monthly API costs by 60-70% while maintaining quality where it matters. My monthly bill dropped from ~$35 to ~$12 after implementing model routing.

Practice 6: Memory File Templates

Create templates for common project types to speed up the onboarding of new projects:

# Template: Python Backend Project
## Tech Stack
- Python 3.x
- Framework: [FastAPI / Django / Flask]
- Database: [PostgreSQL / MySQL / SQLite]

## Coding Preferences
- Type hints required
- Async preferred for I/O operations
- Testing: pytest with fixtures

## Deployment
- Target: [VPS / Docker / Serverless]
- CI: GitHub Actions

When starting a new project, I give Hermes this template and fill in the specifics. It immediately has context without me explaining everything from scratch.

Practice 7: Session Handoff Protocol

When ending a session, I've developed a habit of explicitly summarizing what was accomplished and what's pending:

Me: "Let's wrap up. Summary: We set up the FastAPI project structure, 
     configured the database connection, and wrote the auth module. 
     Pending: rate limiting middleware and deployment config."

This gives Hermes high-quality material for memory extraction, improving what gets stored in long-term memory. Without this explicit summary, Hermes sometimes extracts trivial details and misses important decisions.

Practice 8: Leverage Reflective Memory for Onboarding

If you work with multiple AI tools, use Hermes's reflective memory as a "personality profile" that can be ported. I've exported my reflective memory file and used it to bootstrap new Hermes instances for different machines. It's like transferring your AI's "understanding" of you — your preferences, patterns, and quirks — without retraining from scratch.

Practice 9: Version Control Your Skills

Store your skill files in a Git repository. This gives you: - History of how skills evolved - Ability to rollback if a skill update goes wrong - Easy sharing with team members - Backup in case of data loss

cd ~/.hermes/skills
git init
git add .
git commit -m "Initial skill library"

I push my skills repo to a private GitHub repository. Every time Hermes updates a skill, I review the change before committing. This prevents the "skill drift" problem where auto-updated skills gradually deviate from your actual needs.

The Learning Curve: Worth the Investment

The first two weeks, you might not feel significant difference. But by the third week, when you realize it actually remembers what you taught it before and skills start being automatically reused, that feeling of "it's growing" is quite remarkable.

It's like raising a horse — when you first bring it home, it needs breaking in. But ride it long enough, and it learns your rhythm.

Who Is Hermes For?

Based on a month of use, my judgment is: Hermes is not for people who occasionally ask AI questions. It's for people willing to operate AI as long-term infrastructure.

If you only occasionally use AI to write copy or modify code, Claude Code or Cursor suffices. Hermes's core value lies in two things: persistent memory and skill automatic accumulation.

What About the Future?

The Hermes team has announced plans for: - Desktop App: Hermes Desktop for simpler installation - Team Mode: Shared skill libraries for teams - Plugin System: Extensible plugin architecture

If these features materialize, Hermes could evolve from a personal AI assistant to a team collaboration tool — opening new possibilities for enterprise adoption.

Conclusion: For Those Willing to Invest Long-Term

After a month of use, my conclusion: Hermes is not for people who occasionally ask AI questions. It's for people willing to operate AI as long-term infrastructure.

The first two weeks, you might not feel significant difference. But by the third week, when you discover that what you taught it is truly remembered and the skill library starts automatically reusing — that feeling of "it's really growing" is quite remarkable.

From another perspective, Hermes represents a different philosophy about AI: not just a tool to use, but a partner to cultivate. You invest time in training it, and it grows with you.

This aligns with KaiheAiBox's vision: making AI accessible to everyone, including those willing to build long-term AI partnerships.

KaiheAiBox · Hermes Zone

I've Been Using Hermes Agent for a Month — Is This Horse Really Getting Smarter?