Skills, MCP & Memory — ต่อความสามารถให้ agentSkills, MCP & Memory — Extending What the Agent Knows

🤔 If you told Hermes yesterday that you prefer short answers, and today it is still writing you essays — did it forget, or did it never remember in the first place?

The previous post — #4 The Council — Check Before Deliver — set up a council that checks an answer before it reaches us. That was about the quality of what the agent says. This post steps back one pace to look at its raw material: what the agent knows, which tools it can reach, and what it remembers from one day to the next — because the best council in the world can only check what the agent has to offer.

The one-line answer: Hermes has three drawers for adding knowledge — a skill is a knowledge document loaded on demand, an MCP server is an external tool declared in config.yaml, and memory is two files with a character cap — all three open from the Hermes Desktop screen, and everything you put into them has a price in context that you can read off the meter at the bottom of the chat. This post walks one drawer at a time: what to click, what to type, what you see, and what to check.

1. Three Ways to Make the Agent Know More — Skills, MCP and Memory

The direct answer first: the three mechanisms differ in the shape of the knowledge and in when it enters the context, but they share one destination — the prompt the model sees on every turn — and all three are Hermes Agent capabilities, not Desktop-specific ones. The Desktop docs say it plainly: the app is built around the same agent as the CLI — "same config, same API keys, same sessions, same skills, same memory".^[2] What Desktop adds is a screen for each drawer.

• Skills — the official docs define them as "on-demand knowledge documents the agent can load when needed", compatible with the open agentskills.io standard, living in ~/.hermes/skills/, "the primary directory and source of truth".^[1] The agent sees only the name, description and category of every skill (around 3k tokens) and loads the full content only for the one it actually needs.^[1]
• MCP servers — external tools speaking the Model Context Protocol, declared under the mcp_servers: key in ~/.hermes/config.yaml, either as a local subprocess (stdio) or a remote endpoint (HTTP). Every discovered tool is registered as mcp_<server_name>_<tool_name> so it cannot collide with a built-in.^[3]
• Memory — two files in ~/.hermes/memories/: MEMORY.md, the agent's own notes (capped at 2,200 characters ≈ 800 tokens), and USER.md, our profile (capped at 1,375 characters ≈ 500 tokens). Both are injected into the system prompt as a snapshot frozen at session start.^[6]

The theory behind each drawer is already written up in the analytical series, and I will not repeat it: the loop in which the agent writes its own skills and the Curator that tidies up is in Hermes #6 Skills; the philosophy of bounded memory and the FTS5 search layer is in Hermes #3 Memory; and MCP in both directions, OAuth included, is in Hermes #5 Integrations. This post is purely practical: which drawer to open, and where to click.

2. Skills — Install One from the Hub, Write One Yourself

The direct answer: in Desktop the Skills tab lists your installed skills with enable/disable toggles, and below them the optional-skills catalog that ships with Hermes, each entry with a one-click Install button.^[2] To go beyond the built-in catalog — searching skills.sh, GitHub or a plain URL — you use the hub through the hermes skills command, which you can type in the terminal embedded in the app (Ctrl+` opens the terminal panel in the right sidebar).^[2]

Install one from the hub

1. Open the Skills tab — the docs group it with the management panes, and the command palette (Cmd/Ctrl+K) opens any page or settings section from the keyboard. What you see: the list of installed skills, each row with a toggle, and the optional-skills catalog below it.^[2]
2. Click Install on a catalog entry. What you see: the docs say the button "flips the row into the installed list once it finishes" — the row moves up into the installed list when done.^[2]
3. For other sources, open the in-app terminal with Ctrl+` and always explore before installing: hermes skills browse --source official shows the official catalog, hermes skills search kubernetes searches every source, hermes skills inspect openai/skills/k8s previews the details before installing.^[1] The sources the hub supports, per the docs, are official, skills-sh, well-known, url, github and the community aggregators clawhub, lobehub, browse-sh.^[1]
4. Install: hermes skills install openai/skills/k8s — the docs annotate it "Install with security scan". What you see: the skill lands in ~/.hermes/skills/, and hermes skills list --source hub lists the ones that came from the hub.^[1]
5. Back in the chat box, type the skill as a slash command, /<skill-name>, followed by your request — every installed skill automatically becomes a slash command, and if you type just the skill name the agent loads it and asks what you need.^[1] What you see: the skill is loaded into context for the turn that invoked it, not every turn.
6. Keep it maintained: hermes skills check asks whether upstream has a newer version, hermes skills update installs it, hermes skills audit re-runs the security scan over everything.^[1]

# Explore first, install second — every command works in the Desktop terminal
hermes skills browse --source official
hermes skills search kubernetes
hermes skills inspect openai/skills/k8s
hermes skills install openai/skills/k8s
hermes skills list --source hub
hermes skills check
hermes skills update
hermes skills audit

Write one yourself

A skill is a folder whose required file is SKILL.md. The docs' example tree groups them by category, e.g. ~/.hermes/skills/devops/deploy-k8s/SKILL.md, with references/, scripts/, templates/, examples/ and assets/ as optional supporting folders.^[1] The head of the file is YAML frontmatter in this shape (excerpted from the docs' example, which marks platforms, the conditional-activation keys and config as optional)^[1]:

