Hermes Agent: Setup, Local Models, and How It Compares to OpenClaw

OpenClaw defined what a self-hosted, persistent AI agent looks like when it ran the table in January and February. But the agent space moves fast, and in the three months since, a quieter project from Nous Research has been steadily eating into that mindshare: Hermes Agent. Released in February 2026, it hit 95,600 GitHub stars in seven weeks — faster than LangChain and AutoGen combined — and it has a few design decisions that make it meaningfully different from OpenClaw, particularly for anyone who wants to run agents on local models.

This post is a practical setup guide for Hermes, a fair-minded comparison against OpenClaw, an honest take on running it against local models, and a survey of the other agent frameworks worth knowing about in 2026.

What Hermes Agent Actually Is

Hermes is an open-source, self-hosted AI agent runtime built by Nous Research, the same team behind the Hermes line of open-weight models. It’s distributed under MIT, runs on Linux, macOS, and WSL2, and installs from a single curl command. The pitch is the same general shape as OpenClaw — persistent memory, automated skill creation, multi-channel reach — but the engineering DNA is different.

A few things stand out about Hermes specifically:

• It self-improves. The agent writes its own skills as needed. If you ask it to do something it doesn’t know how to do, it attempts to build a new skill, tests it, and adds it to its permanent toolkit. This is implemented at the framework level, not as a clever prompt.
• Memory is first-class. Hermes ships with a structured persistent memory store from day one — episodic memory (what happened), semantic memory (facts about you and your environment), and procedural memory (learned skills). Unlike retrofitted RAG, the memory model is part of the agent loop.
• It’s model-agnostic from the start. Hermes was designed to run against local models as the default case. The Nous team has obvious incentives here, but the practical result is that local-model integration in Hermes is noticeably more polished than in OpenClaw.
• 70+ built-in skills. Out of the box, Hermes handles email, calendar, Telegram, Discord, Slack, GitHub, shell access, web browsing, file manipulation, and so on. The skill catalog isn’t as deep as OpenClaw’s 700+, but the curation is tighter.

The naming is intentional — Hermes the Greek messenger god, but also a callback to Nous Research’s Hermes model family. The agent and the models are designed to work together, though neither requires the other.

Architecture in One Diagram

┌─────────────────────────────────────────────────┐
│                  Hermes Agent                    │
│                                                  │
│  ┌────────────┐    ┌───────────────────────┐    │
│  │  Channels  │    │     Agent Loop         │    │
│  │ (Telegram, │◄───┤  ┌─────────────────┐   │    │
│  │  Discord,  │    │  │ Planner         │   │    │
│  │  Email,    │    │  │ Reasoner        │   │    │
│  │  Web UI)   │    │  │ Skill Executor  │   │    │
│  └────────────┘    │  └─────────────────┘   │    │
│                    └──────────┬─────────────┘    │
│                               │                  │
│  ┌──────────────────┐  ┌──────▼──────────┐      │
│  │  Skill Library   │  │  Memory Store    │      │
│  │  ├ Built-in (70+)│  │  ├ Episodic      │      │
│  │  └ Self-authored │  │  ├ Semantic      │      │
│  └──────────────────┘  │  └ Procedural    │      │
│                        └──────────────────┘      │
│                                                  │
└─────────────────────────────────────────────────┘
                       │
            ┌──────────┴───────────┐
            ▼                      ▼
       Model Backend          External APIs
       (Ollama, vLLM,         (Email, GitHub,
        Anthropic, OpenAI)     Calendar, etc.)

The structural difference from OpenClaw is the skill executor loop. In OpenClaw, the model decides which skill to call and the gateway executes it; the skill set is essentially static (you add new ones by installing them from ClawHub). In Hermes, the executor can call into a skill-authoring sub-agent that writes new skills on the fly, validates them in a sandbox, and registers them for future use.

Whether you find this exciting or alarming depends on your threat model. We’ll get to that.

Head-to-Head: Hermes vs OpenClaw

The honest summary:

OpenClaw is broader. More channels, more skills, more integrations, more total deployments. If your use case is “I want an agent that talks to me on WhatsApp and manages a sprawling collection of services,” OpenClaw still has the edge purely on ecosystem.

Hermes is tighter. Better memory model, cleaner code, better local-model story, no security incidents to date, and the self-authored skills mechanism is genuinely novel. If your use case is “I want a self-hosted agent that I control end-to-end and that gets smarter over time,” Hermes is the more thoughtful piece of engineering.

Neither is obviously the right answer for everyone. They’re tools with different design centers.

How Hermes Fares with Local Models

This is the most important question to answer up front, because it’s where the marketing and the reality diverge most.

The good news

Hermes was designed for local-first operation. The provider abstraction is genuinely model-agnostic — switching from cloud Claude to local Ollama is a single command, and the agent loop doesn’t depend on cloud-only features like server-side tool use. You can run the entire stack on a single machine with no outbound API calls.

