Skip to content

Runtime Hermes

Jump to bottom
weiyong1024 edited this page Apr 27, 2026 · 1 revision

Hermes

A single-user learning agent, built by Nous Research. Memory compounds across sessions. The agent writes its own skills from experience and improves them as it uses them.

Upstream: github.com/NousResearch/hermes-agent · Python, distributed via PyPI and an official Docker image

What is Hermes

Hermes Agent is built around a learning loop, not just a chat loop. It's the runtime to pick when you don't want a brand-new agent each session — you want one assistant that remembers what you've been doing and gets better at helping you over time. Three mechanisms make this concrete:

  1. Cross-session memory. SQLite FTS5 full-text search across past sessions, plus periodic LLM summarization. Past conversations are retrievable by content, not just by date.
  2. Honcho user modeling. A dialectic user model that builds and refines a representation of you — your goals, preferences, idioms — as a separate evolving artifact alongside conversation memory.
  3. Self-authored skills. After completing complex tasks, Hermes can write a skill that captures the procedure, then refine that skill on subsequent uses. Skills are procedural memory, not just curated tools.

Hermes is TUI-first: the primary surface is an interactive terminal chat (hermes command). Messaging platforms (Discord, Telegram, Slack, WhatsApp, Signal, and more) are secondary remote-control surfaces — useful for delegating tasks and getting results back, but not where the agent's relationship with you primarily lives.

ClawFleet runs Hermes inside a sandboxed Docker container with both Hermes's native Web Dashboard (port 9119 inside) and its messaging Gateway (port 3000 inside) launched at startup. ClawFleet's outer Dashboard handles container lifecycle and basic Configure; deeper agent configuration happens in Hermes's own native Dashboard.

Architecture

Hermes inside a ClawFleet container:

┌── Container (one per ClawFleet instance) ────────────────────────┐
│                                                                  │
│   Hermes Native Dashboard ──── HTTP on :9119                     │
│       │                              │── exposed on host 690N    │
│       │   (credentials, cron, personality, terminal backends)    │
│                                                                  │
│   Hermes Gateway ──── messaging events on :3000                  │
│       │                              │── exposed on host 1878N   │
│       │                                                          │
│       ├── Memory layer  (FTS5 + Honcho user modeling)            │
│       ├── Skills  (40+ built-in + agent-authored)                │
│       ├── Tools  (40+ toolsets)                                  │
│       ├── Cron scheduler  (delivery to any platform)             │
│       ├── Terminal backends  (local/Docker/SSH/Daytona/Modal)    │
│       └── Workspace at /opt/data                                 │
│             ├── auth.json  (credential pool, multi-key)          │
│             ├── config.yaml  (model + gateway settings)          │
│             ├── SOUL.md  (personality)                           │
│             ├── memories/, sessions/, skills/, plans/, ...       │
│                                                                  │
└──────────────────────────────────────────────────────────────────┘

Key pieces:

  • Native Dashboard — Hermes's own web UI for everything beyond basic config: rotating credentials, scheduling cron, editing personality, choosing terminal backends, browsing skills. Port 9119 inside the container; ClawFleet exposes it on a host port shown on each instance card (typically 690N).
  • Gateway — single process that fronts all configured messaging platforms. One instance can be reachable simultaneously from Discord + Telegram + Slack + WhatsApp + ... without separate processes.
  • Memory layer — the architecturally most distinct part of Hermes. Two complementary stores: FTS5 cross-session retrieval (for "what did I ask you last week about X?") and Honcho dialectic user modeling (for "based on this user's pattern, what would they want?").
  • Skills — both the 40+ Hermes-bundled skills and skills the agent writes itself when it solves something novel. Skills are stored as procedural memory under workspace/skills/ and can be inspected, edited, or shared.
  • Cron scheduler — first-class. Schedule "every weekday at 8am, run X and DM me the result" in plain English; results route to any configured platform.
  • Terminal backends — what the agent uses to do work. Six options: local in-container, Docker side-container, SSH to a remote machine, Daytona/Singularity sandboxes, Modal serverless. The agent itself is local; its hands can be remote and elastic.
  • Credential pool — auth.json is a multi-credential store keyed by provider:name (e.g. openai-codex:default). Supports rotation and per-credential metadata; managed entirely through the native Dashboard today.

When to pick Hermes

Hermes is the right choice when you want:

  • A personal "my assistant" that learns over time. Not a participant in your team chat — a private agent that remembers your projects, your preferences, the specific way you work.
  • First-class cron / scheduled automations with delivery to messaging. "Every Monday morning, summarize last week's GitHub activity and post to my Slack DM" is a Hermes one-liner.
  • Remote / serverless execution backends. SSH into a beefier remote machine, or burst onto Modal serverless for parallel work, while the agent's "brain" stays local. Pay for compute only when you need it.
  • Long-tail LLM provider support. Beyond the big five, Hermes natively supports Nous Portal, GLM (z.ai), Kimi/Moonshot, Xiaomi MiMo, MiniMax, NVIDIA NIM, OpenRouter (200+ models), and arbitrary custom endpoints.
  • A TUI-first workflow with messaging as the secondary surface, not the main one.