---
name: my-skill
description: Brief description of what this skill does
version: 1.0.0
platforms: [macos, linux]     # optional — restrict to specific operating systems
metadata:
  hermes:
    tags: [python, automation]
    category: devops
    requires_toolsets: [terminal]   # optional — activate only when this toolset exists
---

# Skill Title

## When to Use
## Procedure
## Pitfalls
## Verification

1. Create the folder and the file: mkdir -p ~/.hermes/skills/devops/my-skill, then create SKILL.md inside it.
2. Paste the frontmatter at the top, set name to match the folder name, and write a description that says "when to use", because the name and description are the only things the agent sees in the Level 0 list before deciding to load it.^[1]
3. Write the body under the docs' four headings — When to Use (trigger conditions), Procedure (the steps), Pitfalls (known failure modes and fixes), Verification (how to confirm it worked).^[1]
4. Confirm: if a chat is already open, type /reload-skills first — it re-scans ~/.hermes/skills/ for newly installed or removed skills.^[8] Then hermes skills list must show the new name, the Skills tab in Desktop must list it with a toggle, and /my-skill in chat must load it.^[1][4]

Before moving on, two numbers that show how big this drawer is — and both come from the docs rather than from counting by hand: the Bundled Skills Catalog lists 61 skills in 12 categories (apple, devops, research, web …) seeded into every profile at install time, while the Official Optional Skills Catalog lists another 136 in 22 categories that are not active by default and have to be installed with hermes skills install official/<category>/<skill>.^[9] Those two sets are exactly what the Skills tab shows you: the installed list on top, the catalog waiting for an Install below it.^[2]

💡 From the community — disable what you do not use: creators doing walkthroughs count different numbers of skills on their own machines — one clip says "71 skills built into this", another says "over 150" — and all of them give the same advice: turn off the skills you do not use (iMessage, Find My, Apple Reminders …).^[12][13] Those two figures are what users report, not official numbers, and the spread between them is explained by the two catalog pages above: 61 seeded for you, another 136 you can add.^[9] The principle underneath the advice is documented: the Level 0 list of every skill costs around 3k tokens, and /context all shows the cost per skill.^[1][8] The toggles in the Skills tab are where you switch them off; on the CLI it is hermes skills config ("Interactive enable/disable configuration for skills by platform"), and to start from zero, hermes skills opt-out stops future seeding without deleting anything on disk.^[4][1]

3. MCP — Add a Server from the Screen or from config.yaml

The direct answer: there are two doors — the MCP page in the app (since v0.21.0, your configured servers and the catalog share one page) or writing the mcp_servers: key in config.yaml by hand.^[10][3] Both end in the same place: Hermes discovers the server's tools on connect and registers them as mcp_<server_name>_<tool_name>, with a toolset named mcp-<server> so you can manage them as a group.^[3]

From the screen — the MCP page (v0.21.0)

