Give Hermes a second brain: connect Nous Research's agent to your notes over MCP

Hermes already remembers things. Nous Research built it with a learning loop: it curates its own memory, writes skills from experience, and recalls across sessions. The catch is where that memory lives. It sits in Hermes's own store on one machine, and nobody on your team can open it, correct it, or read it when Hermes is off. Point Hermes at a Baalda vault over MCP and its memory becomes plain markdown files your whole team can see and edit.

Can Hermes read and write my notes?

Yes. Hermes Agent ships with a native MCP client, and MCP support comes with the standard install rather than as an add-on. Baalda runs an MCP server over your vault. Add Baalda to Hermes's config with a vault token and the agent gets search, read, and write access to the same .md files your team works in.

That makes this a two-sided arrangement rather than a plugin. Hermes brings the autonomy (it runs from the CLI and from Telegram, Discord, Slack, WhatsApp, Signal, and email, on your machine or on a server). Baalda brings a memory that is legible to humans.

What a shared vault gives Hermes that its own memory cannot

Hermes's internal memory is good at what it is for: remembering you, your preferences, and how it solved something last time. It is not built to be a team artifact. A vault is.

• Work you can correct. When Hermes writes a research summary or a decision log into a note, a teammate can open that note and fix the part it got wrong. Internal agent memory has no edit button.
• Context that survives the agent. Notes in a vault outlive Hermes's session history, its config, and its install. They are files on disk.
• One memory for several agents and several people. Hermes, a teammate in the desktop app, and another MCP client can all work against the same vault. Nobody is holding a private copy.
• Real-time merges. Baalda uses a CRDT, so a write from Hermes merges with a human typing in the same note instead of overwriting it.
• Permissions that actually bind. Every Hermes call runs as the user its token belongs to, and Baalda's per-file permissions gate each read and write.

What Baalda is, in one paragraph

Baalda is a team second brain built on plain markdown files on your own disk. Multiple people edit the same notes in real time, permissions are set per file, and it is open source under Apache-2.0 and self-hostable. It serves the Model Context Protocol at POST /api/mcp over Streamable HTTP, which is the door Hermes walks through. It is free to run locally, with an optional managed Team plan for hosted sync.

How to connect Hermes to Baalda over MCP

1. Mint a vault token. In the Baalda desktop app, open Vault Settings → MCP and create a connection token. It is scoped to one user and one vault and inherits that user's permissions.

2. Put the token in Hermes's environment file at ~/.hermes/.env (or ~/.hermes/profiles/<name>/.env if you use profiles), so it stays out of the config you might share:

BAALDA_MCP_TOKEN=mcp_your_token_here

3. Add Baalda to ~/.hermes/config.yaml under mcp_servers. Hermes takes remote HTTP servers as a url plus headers, and it resolves ${env:VAR} references from that .env file:

mcp_servers:
  baalda:
    url: "http://localhost:3010/api/mcp"
    headers:
      Authorization: "Bearer ${env:BAALDA_MCP_TOKEN}"
    timeout: 120
    tools:
      include: [search_notes, read_note, create_note, append_note, update_note]

http://localhost:3010/api/mcp is the default local address. If you self-host or use the Team plan, swap in your server's URL.

4. Reload and check. Run /reload-mcp inside a Hermes session to pick up the config without restarting. Hermes registers MCP tools as mcp__<server>__<tool>, so you should see mcp__baalda__search_notes and friends in the tool list.

The tools.include list above is optional but worth setting. Baalda exposes a fuller catalog (list_vaults, list_folders, list_notes, read_note, search_notes, create_note, update_note, append_note, edit_note, delete_note, create_folder, delete_folder, move_note, move_folder), and starting with read plus additive writes is the safer opening position. tools.exclude works too if you would rather blacklist.

Hermes also has a CLI path (hermes mcp opens an interactive picker, hermes mcp add takes a server directly) if you prefer not to hand-edit YAML. Config keys move as both projects ship, so if a server fails to register, check the current MCP reference in Hermes's docs before assuming the token is wrong.

What Hermes can do once it is connected

The useful jobs are the boring ones. Hermes can search the vault before it answers, so it stops re-deriving context you already wrote down. It can append meeting outcomes and message summaries into a running note. It can draft a document your team then edits by hand in the desktop app, live, while Hermes is still working. When it runs on a schedule, it can file the result somewhere a person will actually find it on Monday.

The writes land through the same sync path as human keystrokes, so a teammate watching that note sees the agent's text appear rather than discovering a conflicting copy later.

Where Baalda is not the right answer

Worth being straight about this.

If your team's knowledge already lives in Notion, Notion's hosted MCP server at https://mcp.notion.com/mcp is genuinely easier. It uses OAuth, there is nothing to run, and it is reachable whether or not your laptop is on. Baalda needs a server up somewhere, which means your machine for a local vault, or a self-hosted or managed instance for an always-on agent like Hermes.

If you are one person with an Obsidian vault, you do not need to move. The Local REST API community plugin now exposes an MCP endpoint directly, and that covers a solo agent reading and writing your notes. Baalda earns its place when more than one human needs to edit the same notes at the same time, which is the thing Obsidian does not do.

And Hermes's own memory does not disappear when you connect a vault. The vault is the shared layer. Hermes keeps its private recall and skills alongside it, which is the right split.

FAQ

Does Hermes Agent support MCP?

Yes. Hermes Agent has a built-in MCP client that ships with the standard install. It supports both local stdio servers and remote HTTP servers in the same ~/.hermes/config.yaml, discovers each server's tools at startup, and can filter which of them the agent sees.

How do I give Hermes persistent memory my team can read?

Connect it to a Baalda vault over MCP. Hermes then writes into plain markdown files on disk that your teammates open and edit in the Baalda app, instead of keeping everything in an internal store only the agent can read.

Where do I put my Baalda token in Hermes?

Put the token in ~/.hermes/.env as an environment variable and reference it from config.yaml with ${env:BAALDA_MCP_TOKEN} inside the server's Authorization header. That keeps the secret out of the config file itself.

Can Hermes see everything in my vault?

Only what its token allows. A Baalda MCP token is scoped to one user and one vault and respects per-file permissions, so the agent has exactly that user's access. For a tighter blast radius, mint the token against a service account or a vault holding only the folders you want the agent to reach.

Does this work if I self-host Baalda?

Yes. Point Hermes at your server's /api/mcp URL instead of localhost. Baalda is open source under Apache-2.0 and self-hostable, so an always-on Hermes can talk to a vault running entirely on your own infrastructure.