# Hermes Feature Inventory — what they actually ship, for parity claims

Audit date: 2026-05-27. Lens: **what a normal user can do with Hermes today.**
The sibling doc `docs/hermes-reliability-audit.md` covers internal reliability
primitives; this one is the consumer-feature view.

Sources read:
- `https://github.com/nousresearch/hermes-agent` (README + repo description)
- `https://github.com/NousResearch/hermes-agent/blob/main/website/docs/reference/tools-reference.md`
- `https://hermes-agent.nousresearch.com/` (marketing)
- `https://hermes-agent.nousresearch.com/docs/` (docs site)
- Web search for "Nous Research hermes-agent features", "hermes-agent tool list"

The fetches above were summarised through WebFetch — exact line references in
the Hermes source could not be inspected directly without cloning the repo
(WebFetch returns rendered markdown, not raw files). All claims below are
quoted or paraphrased from the listed surfaces; anything I could not verify is
flagged with **(unverified)**.

---

## What Hermes actually is

Hermes Agent is an open-source Python CLI (Python 88.9% of the repo per
GitHub language stats). It is a single-process agent loop with tool calls.
You install it via a one-line `curl | bash`, run `hermes` in a terminal, and
talk to a model.

It has two entry points:
1. `hermes` — interactive terminal UI (TUI). Multiline editing,
   slash-command autocomplete, conversation history, interrupt-and-redirect,
   streaming tool output.
2. `hermes gateway` — a long-running gateway process that bridges messages
   from Telegram / Discord / Slack / WhatsApp / Signal / Email / SMS /
   Matrix / Mattermost / DingTalk / Feishu / WeCom / BlueBubbles / Microsoft
   Teams / Home Assistant into the same agent loop.

The headline marketing pitch is **"the only agent with a built-in learning
loop"** — meaning it auto-creates skills from completed work, nudges itself
to save important facts to long-term memory, and uses FTS5 full-text search
over its own conversation history.

It is MIT-licensed. The Nous Research org promotes it as the successor /
migration target for users of an earlier project called "OpenClaw" (`hermes
claw migrate` is a supported CLI verb).

---

## What a Hermes user can actually do today

### Channels / surfaces
- Terminal UI on macOS / Linux / Windows (PowerShell installer, "early beta").
- Telegram, Discord, Slack, WhatsApp, Signal, Email — bidirectional through
  the gateway.
- SMS, Matrix, Mattermost, DingTalk, Feishu, WeCom, BlueBubbles, Microsoft
  Teams, Home Assistant — also via the gateway per the marketing page (the
  docs site footnotes some of these as community-contributed).
- Voice — "real-time voice interaction in CLI, Telegram, Discord, and
  Discord VC" per the docs.
- Discord VC (voice-channel listening) is called out specifically.

### Tools the model can call (from `tools-reference.md`)

Around 70 built-in tools, grouped:

| Group | Tools | Count |
|---|---|---|
| Browser (core) | `browser_back`, `browser_click`, `browser_console`, `browser_get_images`, `browser_navigate`, `browser_press`, `browser_scroll`, `browser_snapshot`, `browser_type`, `browser_vision` | 10 |
| Browser (CDP-gated) | `browser_cdp`, `browser_dialog` | 2 |
| File | `patch`, `read_file`, `search_files`, `write_file` | 4 |
| Terminal | `terminal`, `process` | 2 |
| Web | `web_search`, `web_extract` | 2 |
| Home Assistant | `ha_call_service`, `ha_get_state`, `ha_list_entities`, `ha_list_services` | 4 |
| Spotify | `spotify_playback`, `spotify_devices`, `spotify_queue`, `spotify_search`, `spotify_playlists`, `spotify_albums`, `spotify_library` | 7 |
| Feishu | `feishu_doc_read`, `feishu_drive_add_comment`, `feishu_drive_list_comments`, `feishu_drive_list_comment_replies`, `feishu_drive_reply_comment` | 5 |
| Yuanbao | `yb_query_group_info`, `yb_query_group_members`, `yb_send_dm`, `yb_search_sticker`, `yb_send_sticker` | 5 |
| Kanban | `kanban_show`, `kanban_list`, `kanban_complete`, `kanban_block`, `kanban_heartbeat`, `kanban_comment`, `kanban_create`, `kanban_link`, `kanban_unblock` | 9 |
| Discord | `discord`, `discord_admin` | 2 |
| Standalone | `memory`, `clarify`, `delegate_task`, `execute_code`, `cronjob`, `session_search`, `skill_view`, `skill_manage`, `skills_list`, `text_to_speech`, `image_generate`, `video_generate`, `vision_analyze`, `video_analyze`, `mixture_of_agents`, `send_message`, `todo`, `computer_use`, `x_search` | 19 |

Plus dynamic tool loading from any MCP server.

### Memory + persistence
- Cross-session conversation history in SQLite with FTS5 full-text search.
- An LLM-summarised "session_search" tool to recall prior chats.
- Agent-curated long-term memory (the agent itself decides when to call
  `memory` to write a fact).
- "Honcho dialectic user modeling" — a per-user profile that grows over time.
  **(unverified — only described in marketing copy, no source pointer.)**
- Skills stored locally, hot-discoverable, version-managed.

### Skills
- Skill creation, update, delete via `skill_manage`.
- Skill discovery via `skills_list` with description-based selection.
- "Self-improving" — the agent updates a skill's body when it learns a new
  detail.