The Nous team has done specific tuning work for their own Hermes model family. The hermes-4-llama-70b and hermes-4-mistral-24b releases both have explicit support for the tool-calling format the agent expects. If you run those models, the agent loop is noticeably more reliable than with generic local models.

The honest news

Local models can run Hermes Agent. They are not as good at it as Claude Opus 4.7 or GPT-5.

The agent loop involves:

1. Planning — break a task into steps
2. Tool selection — pick the right skill from a long list
3. Argument generation — produce well-formed structured calls
4. Reflection — decide whether the result is acceptable and what to do next

Frontier models do all four reliably. Local models in the 7B–13B range struggle at step 2 once you have more than ~15 skills loaded, and routinely fail step 4 by declaring success when the task isn’t done. Local models in the 30B+ range (Gemma 4 31B, Hermes 4 70B, Qwen 3.6-Coder 32B, Llama 4 Scout) handle the loop reliably, but you need the hardware to run them.

See the companion post on Llama 4 and Gemma 4 self-hosting for hardware planning.

The recommended local stack

For agent use specifically, here’s what actually works after several weeks of testing:

The single most important parameter you can tune is context length. Hermes Agent’s system prompt plus tool schemas runs to roughly 6,000 tokens before you’ve said anything. At a 4K context, the model has no room to actually think. Configure 16K minimum, 32K if you can afford it.

Setup Guide

The full installation is genuinely one command. The interesting part is configuring it sensibly for your hardware and threat model.

Prerequisites

• Linux, macOS, or Windows with WSL2
• Python 3.11+ (the installer will set this up if missing)
• 8GB RAM minimum (for the agent process itself; model serving is separate)
• A model backend — either an API key or a local server

Install

1

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

The installer detects your platform, sets up a Python virtualenv at ~/.hermes, installs the CLI, and creates a ~/.hermes/config directory. On macOS it uses Homebrew for system dependencies; on Linux it uses your distro’s package manager.

Verify:

1
2

hermes --version
hermes status

Pick a model backend

For first-time users, the prompts walk you through this:

1

hermes init

You’ll be asked to pick a backend. The choices are:

1. Nous Research API — managed, requires an API key
2. Anthropic — Claude models, requires an API key
3. OpenAI — GPT models, requires an API key
4. Custom endpoint (self-hosted / vLLM / Ollama / etc.) — anything OpenAI-compatible

For local use, choose option 4. The prompts then ask for:

• Endpoint URL — http://localhost:11434/v1 for Ollama, or wherever your vLLM server lives
• API key — anything non-empty (Ollama ignores it), or your real key for vLLM with auth enabled
• Model name — exactly as your backend serves it (hermes-4:70b, gemma4:31b, etc.)

Local model setup with Ollama

If you don’t already have Ollama running, set it up first:

1
2
3
4
5
6
7
8

ollama pull hermes-4:70b           # Best agent reliability if you have the hardware
# or
ollama pull gemma4:31b             # Best general-purpose option for most homelabs
# or
ollama pull qwen3.6-coder:32b      # Best for coding-heavy agent workloads

# Make Ollama reachable on all interfaces if Hermes will run elsewhere
OLLAMA_HOST=0.0.0.0:11434 ollama serve

Then point Hermes at it:

1
2
3
4
5
6
7
8

hermes model
# Select "Custom endpoint"
# URL: http://localhost:11434/v1
# Key: ollama
# Model: gemma4:31b

hermes config set context_length 32768
hermes config set max_iterations 25

The max_iterations setting caps how many agent loop steps Hermes will run before bailing out. The default is 10, which is too tight for non-trivial tasks but useful as a safety rail. 25 is a reasonable working number.

First conversation

1

hermes chat

You’ll get an interactive prompt. Try a sanity check:

> What can you do?
> Summarize my last 5 emails.
> Build me a skill that pings my Pi-hole and reports the blocked-query rate.

The third prompt is the interesting one — it triggers the skill-authoring loop. Hermes will plan the skill, write it, test it against your environment, and either install it or report why it couldn’t.

Hook up channels

The web UI is the default channel. To add others:

1
2
3
4
5
6
7

hermes channels add telegram
# Follow the prompts to register a bot and provide the token

hermes channels add email
# Configure SMTP/IMAP details

hermes channels add discord

Channels run as part of the main hermes daemon. Start it with:

1
2

hermes daemon start
hermes daemon status

The daemon is what makes Hermes proactive — it can reach out to you on a schedule or in response to triggers, rather than waiting for you to type at it.

Sandbox configuration

By default, Hermes runs skills in a per-skill sandbox with no network access, no filesystem write access outside ~/.hermes/scratch, and no shell access. If a skill needs more, you grant permissions explicitly:

1
2

hermes skills permissions email_summarizer
# Interactive prompt: allow IMAP read? allow filesystem read on ~/Mail? etc.

This is materially more restrictive than OpenClaw’s default posture. It’s also more annoying for casual use. For a homelab agent that has access to your services and data, the trade is worth it.

A reasonable starting config

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# ~/.hermes/config/agent.yaml
model:
  provider: ollama
  endpoint: http://localhost:11434/v1
  name: gemma4:31b
  context_length: 32768