The v0.21.0 release notes describe this page in a single paragraph; I have split it into a list so you know what to look for: "MCP servers and the catalog merged into one coherent desktop page", with drag-in "paste anything" import, background health checks that nudge you to re-auth before a tool call fails, a cost/usage overlay showing "schema token estimates and 30-day usage per server", and hermes:// deep links that install an MCP server "with explicit confirmation".^[10] The Desktop docs count "MCP servers" among the settings panes, and the command palette (Cmd/Ctrl+K) opens any page or settings section from the keyboard.^[2]

1. Open the MCP page: Cmd/Ctrl+K and type MCP, or go in through Settings. What you see: your configured servers and the catalog on one page.^[10] That catalog is the set the Nous team has reviewed and merged (it lives under optional-mcps/ in the repo, with no community submission tier), and the docs are explicit that entries are disabled by default — install only what you actually want. On the CLI it is hermes mcp catalog and hermes mcp install <name>.^[3]
2. Add a server one of three ways — pick a catalog entry, paste the config you copied from the server's own docs (this is the "paste anything" import), or click a hermes:// link on a vendor's page, which the app always confirms first — read exactly what it is about to run before you accept.^[10]
3. Wait for the background health check: if the server needs re-authentication, this page warns you before a tool call fails.^[10] Check at the same time: that server's schema token estimate in the overlay — this is the price every turn will pay (section 6).
4. Go back to the chat and ask for something the server can do. What you see: in the tool activity, a tool name beginning with mcp_ followed by the server name — the docs say you normally never call the full name yourself; Hermes sees the tool and chooses it during normal reasoning.^[3]

From YAML — mcp_servers: in config.yaml

1. Open ~/.hermes/config.yaml and add an mcp_servers: block. The first example is the stdio server the docs use in their Quick start — a filesystem server run through npx with access to a single directory (replace /home/user/projects with your own folder).^[3]
2. Or a remote HTTP server with an authentication header — also the docs' minimal example.^[3] Put secrets in an environment variable rather than in the file where you can.
3. Test before using: hermes mcp test filesystem ("Test connection to an MCP server") and hermes mcp list to see what is configured.^[4] If it does not connect, the docs have you check node --version and npx --version first.^[3]
4. If a chat is already open, type /reload-mcp — it reloads the servers from config and re-probes the tools, because a session's tool set is otherwise frozen and only picks up new things on /reload-mcp, /new or context compaction.^[3]
5. Use it: type the docs' example prompt, "List the files in /home/user/projects and summarize the repo structure." What you see: the agent calls mcp_filesystem_read_file or one of its siblings, per the naming table in the docs.^[3]
6. Switch off without deleting: enabled: false in that server's block — the docs list it as one reason for "tools not appearing".^[3]

# ~/.hermes/config.yaml — stdio server (the docs' Quick start example)
mcp_servers:
  filesystem:
    command: "npx"
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"]

# ~/.hermes/config.yaml — remote HTTP server (the docs' minimal example)
mcp_servers:
  company_api:
    url: "https://mcp.internal.example.com"
    headers:
      Authorization: "Bearer ***"

# Test, list, then reload inside the chat
hermes mcp list
hermes mcp test filesystem
/reload-mcp

The knob people forget is the middle one: you do not have to switch a whole server off to cut its price. The docs let you filter per tool with tools.include (register only these) or tools.exclude (register everything but these); both accept glob patterns, and if you write both keys, include wins.^[3] This is the way out for servers that generate thousands of tools from an OpenAPI surface — the docs cite cloudflare at roughly 3,300 endpoint tools, which ships a block-list instead of a checklist.^[3] On the CLI, hermes mcp configure <name> reopens that same checklist with your current selection pre-checked.^[3][4]

# ~/.hermes/config.yaml — register only the tools you actually use (the docs' whitelist example)
mcp_servers:
  github:
    command: "npx"
    args: ["-y", "@modelcontextprotocol/server-github"]
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: "***"
    tools:
      include: [create_issue, list_issues]

💡 MCP runs the other way too: hermes mcp serve turns Hermes itself into an MCP server for other agents to connect to.^[4] I tell the "MCP both ways" story in Hermes #5 Integrations — in this post we stay on the inbound side.