ClawFleet integration today

ClawFleet's Hermes integration is newer than its OpenClaw integration. Today the Dashboard handles container lifecycle and a minimal Configure flow that gets you to a working agent quickly; deeper configuration happens in Hermes's own native Dashboard. The direction is full Dashboard parity with OpenClaw — these gaps are integration work in progress, not design choices.

Capability Status Notes
Configure (Model + Channel) ✅ Dashboard. Channel scope today is Discord / Telegram / Slack
Native Hermes Dashboard ✅ One-click ⚕ Dashboard button on instance card. Opens credential pool, cron, personality, terminal backends
clawfleet shell hermes-N ✅ Drops into Hermes's interactive TUI
Container lifecycle ✅ Suspend / Resume / Destroy / batch operations
Stats / logs / events ✅ Real-time
Skill Manager (planned) Today managed via Hermes native Dashboard
Save Soul / Soul Archive (planned)
Browser Desktop (planned) Hermes images don't ship a desktop today
Restart Bot (planned) Use container restart for now
15+ upstream channels (Dashboard scope: 3) WhatsApp, Signal, etc. configurable via Hermes native Dashboard

Bringing Hermes to full Dashboard parity with OpenClaw is an active direction. The (planned) entries are tracked work, not stable design.

Setup walkthrough

1. Create a Hermes instance

  1. In the Dashboard, click + Create Instances
  2. Set Runtime to Hermes Agent
  3. Click Create

The instance appears under the ☤ Hermes group header on the Fleet page. Cards show two ports: Dashboard (Hermes's native UI) and Gateway (messaging endpoint).

2. Configure model + channel from the ClawFleet Dashboard

  1. Click Configure on the Hermes instance card
  2. Model Config — pick from your asset pool. Codex (ChatGPT subscription) is OpenClaw-only; for Hermes use Anthropic, Google AI Studio, DeepSeek, or OpenAI (or any custom provider via Hermes native Dashboard later)
  3. Channel Config (optional) — Discord, Telegram, or Slack
  4. Click Configure

ClawFleet writes the model into Hermes's config.yaml, drops the channel token into .env with GATEWAY_ALLOW_ALL_USERS=true, and restarts the container so Hermes picks up the new config. Within seconds the bot is reachable on your configured platform.

3. Deeper config via Hermes's native Dashboard

For credentials beyond a single API key, scheduled cron jobs, personality tuning, terminal backend selection, or a channel beyond Discord/Telegram/Slack:

  1. Click the ⚕ Dashboard button on the instance card
  2. Browser opens Hermes's own UI on the host port shown on the card

Hermes's native Dashboard exposes all the depth ClawFleet's Configure dialog doesn't. Use it for:

  • Credentials — rotate keys, add fallback credentials, pool credentials per provider
  • Cron — schedule recurring tasks with natural-language descriptions
  • Personality — edit SOUL.md, switch between named personalities
  • Terminal backends — point Hermes at SSH, Daytona, or Modal for execution
  • Skills — browse, edit, install new skills

4. Or jump straight into the TUI

If you'd rather use Hermes interactively from the command line:

clawfleet shell hermes-1

This drops you into Hermes's interactive TUI inside the container. Type messages, get responses; /help shows commands. Exit with /exit (the messaging Gateway keeps running independently — it's a separate process inside the container).

Common gotchas

  • Native Dashboard port is per-instance. The upstream default is 9119 inside the container, but the host port is allocated when the instance is created. Read it from the card, not from documentation.
  • ClawFleet's Configure dialog only lists 3 channels. Discord, Telegram, Slack. WhatsApp, Signal, and other Hermes-supported platforms are configurable via the native Dashboard.
  • Save Soul rejects Hermes today. The Soul Archive flow is OpenClaw-specific in ClawFleet v1. The roadmap includes Hermes parity; until then, Hermes state lives at ~/.clawfleet/data/<name>/hermes/ on the host and can be backed up manually.
  • ChatGPT (Codex) is greyed out. Codex's OAuth is OpenClaw-exclusive. Hermes uses standard API-key providers or provider=custom with a base_url.
  • /exit doesn't stop the gateway. clawfleet shell drops into the TUI; exiting the TUI returns you to your host shell but the messaging Gateway continues running inside the container. To stop everything, suspend or destroy the instance from the Dashboard.
  • Memory is per-instance, not per-user-across-instances. If you destroy a Hermes instance and create a new one, the new one doesn't inherit the old one's memory. Use the host data directory if you need to migrate.

Related guides

ClawFleet · Website · Discord

ClawFleet Wiki

Runtimes

LLM Providers

Messaging Channels

Reference

Clone this wiki locally