Home / Articles

Hermes and Obsidian: A Three-Agent Knowledge Vault with Human Review

Set up an orchestrator, researcher and librarian in Hermes that move notes from Bronze to Silver to Gold in an Obsidian vault, with Docker isolation and review.

Publisher: REACTAPP.TOP7 min read1543 words

This article is published in English.

Sources: Built Multiples Agents to Research, Think and Remember on Its Own with Hermes + Obsidian

An autonomous knowledge system can be assembled from Hermes, Obsidian and three cooperating agent roles: an orchestrator, a researcher and a librarian. Each role has a narrow job, and a folder structure keeps unreviewed material away from trusted notes.

The pieces

Hermes is a self-improving agent from Nous Research. It learns by doing, looping over its own work to add context and knowledge. It also ships with many features that would be painful to configure in Openclaw, which makes it the more dependable option of the two.

Obsidian is a note app for free-form writing whose strength is linking notes together. The result resembles a graph in which ideas in one note connect to ideas in another.

Docker controls what an agent may touch. Hermes can run its backend inside a container, so mounted folders can be given read-only or read-write rights individually.

How this differs from RAG

There's no chunking, embedding, similarity search or vector store anywhere in this design, so it isn't a RAG pipeline. The goal is a set of autonomous agents that handle their own jobs and talk to one another. The librarian has the hardest task, because it separates reliable knowledge from junk and pulls a human in when a decision needs one.

Agents move through a structured vault by name, link and folder. A write policy governs the flow: Raw, then Review, then Wiki. That amounts to an ETL pipeline for knowledge, moving content from a Bronze layer to Silver and then Gold, which makes it reliable to curate material and tell good from sloppy.

The orchestrator

The orchestrator is the main agent. Its work is simple: take an instruction and pass it to the right teammate. Its SOUL.md defines the role:

# Orchestrator

**Role:** Orchestrator
**Mission:** Coordinates my agent team. Clarifies the outcome and acceptance criteria,
> delegates bounded research to @researcher, reviews returned work for relevance, completeness, inspectable citations, uncertainty, and unresolved  gaps, and requests one focused revision when necessary. Hands accepted work to @librarian, but never authorizes durable writes without my approval.
> Can retrieve & retain to Hindsight, alongside a built-in memory.md & user.md for always-on context (which is minimal)

You are Orchestrator, a persistent named agent (profile `orchestrator`) on this machine.
You keep your own memory, skills, and conversation history across sessions.

## Team protocol

- Begin by stating the Outcome, Acceptance criteria, Owner, Deliverable, and
  Stop condition.
- Delegate research to @researcher rather than doing the specialist's work.
- Review the return for scope and evidence adequacy; do not claim to have
  independently verified facts you did not inspect.
- If the return is inadequate, request one focused revision. If it is
  adequate, stop for the user's approval before involving @librarian.
- Do not write to the Wiki. Update your built-in memory.md  & user.md when applicable to assist with operational efficiency & effectiveness

Default skills and tools should be switched off. An agent that isn't running unneeded ones is faster:

List Disabled Skills:
llm-wiki
determinstic-codebase-auditing

List Disabled Tools:
Web Searching & Scraping
Task Delegation
Browser Automation

Setting the backend to Docker isolates the workspace, so the agent can't alter or delete private data on the host. That's a worthwhile security boundary between the agent and the machine.

The researcher

The researcher accepts jobs from the orchestrator and does the deep investigation. It never edits the wiki or the knowledge base, because research and summarizing are its only duties. Search tools can be added so it can look things up on the internet. Its SOUL.md:

# Researcher

**Role:** Researcher
**Mission:** Investigates bounded current-reality questions using current and original sources. Produces concise, inspectably cited briefings with uncertainty, counterevidence, and unresolved gaps, then returns them to @orchestrator for quality review. Does not write to the wiki.

You are Researcher, a persistent named agent (profile `researcher`) on this machine.
You keep your own memory, skills, and conversation history across sessions.

## Research protocol

- Research bounded questions about current real-world conditions using recent evidence and the most direct or original sources available.
- Provide inspectable citations and distinguish evidence, inference, uncertainty, counterevidence, and unresolved gaps.
- Save each completed briefing as a Markdown file under `/workspace/article`, using a clear descriptive filename.
- Include the research question, date, summary, findings, source links, uncertainty, counterevidence, and unresolved gaps.
- Return the briefing and its file path to @orchestrator for review.
- Do not hand work directly to @librarian unless the user explicitly requests it.
- Treat the Markdown file as a working research artifact-not private memory or canonical Wiki knowledge.
- Write only wiki inside /workspace/article

The same trimming of default skills and tools applies here:

List Disabled Skills:
llm-wiki
determinstic-codebase-auditing

List Disabled Tools:
Task Delegation
Code Execution
Cronjob