4. Memory — Read, Edit and Reset MEMORY.md and USER.md

The direct answer: Hermes's persistent memory is two capped Markdown files — MEMORY.md at 2,200 characters and USER.md at 1,375 characters, in ~/.hermes/memories/ — and when one is full the memory tool returns an error rather than silently dropping old entries.^[6] In Desktop we read and edit them from the Memory Graph (the docs call it both Memory Graph and Star Map), while the profile-level switches sit on the Settings → Memory & Context page, which the docs name but do not walk through control by control.^[2]

Read

What the agent sees on every turn is a block like this in the system prompt — a header saying which store it is and how full, and entries separated by the § sign (excerpted from the docs' example)^[6]:

MEMORY (your personal notes) [67% — 1,474/2,200 chars]
User's project is a Rust web service at ~/code/myapi using Axum + SQLx
§
This machine runs Ubuntu 22.04, has Docker and Podman installed
§
User prefers concise responses, dislikes verbose explanations

The one rule to remember when reading it: this block is a frozen snapshot — captured once at session start and never changed mid-session, to preserve the model's prefix cache. If the agent saves a memory during a conversation, the file on disk changes immediately, but the prompt sees the new content in the next session.^[6] That is the answer to the question in this post's first paragraph: it did remember, but the old session is still reading the old snapshot — open a new session and look.

Edit and reset

1. Open the Memory Graph: command palette → Memory Graph, click the status-bar item, or type /journey in chat (aliases /learning, /memory-graph). What you see: a zoomable node graph of skills and memories with a timeline, filterable by All / Used / Learned.^[2]
2. Click a node and edit or delete it right from the panel — the docs spell out the different outcomes: "skills are archived, memories removed", i.e. a skill goes to the archive (restorable) while a memory chunk is actually deleted.^[2]
3. The CLI does the same: hermes journey list prints the node ids (memory chunks use the form memory:<source>:<index>), hermes journey edit <node> opens the content in $EDITOR, hermes journey delete <node> [-y] deletes without a second prompt if you pass -y.^[6]
4. To route every save through a human first: set memory.write_approval: true — in the CLI, foreground writes prompt inline, while other channels and the background review are staged; review with /memory pending, /memory approve <id>, /memory reject <id>, or flip the gate live with /memory approval on.^[6]
5. Reset: to switch the whole system off, set both memory_enabled: false and user_profile_enabled: false — the docs say that with both off the memory tool disappears from the schema and the prompt never mentions a tool it cannot use.^[6] If you only want to start remembering from zero, what I do is delete every node through the journey, or move the two files out of memories/ somewhere safe, and open a new session — the docs do not offer a separate "reset memory" command.

# ~/.hermes/config.yaml — the documented defaults
memory:
  memory_enabled: true
  user_profile_enabled: true
  memory_char_limit: 2200   # ≈ 800 tokens
  user_char_limit: 1375     # ≈ 500 tokens
  write_approval: false     # true = require approval before every save

display:
  memory_notifications: on  # off | on | verbose

If the two files are not enough, Hermes has an external memory provider layer as plugins you select one at a time, with the built-in memory always running alongside — the providers page opens with the number 8 (Honcho, OpenViking, Mem0, Hindsight, Holographic, RetainDB, ByteRover, Supermemory), while the comparison table at the bottom has Memori as a ninth row.^[7] Enable one with hermes memory setup, check with hermes memory status, switch off with hermes memory off, or set memory.provider: in config.yaml, or pick it from hermes plugins → Provider Plugins → Memory Provider.^[7][4] I still stand by the advice in Hermes #3 Memory: get the most out of the two files plus session search first, and add a provider only when you hit a problem those two layers genuinely cannot answer.

💡 The cap is the feature: the docs recommend consolidating entries once memory is above 80% of capacity, which you can read off the block header in the prompt.^[6] When I see that number in the Memory Graph I take it as a cue to open the entries one by one — not as a cue to raise the cap. Why the number is deliberately small is in Hermes #3 Memory.

5. Which One, When — Five Extension Points Compared

The direct answer: a fact that must be in context at all times → memory · a long procedure used now and then → skill · the ability to act on an external system → MCP server · a new screen or pane in the app → Desktop plugin, which is an entirely different system from the first three. The table lays all five side by side: where each lives on disk, its Desktop surface, its CLI, and the price it pays in context.

The last row is the one people confuse most often. A Desktop plugin does not make the agent know anything more — it adds a pane, a page, a status-bar item or a palette command to the app. It is a single ESM file the app loads within seconds and hot-reloads on every save, managed in Settings → Plugins.^[2][11] The "Agent plugins" section on the same page is the backend-side plugin system, a different thing again.^[2] If you want to try writing a plugin for the app, I wrote up an example and the limits in Hermes #10 Desktop & Fleet.

6. See What Each One Costs in Context

The direct answer: the Context usage meter in the status bar at the bottom of the chat shows a live "% full" of the context window, and clicking it opens the Context Usage popover with a token breakdown by category — system prompt, tool definitions, skills, memory, rules, MCP, subagent definitions and the conversation itself — which the docs say exists "so you can see exactly what's eating the window before compression kicks in".^[2] Three of those categories are exactly this post's three drawers.

1. Look at the status bar: the context meter is there. If you cannot see it, right-click the bar and choose Show in status bar → context meter (the whole bar hides and shows with Cmd/Ctrl+Shift+S).^[2]
2. Click the meter. What you see: the popover by category. Read three rows — skills (the CLI calls it the skills index), memory (the two files) and MCP (the tool schemas of every enabled server).^[2][8] If the MCP row is unexpectedly large, go to the next step.
3. Open the MCP page: the cost/usage overlay shows the schema token estimate and the last 30 days of usage per server — a server with a large schema and no calls in 30 days is the one I deal with first — trim the tools you never call with hermes mcp configure <name> or tools.include before reaching for enabled: false.^[10][3]
4. On the CLI/TUI use /context (alias /ctx) — it shows the same estimated per-category table, and /context all adds per-skill and per-toolset detail; /usage shows tokens, an estimated cost breakdown and — where the provider supports it — the account's remaining quota.^[8]

# In chat (CLI/TUI) — the same numbers as the Desktop popover
/context        # categories: system prompt, tool definitions, rules, skills index, MCP, subagents, memory, conversation
/context all    # adds per-skill / per-toolset cost
/usage          # tokens, estimated cost, account quota (where available)
/new            # start a fresh session when the meter fills (alias /reset)

💡 From the community — one session per topic: heavy users doing walkthroughs agree on keeping one session per topic, pinning and foldering them, and pressing /new when the meter at the bottom fills, because every message sends the whole thread back to the model — so cost grows with the length of the conversation, not with the number of questions.^[12] The docs confirm half of that in their memory-versus-session-search table: persistent memory has "Token cost: Fixed per session (~1,300 tokens)"; the conversation is the part that grows.^[6]

The order I use to bring the meter down, cheapest first: switch off unused skills in the Skills tab → trim unused MCP tools with tools.include, then set enabled: false on a server you rarely use, then /reload-mcp → let memory fill and consolidate it rather than raising the cap → and when all of that is still not enough, /new. The next post, #6 Automation & Agents, will use these numbers again, because every cron job and every subagent has a context of its own to pay for.

7. Summary

In this post we opened Hermes Desktop's three drawers one at a time: installed a skill from the catalog and from the hub, then wrote one ourselves from a few lines of frontmatter; added an MCP server both from the MCP page that v0.21.0 merged into one and from an mcp_servers: block lifted line for line from the docs; read, edited and reset MEMORY.md and USER.md from the Memory Graph and from hermes journey; and closed with the meter that says what each drawer costs in context. The one sentence to take away: everything the agent knows in addition has a price in tokens on every turn — so a good drawer is not the one that holds the most, but the one that knows what belongs in it.

The next post, #6 Automation & Agents — Work That Runs and Checks Itself, takes all three drawers into work that happens while nobody is at the screen: cron jobs that since v0.21.0 "load and update persistent memory like every other agent", and subagents that can be steered mid-flight.^[10]