Hermes Agent Obsidian Integration Guide

If you are searching for a Hermes Agent Obsidian integration, the goal is usually simple: let Hermes work with your Markdown vault without turning Obsidian into another opaque agent database. The best setup keeps Obsidian as the human-readable source for project notes, daily logs, research, and review surfaces while Hermes keeps durable memory, skills, sessions, and credentials in their proper places.

When Obsidian is the right Hermes integration#

Use Obsidian with Hermes when your workflow depends on local Markdown, backlinks, long-running research, or a personal knowledge base that should stay inspectable outside the agent. It is especially useful when you already have project notes and want Hermes to reuse them before writing code, summarizing support threads, planning content, or preparing recurring operations.

Good fits include:

• Project notes that store repo paths, conventions, known blockers, and launch checklists.
• Daily notes that collect session summaries, decisions, and follow-up tasks.
• Research vaults where Hermes can search prior notes before opening the web.
• Review notes for memory, sessions, skills, and recurring mistakes.
• Local-first backups of agent context that should be readable without a hosted app.

Use the Hermes Agent + Obsidian integration page when you want the short product overview. Use the Hermes Obsidian plugin/tool page when you want the plugin-style feature summary. This guide is the practical operating model: what Hermes should read, what it should write, and where the boundaries belong.

Setup model: scoped vault access first#

Do not give an agent your entire vault on day one. Create a small folder structure that makes the boundary obvious:

Obsidian Vault/
  Hermes/
    Inbox/
    Projects/
    Daily/
    Research/
    Memory Review/
    Skill Notes/

Then tell Hermes the absolute vault path and the folders it may use. A good first prompt is:

Use my Obsidian vault at /Users/me/Obsidian Vault. For this session, only read and write files under Hermes/. Search Hermes/Projects before starting project work, write session summaries to Hermes/Daily, and never store secrets in notes.

If you use Hermes from a Docker or VPS environment, mount the vault path explicitly and keep it separate from ~/.hermes. The self-hosting guide explains the operational tradeoff: local vault access gives control, but always-on remote agents need volume mounts, backups, and permissions you have to maintain.

Workflow 1: search the vault before starting work#

The simplest Obsidian workflow is retrieval. Before a coding, research, or marketing task, ask Hermes to search a scoped vault folder for project context.

Example prompt:

Before editing the Hermes Agent website, search my Obsidian Hermes/Projects and Hermes/Research notes for anything about Obsidian integration, memory boundaries, or dashboard links. Summarize the relevant notes and cite the note filenames before proposing edits.

What good output looks like:

• Hermes lists the notes it searched.
• It separates facts found in notes from assumptions.
• It asks before using notes outside the scoped folder.
• It turns repeated steps into a skill only when the process is reusable.

This is different from durable memory. A note can be long, speculative, or historical. A durable memory should be compact and stable enough to shape future behavior. If a note says maybe try this later, it belongs in Obsidian. If a fact will still be useful next month, it may belong in Hermes persistent memory.

Workflow 2: create and edit project notes#

Hermes can create normal Markdown notes that Obsidian indexes immediately. Start with reader-facing notes rather than agent logs.

Example prompt:

Create Hermes/Projects/Obsidian integration.md in my vault. Include the goal, current site URLs, related pages, setup decisions, and a verification checklist. Add wikilinks to [[Hermes memory]], [[Skills]], and [[GitHub setup]].

A useful project note might include:

# Obsidian integration

## Goal
Make Hermes Agent work with local Obsidian notes without confusing vault notes, durable memory, and skills.

## Boundaries
- Vault notes: human-readable project context and research.
- Durable memory: stable user/project facts.
- Skills: repeatable procedures with commands and verification.
- Sessions: ephemeral transcript history unless summarized.

## Related
- [[Hermes memory]]
- [[Skills]]
- [[GitHub setup]]

After creation, ask Hermes to read the file back and summarize what changed. That read-after-write step catches path mistakes, malformed Markdown, and accidental writes outside the intended folder.

Workflow 3: daily notes without memory pollution#

Daily notes are a good place for summaries that should be searchable but not automatically treated as permanent agent memory. Ask Hermes to append a short structured summary after meaningful sessions:

Append a session summary to Hermes/Daily/2026-05-16.md with: objective, files changed, decisions, blockers, and next actions. Do not save any of this as durable memory unless I explicitly say it should affect future sessions.

This keeps the vault useful without teaching the agent stale facts. Durable memory should not contain every task result, commit hash, or temporary blocker. Obsidian can hold that history; Hermes memory should hold the stable preference or convention behind it.

Workflow 4: skills vs Obsidian notes#

A common mistake is using Obsidian notes as a substitute for Hermes skills. They solve different problems.

• Use Obsidian notes for explanations, research, meeting notes, drafts, and human review.
• Use skills for reusable procedures Hermes should load and follow automatically.
• Use durable memory for stable facts and preferences.
• Use session search when you need to recall what happened in a previous conversation.

For example, How I debugged GitHub Actions on this repo can start as an Obsidian note. Once it becomes a repeatable checklist with exact commands, promote it into a Hermes skill and link the vault note to that skill. The create Hermes skills guide covers the skill side; the vault can remain the narrative and review layer.

Workflow 5: connect Obsidian with GitHub work#

Obsidian becomes much more useful when Hermes can connect notes to code repositories. Pair the vault with the GitHub repository guide so project notes can point to branches, PRs, issues, CI failures, and release checklists.

Example prompt:

Search Hermes/Projects for the checkout flow note, inspect the linked GitHub repository, then update the note with current branch, failing tests, and the next safe verification command. Do not commit until the note and repo agree.

This creates a strong loop: Obsidian stores the human-readable project state, GitHub stores source history, and Hermes operates across both with explicit verification.

Workflow 6: use the dashboard for review#

The Hermes dashboard is useful when you want to watch sessions, inspect conversation history, or demonstrate workflows to teammates. Obsidian is better for durable note review and long-form context. Use them together:

• Dashboard: live session visibility, demos, recent conversations.
• Obsidian: curated notes, daily summaries, linked research, memory review.
• Hermes memory: compact facts and preferences that should affect future agent behavior.
• Skills: procedures the agent should execute consistently.

A practical review habit is to open the dashboard after a long run, ask Hermes to summarize only the durable parts into Obsidian, then decide whether any stable fact should become memory or any repeated workflow should become a skill.

Obsidian vs Notion for Hermes Agent#

Choose Obsidian when you want local Markdown, backlinks, offline access, and Git-friendly files. Choose the Hermes Notion integration when the knowledge base is collaborative, database-driven, or already owned by a team workspace.

A clean split is:

• Obsidian for personal operating notes, local research, private project memory, and skill review.
• Notion for shared team docs, public project plans, content calendars, and collaborative status pages.
• Hermes memory for stable facts that should shape future sessions regardless of which note system you open.

Do not duplicate everything into both systems. Pick one source of truth per workflow and link across only when there is a real handoff.

Create Hermes/Inbox/hermes-obsidian-smoke-test.md with a one-paragraph summary of what Obsidian should store for Hermes. Then read it back and tell me the absolute file path you changed.

FAQ#

Does Hermes Agent need an Obsidian plugin?#

Not always. The most reliable baseline is filesystem access to Markdown files in a scoped vault folder. A plugin-style integration can add convenience, but the core workflow is Hermes reading, creating, and editing normal Markdown notes that Obsidian already understands.

Should Obsidian replace Hermes memory?#

No. Obsidian should hold human-readable notes and history. Hermes memory should hold compact durable facts and preferences that should affect future agent behavior. Keep temporary project logs in Obsidian, not memory.

Can Hermes edit existing Obsidian notes?#

Yes, if the agent has file access to the vault path. For safety, start in a dedicated Hermes/ folder, ask for read-after-write verification, and use version control or vault backups before allowing broad edits.

Where should Hermes skills live?#

Skills should live in Hermes' skills directory so the agent can load them as procedures. Obsidian can store explanations, draft checklists, and review notes about skills, but the executable source of truth should be the actual SKILL.md files.

How do I connect this to GitHub work?#

Use Obsidian for project context and the GitHub integration for repository actions. Ask Hermes to read the project note first, inspect the repository second, then update the note with decisions and verification results after the work is done.