agent:
  max_iterations: 25
  reflection_enabled: true
  skill_authoring_enabled: true
  skill_authoring_requires_approval: true

memory:
  episodic_retention_days: 90
  semantic_max_facts: 10000
  procedural_skills_dir: ~/.hermes/skills

sandbox:
  default_network: deny
  default_filesystem_write: ~/.hermes/scratch
  default_shell: deny

The skill_authoring_requires_approval: true flag is the one most people miss. With it off, Hermes will write and install new skills autonomously; with it on, you get a diff and an approve/reject prompt. For an agent running on your homelab with access to real services, leave it on.

Up-and-Coming Agent Frameworks Worth Knowing

Hermes and OpenClaw are the headliners for self-hosted personal agents, but the agent space is bigger than personal automation. Here’s the landscape, organized by what each framework is actually for.

Letta (formerly MemGPT)

The original “agents with persistent memory” project. ~15k stars, well-engineered, narrower in scope than Hermes or OpenClaw. Letta is a library you build with, not a runtime you install. If you want to bake agent-style memory into your own application rather than run a standalone assistant, Letta is the cleanest building block.

Pick it when: You’re a developer building agent capability into a product.

Smolagents (Hugging Face)

The minimalist counterpoint. The entire framework is ~1,000 lines of Python. Its design innovation is that the agent generates Python code snippets rather than JSON tool calls — the model is more reliable when writing actual code than when filling out structured forms. ~26k stars and growing.

Pick it when: You want to understand how agent frameworks work end-to-end, or you need something small enough to audit yourself before deploying.

OpenHands (formerly OpenDevin)

Specifically a coding agent. Opens a sandboxed environment, writes code, runs tests, debugs, commits. Not a general assistant — it’s an autonomous engineer. The closest open-source analog to Claude Code or Cursor’s background agents.

Pick it when: Your use case is “I want an agent that solves coding tickets while I sleep.”

LangGraph

The production workhorse. Roughly 400 enterprises run agents on LangGraph Platform — Cisco, Uber, LinkedIn, BlackRock. It’s the framework you reach for when you need observability, persistence, human-in-the-loop checkpoints, and the ability to fail gracefully across multi-step workflows. Heavier to learn than the others. Not for personal homelab use.

Pick it when: You’re shipping an agent product at a company.

Anthropic Agent SDK

Anthropic’s first-party SDK for building agents on top of Claude. Tighter integration with Claude’s tool use, structured output, and computer-use capabilities than third-party frameworks can manage. Cloud-only (Claude API), not a self-hosted runtime.

Pick it when: You’re building on Claude and want first-party integration; you don’t need local-model support.

Google Agent Development Kit (ADK)

Google’s answer to the agent SDK question. Strongest integration with Gemini and Google Cloud services. Open-source, but the design center is “agents that run on Google Cloud.” Worth knowing about if you’re already on GCP.

OpenAI Agents SDK

The successor to Swarm. Designed for multi-agent orchestration on OpenAI’s API. The “agent handoff” primitive is genuinely useful for hierarchical agent setups. Cloud-only.

Microsoft AutoGen and Semantic Kernel

Microsoft has two parallel offerings. AutoGen is the multi-agent conversation framework; Semantic Kernel is the broader SDK for orchestrating LLMs and tools. AutoGen has had the most interesting research, but neither has the deployment scale that LangGraph does in production.

What this means

The takeaway from the framework landscape isn’t “pick the best one.” It’s that “AI agent framework” is now an umbrella for at least four different categories of tool:

Pick from the right category first; pick the specific tool second.

Practical Recommendations

If you got to this point and you’re trying to decide what to actually install, here’s the short version:

Run Hermes Agent if:

• You want a self-hosted assistant that gets smarter over time
• You care about running on local models specifically
• You value tight engineering and a restrictive default security posture
• You’re comfortable with a smaller built-in skill catalog in exchange for self-authoring

Run OpenClaw if:

• You want WhatsApp/iMessage/etc. on day one
• You want the deepest pre-built skill ecosystem
• You’re running primarily against cloud Claude
• You can accept a looser default security posture (or you’ll tighten it yourself)

Run both if:

• You’re curious. They install cleanly side by side, they don’t interfere with each other, and you’ll learn more from a week of comparison than from reading anyone else’s review (including this one).

Don’t run either if:

• You don’t have a clear use case in mind. Personal agents are powerful, but they’re also a maintenance commitment. Without a real workload to give them — emails to triage, services to monitor, repos to babysit — they end up being expensive curiosities.

The honest end-state for most people is one personal agent runtime (Hermes or OpenClaw) handling proactive automation, plus a specialized coding agent (OpenHands or Claude Code) for software work, plus whatever LLM provider you happen to like for ad-hoc questions. The agents-everywhere future is closer than it was six months ago, but it’s still being assembled piece by piece.

Run something local. See how it breaks. That’s the only way to learn what these tools actually do.