Back to articles

Hermes Agent: the open-source personal AI assistant that actually learns from you

8 min read
aiagentsopen-sourcehermesopenclawpersonal-assistantnous-researchautomation

For a few months now, a quiet but structuring category of tools has been gaining traction in developer and early-adopter circles: self-hosted personal AI assistants. Not chatbots. Not IDE copilots. Persistent agents that run on your own server, actually know you, and can keep working while you sleep.

OpenClaw has done a lot to make that idea concrete and practical. This assistant — which I have been using and configuring for several months — laid the foundation of a paradigm: an agent that lives in a structured workspace, with memory files, a skills system, and access to your tools through Telegram, Discord or WhatsApp.

But limits exist. Legitimate frustrations: Telegram sessions that drift, skills that demand constant manual maintenance, a "you configure everything yourself" philosophy that can become time-consuming. Nothing fatal — but enough to ask the question: are there other approaches that do the same things differently, and better in some areas?

The answer is yes. It's called Hermes Agent, a project launched by Nous Research, and it deserves a serious look.

Who is Nous Research?

Before talking about the tool, the context matters. Nous Research is an AI lab informally founded in 2022 on Discord and Twitter, formalized in 2023 by Jeff Quesnelle, Karan Malhotra, Teknium and Shivani Mitra. Their stance: open source first, decentralization, user-controlled AI.

They are best known for the Hermes, Nomos and Psyche model families — models fine-tuned for reasoning and instruction following, often used as a base for local agents. With Hermes Agent, they offer their take on an autonomous, persistent and open-source personal assistant. The project is moving fast, with sustained activity on GitHub, which makes it a credible thing to keep an eye on.

What Hermes Agent actually is

In one sentence: Hermes Agent is an open-source personal assistant that runs on your own infrastructure, keeps continuity across sessions, and can be used from multiple interfaces such as the terminal or messaging apps.

What sets it apart from the start:

A closed learning loop

Most agents store facts in memory. Hermes goes further: after a complex task succeeds, it automatically creates a skill — a reusable procedure it can call up the next time it faces a similar task. Those skills then improve with each use.

This isn't magic. It's a specific architecture: the agent has a periodic nudge mechanism that prompts it to persist what it just learned. The result: an agent that becomes more useful as it accumulates usage — without you having to write any config file.

A layered memory system

Hermes doesn't just "take notes." It stacks:

  • Persistent memory — long-term notes, facts about the user
  • Cross-session recall — full-text search (FTS5) over conversation history with LLM summaries
  • User modeling — via Honcho, a "dialectical" system that progressively refines its model of who you are
  • Procedural memory — the skills themselves, treated as routines the agent knows how to run without you rewriting them

That's the most interesting ambition: not just remembering what you do, but understanding how you operate.

Model-agnostic, no lock-in

Hermes connects to any OpenAI-compatible endpoint: Nous Portal, OpenRouter (200+ models), OpenAI, Anthropic, GLM, Kimi, or a local model. You change the model with hermes model — no code change. You can run a local Llama one day, GPT-4o the next, without touching your skills or your config.

Multi-platform and extensible via MCP

Hermes also pushes a fairly broad logic for integration and deployment: multiple access channels, multiple execution backends, and MCP support that makes it potentially extensible to many external tools.

In other words, the assistant isn't designed only as a local agent in a terminal. It's designed as a continuity layer that can stay available beyond your laptop.

Comparison with OpenClaw: useful nuance

I'll be upfront: this article isn't a takedown of OpenClaw. It's a tool I use, that I respect, and that has real advantages. But the comparison is useful.

| | Hermes Agent | OpenClaw | |---|---|---| | Paradigm | Self-improving agent, closed learning loop | Workspace-native, manually authored skills | | Memory | FTS5 + LLM summarization + user modeling (Honcho) | Markdown files (MEMORY.md, USER.md) | | Skills | Auto-created from experience + community hub | Manually authored by the user | | Models | Agnostic (200+ via OpenRouter) | Claude-centric, OpenRouter possible | | Tool extensibility | Native integrations + MCP | Manually configured skills and tools | | OpenClaw → Hermes migration | hermes claw migrate (automatic) | — | | User control | More autonomous (more trust required) | More manual, more predictable | | Research loop | Atropos RL + batch trajectories | No |

What Hermes does better:

  • Natively structured and searchable memory (not just Markdown files)
  • Skills that emerge from usage rather than being hand-written
  • Native multi-backend support for deployment
  • No model lock-in
  • Built-in MCP = potentially very broad extensibility

What OpenClaw does differently (and sometimes better):

  • Total control over what the agent can do (human-authored skills = auditable, versionable)
  • Workspace-native: everything is in readable, version-controllable files
  • Deep Claude integration (excellent reasoning model)
  • "You first" philosophy: the agent does not do anything it has not been explicitly configured to do

The real choice:

If you favor an assistant that capitalizes more on usage and history, Hermes can be especially interesting. If you prefer to keep an explicit hand on every behavior of the agent, OpenClaw stays more reassuring on certain workflows.

For critical automations, OpenClaw's explicit control can be an advantage. For a personal assistant that grows over time, Hermes proposes an architecture that clearly deserves to be tested.

Hermes' honest limits

Trusting auto-improvement

The fact that an agent can modify its own procedures is the most ambitious feature — and the one that demands the most trust. Hermes can create and update skills without human intervention. That's powerful. It's also the kind of thing that can drift if you don't verify what's being created.

The project has an approval system for risky commands, but vigilance is still required about what the agent decides to persist as behavior.

Project maturity

Hermes is still a young project. The momentum is good, the docs are improving, but you should keep in mind that some pieces are still stabilizing. Migration from OpenClaw is documented, but it should still be approached with care on real, complex setups.

The learning loop depends on usage

Auto-improvement isn't magic. If you ask simple, repetitive questions, the agent won't create many useful skills. The learning loop is proportional to the complexity and diversity of what you ask of it. For it to work, you have to use it seriously.

What it changes for builders

If you build automations, pipelines, or want an assistant that genuinely handles complex recurring tasks, Hermes opens interesting possibilities:

  • Skills become more portable via agentskills.io, with logic for community sharing and reuse.
  • The agent can delegate or parallelize certain tasks, opening up usage more ambitious than the simple conversational assistant.
  • Built-in MCP = the ability to plug external tools in within a standardized framework.
  • Atropos integration will mostly interest research- or fine-tuning-oriented profiles.

It's not just a conversational assistant. It's an attempt to build real personal-agent infrastructure.

In practice: install in 60 seconds

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
source ~/.bashrc
hermes setup  # interactive wizard: model, platform, OpenClaw migration if needed
hermes gateway start  # Telegram/Discord/Slack/Signal...

If you are coming from OpenClaw:

hermes claw migrate  # imports SOUL.md, memories, skills, API keys
hermes claw migrate --dry-run  # preview first

Works on Linux, macOS, WSL2, and Android via Termux.

Conclusion

Hermes Agent isn't here to replace OpenClaw. It's a different answer to the same question: how do you build an AI assistant that lasts, that grows, and that stays under your control?

The fundamental difference is philosophical. OpenClaw bets on human authoring and predictability. Hermes bets on autonomy and accumulation — an agent that becomes more capable over time without you having to rewrite it.

For serious personal use, the two can coexist. For anyone seriously interested in persistent, open-source personal AI assistants, Hermes clearly deserves a careful test.

Which do you prefer: an agent you configure yourself line by line, or an agent that gradually learns from your usage and adapts over time? That's maybe the real question behind this choice.

References