- Compatible with the open standard at `agentskills.io` (the same standard
  InfiniBot's skills are based on — frontmatter + SKILL.md body).

### Sub-agents
- `delegate_task` spawns an isolated sub-conversation with its own context
  window and tool set. The result is fed back into the parent turn as a tool
  result.
- "Zero-context-cost pipelines" is the marketing line.

### Cron / scheduling
- `cronjob` tool — natural-language schedule descriptions, deliverable to any
  connected platform. "Built-in cron with delivery to any platform."

### Browser control
- Headed / headless via the 12 browser_* tools above.
- CDP escape hatch for advanced cases.
- Vision tool that screenshots + LLM-analyses the page.

### Voice / TTS
- `text_to_speech` standalone tool.
- "Real-time voice interaction" called out in the docs for CLI + Telegram +
  Discord (incl. voice channels).
- **(unverified — voice provider / latency story not documented at the URL
  WebFetch could reach.)**

### Image / video / vision
- `image_generate` via FAL.ai (per the tools reference).
- `video_generate` (text-to-video and image-animate).
- `vision_analyze` (still images) and `video_analyze` (URLs / files).

### Code / dev
- `execute_code` — runs Python that can call Hermes tools programmatically,
  for "collapsing workflows".
- `terminal` + `process` for arbitrary shell access on the host where Hermes
  is running.

### Deployment topologies
- Six "terminal backends" the agent can use to run shell commands: local,
  Docker, SSH, Daytona, Singularity, Modal.
- The Modal / Daytona path lets the whole agent hibernate to nearly zero cost
  when idle.

### Model story
- 200+ models via OpenRouter, plus Nous Portal, OpenAI, Anthropic,
  Kimi/Moonshot, MiniMax, z.ai/GLM, NVIDIA NIM, Hugging Face, any
  OpenAI-compatible endpoint, and local via Ollama / vLLM.
- Per-conversation model switching via `/model` slash command.
- "Mixture of agents" tool routes hard problems through multiple frontier
  models in parallel.

### Reliability primitives (cross-reference)
See `docs/hermes-reliability-audit.md` for the deep dive. Headlines: iteration
budget with grace call, pre-call validation + arg coercion, classified
retryable / non-retryable errors with exponential backoff + jitter, malformed
JSON repair via `_repair_tool_call_arguments`, content-after-think guards,
trajectory persistence for resume across restarts.

---

## What's notably **not** in Hermes

These are absences a normal "I want a personal AI" user would notice once
they tried both:

- **No GUI.** The whole product is a CLI + a gateway daemon. You read replies
  in a terminal or in whichever chat app you forwarded to. There is no
  dashboard, no kanban, no business view, no notes UI, no calendar surface,
  no settings panel that isn't a TOML file.
- **No federation.** Hermes runs on one host. The Modal / Daytona backends
  give it portable compute, but there is no multi-node "this agent lives on
  my laptop AND my server AND my phone, sharing state in real time" story.
- **No life-OS layer.** No discipline / day-start / day-end / overlay.
  No completion-bus tying kanban + agent + content together as a single
  schedule the agent enforces against you.
- **No business pipeline.** No lead-gen scrapers, no funnels, no landing
  pages, no business-income tracker, no campaigns, no community / role
  gating.
- **No content production substrate.** No content-pages with live IG
  analytics, no storyboard, no video editor, no image studio, no composition
  graphs.
- **No native desktop integration.** No Hyprland window / workspace / capture
  / highlight tools, no taskbar icon, no overlay that takes over the screen.
- **No canvas modality.** No Excalidraw-style hand-drawn diagram tool the
  agent can use to think on screen; no Three.js / Cytoscape visualisations.
- **No first-class voice infrastructure.** TTS is a tool, voice
  interaction in Telegram/Discord is supported, but there's no in-app
  LiveKit-style WebRTC voice room and no on-device ONNX speech backend
  bundled.
- **No vault.** Credentials live in the user's env / config files. No
  encrypted secrets store with 0600 perms, no per-integration scoped
  credentials surface.
- **No browser relay.** Their browser tools drive a per-call Chromium /
  Playwright session. There is no long-running browser process attached to a
  user's persistent profile with session cookies and saved logins kept
  across calls.
- **Skills hub is open / shareable** (agentskills.io) — that's a real win
  for them. InfiniBot's skills are locally curated, not yet shared through
  a public hub. Worth acknowledging.

---

## TL;DR for the comparison note

Hermes is a **real product** with a real loop, real memory, real skills, real
sub-agents, real cron, real MCP support, real ~70 tools, real multi-channel
gateway, real model-agnostic backend. The lazy framing of "Hermes is just
a chat loop" doesn't hold up — they ship more than that.

What Hermes is **not** is a substrate. It's a CLI that talks to messaging
apps. Everything that's not "talk to the model and have it call a tool"
lives outside Hermes's universe: federation, life-OS, business pipeline,
content production, native desktop, canvas, full GUI dashboard, vault,
persistent browser relay.

The honest receipt is: **for every meaningful Hermes capability, InfiniBot
has a counterpart or superset.** Hermes ships ~70 tools; InfiniBot's gateway
exposes ~628 base RPC methods plus per-channel extensions. Hermes runs on
one host; InfiniBot federates. Hermes lives in a terminal; InfiniBot is a
desktop app with 192 view files. Hermes auto-creates skills; InfiniBot does
too AND ships 73 of them curated. The parity argument is: yes we got that
— and we got the other 90% of what a personal AI actually needs.
