arielshemesh1999@gmail.com · Israel
← All articles Agents

Hermes Agent

Nous Research’s open-source agent that lives on your server, remembers everything across sessions, and gets more capable the longer you run it — because it writes its own skills as it works.

2026-05 · 7 min read

What it is

Hermes Agent is an open-source autonomous agent built by Nous Research (MIT license, 170k stars, current version v0.14.0 released 2026-05-16). The pitch in one sentence, taken from their own site: “an autonomous agent that lives on your server, remembers what it learns, and gets more capable the longer it runs.”

The difference from a Claude/ChatGPT wrapper is the “remembers” and the “more capable.” Hermes is not stateless. Every session gets stored in a full-text-indexed local database (SQLite FTS5), summarized by the LLM, and folded back into the agent’s working context the next time the same topic comes up. And every time it solves a non-trivial task, it can spin that solution out into a reusable skill — a small markdown file with embedded code — so it never has to rediscover the same trick.

Architecture

            +---------------------------------------+
            |           Hermes Gateway (cron,        |
            |           subagents, scheduling)       |
            +----+----------+---------+--------------+
                 |          |         |
                 v          v         v
            Telegram     Discord    Slack     ... WhatsApp / Signal / Email / CLI
                 |          |         |
                 +----------+---------+
                            |
                            v
              +-------------+--------------+
              |     Hermes core agent      |
              |  (model-agnostic, 40+ tools)|
              +------+------+--------+-----+
                     |      |        |
            +--------v-+ +--v----+ +-v----------+
            |  Memory  | | Honcho| |  Skills    |
            |  FTS5    | | user  | | (.md +     |
            |  search  | | model | |  code)     |
            +----------+ +-------+ +------------+

The four moving parts:

  • Gateway — one long-running process that fans out to all messaging channels (Telegram, Discord, Slack, WhatsApp, Signal, Email, CLI) and runs the built-in cron scheduler for unattended tasks.
  • Core agent — model-agnostic. Plug in OpenRouter, OpenAI, Anthropic, HuggingFace, or a local model. Ships with 40+ tools across multiple terminal backends (containerized execution across five options).
  • Memory layer — SQLite with FTS5 for fast session search, plus LLM-driven summarization for cross-session recall. Built on top of Honcho’s dialectic framework for user modelling, so the agent keeps a deepening profile of who you are and how you work.
  • Skills — reusable capabilities, written either by you or by the agent itself after completing a task. Compatible with the agentskills.io open standard.

Install

One command on Linux, macOS, WSL2 or Termux:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

Windows (PowerShell, early beta):

iex (irm https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.ps1)

The installer drops a hermes binary on your PATH, creates ~/.hermes/ for state, and walks you through the setup wizard. First-run commands:

hermes setup        # full configuration wizard (model + channels)
hermes model        # pick / switch LLM provider
hermes gateway      # start the messaging gateway
hermes              # drop into the interactive terminal UI

Primary language is Python (88.9% of the repo), so you need Python 3.10+ available. Docker is optional but recommended for the sandboxed tool backends.

Configuration

Config lives at ~/.hermes/config.yaml. A realistic config wiring a model, two channels, the memory DB and a cron job:

model:
  provider: openrouter
  name: anthropic/claude-opus-4-7
  fallback: openai/gpt-5

memory:
  backend: sqlite-fts5
  path: ~/.hermes/memory.db
  honcho:
    enabled: true
    user_id: ariel

channels:
  telegram:
    enabled: true
    bot_token: ${TELEGRAM_BOT_TOKEN}
  discord:
    enabled: true
    bot_token: ${DISCORD_BOT_TOKEN}
  cli:
    enabled: true

tools:
  enabled:
    - web_search
    - browser
    - shell_sandbox
    - python_exec
    - filesystem
    - github

cron:
  - name: morning_brief
    schedule: "0 7 * * *"
    prompt: "Summarize my unread Slack and Gmail; flag anything urgent."

Skill format

A skill is just a markdown file in ~/.hermes/skills/. The agent can read, write, and run them. Example skill the agent might auto-generate after solving a deploy task once:

---
name: deploy-vercel-project
description: Build and deploy a Vercel project from the current git repo.
triggers: ["deploy to vercel", "ship to vercel", "vercel deploy"]
---

## Steps
1. Verify `vercel` CLI is installed (`vercel --version`).
2. Confirm the repo has `vercel.json` or a framework preset.
3. Run `vercel pull --yes --environment=production`.
4. Run `vercel build --prod`.
5. Run `vercel deploy --prebuilt --prod` and capture the URL.
6. Post the URL back to the user.

## Notes
- If the build fails on a missing env var, list which one and stop.
- Never deploy from a dirty working tree without explicit confirmation.

Usage examples

1) Interactive CLI with multiline edit + slash commands.

$ hermes
hermes > /model
  current: anthropic/claude-opus-4-7
hermes > summarize the last 3 sessions about the
         landing-page-tzahi project
· recalling 3 sessions (FTS5: tzahi, landing, leads)
· ...

2) Telegram — ask for a scheduled brief.

You:   every weekday at 7am, send me a one-paragraph
       brief on what shipped on my GitHub yesterday
Hermes: scheduled. job id #cron_3.
        next run: tomorrow 07:00 (Asia/Jerusalem).
        saving as skill `github-daily-brief`.

3) Parallel subagent delegation.

$ hermes "research the top 5 open-source local
   agent frameworks and rank by stars, license, and
   memory architecture"
· spawning 5 subagents in parallel...
· agent[1] -> openclaw      (375k, MIT, local FTS)
· agent[2] -> hermes-agent  (170k, MIT, FTS5+Honcho)
· agent[3] -> OpenManus     (901,  UNLICENSE, vector)
· ...
· merging results, writing report.md

What’s new / version

v0.14.0 (2026-05-16) is the current release. Recent highlights:

  • Honcho integration for dialectic user modelling on top of the FTS5 memory store.
  • Skills self-improve during use — the agent edits its own skill files when it finds a better way.
  • 40+ tools across five containerized terminal backends (pick the sandbox that matches your security posture).
  • Real terminal UI with multiline editing, slash-command autocomplete, and persistent history.
  • Scheduled automations via built-in cron, no external scheduler.

Why it matters / where I use it

Most agent frameworks pretend memory is solved — usually with a vector DB they paper over the fact that retrieval is fuzzy and forgetful. Hermes commits to FTS5 + LLM summarization + a real user model (Honcho), which is much closer to how humans actually remember conversations: by exact phrases and by gist. The fact that skills get written automatically after a successful run means the agent’s capability surface compounds — week 4 hermes is materially better than day 1 hermes, on your projects specifically.

I treat Hermes as the “always-on server brother” to OpenClaw’s “chat everywhere” story: same MIT openness, different deployment shape. It’s also a strong reference for how I structure the SKILL_REGISTRY layer in the Bot-UI Provider Hub.

Source

GitHub: github.com/NousResearch/hermes-agent · Docs: hermes-agent.nousresearch.com · License: MIT.

AgentsMemoryOpen SourceSelf-improving