It also runs on a Docker backend for the same isolation, and its config mounts the vault location into the container workspace:

terminal:
  backend: docker
  modal_mode: auto
  cwd: /workspace/article
  timeout: 180
  env_passthrough: []
  shell_init_files: []
  auto_source_bashrc: true
  docker_image: nikolaik/python-nodejs:python3.11-nodejs20
  docker_forward_env: []
  singularity_image: docker://nikolaik/python-nodejs:python3.11-nodejs20
  modal_image: nikolaik/python-nodejs:python3.11-nodejs20
  daytona_image: nikolaik/python-nodejs:python3.11-nodejs20
  container_cpu: 1
  container_memory: 5120
  container_disk: 51200
  container_persistent: true
  docker_volumes:
    - /Users/dmitri/Documents/ai-agent-workflow/obsidian/ai-agent/wiki-skill/raw/articles:/workspace/article

The librarian

This is the key agent, since it writes to the wiki and curates what goes in. Knowledge moves through the Bronze, Silver and Gold stages, and Silver is where a person can review the table.

New material is ingested into vault/raw. Anything needing a human check lands in vault/review. Human review happens in three situations:

  1. A page is being created or updated.
  2. New content contradicts an existing page.
  3. An earlier approval is being reapplied to change content.

Everything ends up in the Gold layer, which holds detailed pages such as concepts and entities. Curation means keeping what a reviewer has approved and discarding what they haven't.

The librarian's SOUL.md:

# Librarian

**Role:** librarian

You are Librarian, a persistent named agent (profile `librarian`) on this machine.
You keep your own memory, skills, and conversation history across sessions.

Two skills enable the ETL, llm-wiki and llm-wiki-review, and both go in the librarian's skills folder.

The librarian also needs a Docker backend, with its profile in config.yaml updated like this:

terminal:
  backend: docker
  modal_mode: auto
  cwd: /workspace
  timeout: 180
  env_passthrough: []
  shell_init_files: []
  auto_source_bashrc: true
  docker_image: nikolaik/python-nodejs:python3.11-nodejs20
  docker_forward_env:
    - OBSIDIAN_VAULT_PATH
    - WIKI_PATH
  singularity_image: docker://nikolaik/python-nodejs:python3.11-nodejs20
  modal_image: nikolaik/python-nodejs:python3.11-nodejs20
  daytona_image: nikolaik/python-nodejs:python3.11-nodejs20
  container_cpu: 1
  container_memory: 5120
  container_disk: 51200
  container_persistent: true
  docker_volumes:
    - /Users/dmitri/Documents/ai-agent-workflow/obsidian/ai-agent/wiki-skill:/workspace
    - /Users/dmitri/Documents/ai-agent-workflow/obsidian/ai-agent/RO:/workspace/RO:ro

In the example setup the Obsidian vault folder holds two subfolders, one for the wiki skill and one for a workspace. The wiki-skill folder mounts at /workspace in the container, and a read-only folder mounts at /workspace/RO. Access is set per mount with a :ro or :rw suffix. A path like /workspace/RO:ro is read-only, and one with no suffix, like /workspace, defaults to read and write.

Environment variables work differently once the agent is containerized. It can't read the host's .env file directly, so they're passed in through the docker_forward_env parameter in the librarian profile:

.env:
WIKI_PATH=/workspace
OBSIDIAN_VAULT_PATH=/workspace

The three layers in practice

A raw Bronze note:

A Silver review page:

The Gold index page:

And a Gold comparisons page:

Those four screenshots show the layers the librarian maintains. With them in place, an integration test comes next: ask the orchestrator to coordinate the other agents, ingest new knowledge and curate it.

Running it end to end

The first step is creating the bot group in the Hermes desktop app, containing the orchestrator, the librarian (with the wiki skills) and the researcher.

Then give the orchestrator an ingestion request:

@orchestrator get new article related to AGI and ASI, then store it to article, then run wiki skill

The orchestrator has the researcher collect material and store it in the vault. The librarian then picks up that Bronze content and promotes it to Silver.

After approval, the knowledge moves to Gold, specifically the vault's concepts, comparisons, entities and query folders.

The raw Bronze page ends up archived in the raw folder. The librarian never reads or ingests it again, since its header level and ingestion status have changed.

Why it isn't RAG

RAG is a one-way read path. Text is split, embedded and matched by similarity, the best hits are pasted into a prompt, and a model writes an answer. Which passages come back is a matter of probability, the corpus stays a passive index, and nothing flows back into it.

The setup above works the opposite way. Agents navigate a structured vault by name, link and folder, and they fetch what they need, when they need it, deterministically. Knowledge moves along a policy boundary of Bronze (Raw), Silver (Review) and Gold (Wiki), and that movement belongs to no RAG process.