Hermes Agent + Obsidian: A Second Brain That Truly Thinks

Many when building a "Second Brain" eventually face an awkward dilemma: as notes accumulate and organizational structures become more beautiful, they still have to explain the context to the AI from scratch when it's time to actually execute a task. This article will share how to turn your accumulated static notes into executable assets that an AI can actively call upon, using the combination of Hermes Agent + Obsidian, achieving a truly thinking, closed-loop Second Brain.

Over the past two years, the concept of a Second Brain has been widely popularized. Whether it's Notion templates, Obsidian graph views, the PARA framework, MOCs (Maps of Content), or slipboxes, these tools and methodologies look incredibly complete. However, in practice, we often encounter a problem: you write a massive number of notes, organize countless files, and even build a bunch of beautiful backlinks, but when it's time to actually get to work, they still sit quietly in your vault.

The disconnect between static notes and executive actions

These notes are essentially dead files.

Dead files doesn't mean the files have no value, but rather that the AI Agent cannot directly use them, cannot use them as context, cannot compare them with other files, and cannot actively call them in the next task. To the Agent, these files might as well not exist.

Traditional Second Brain tutorials are essentially "training humans": you must know exactly where every file is stored, remember when to reference which note, regularly clean up tags and maintain folder structures, and actively look through them when writing or doing research. This high-intensity organizing is useful for a tiny fraction of highly disciplined people, but for most, it eventually becomes just "Bookmarks 2.0".

To solve this problem, we need to transform the Markdown notes in Obsidian into living files that Hermes Agent can continuously read and write, allowing accumulated materials to truly enter the execution pipeline.

Obsidian's core advantage lies in its "dumbness"—it is essentially just local Markdown files. This means:

• Humans can understand them, and Agents can too.
• Humans can modify them directly, and Agents can read and write to them directly.
• Data won't be locked away in complex black-box databases, making it perfect for storing context that humans need to maintain long-term and Agents need to read (such as project judgments, user research, long-term preferences, etc.).

To turn Obsidian from a "repository" into a "console," we don't need to build complex graphs right from the start. Instead, we can first set up a simple and practical entry page: the One Dashboard Home Page.

One Dashboard Concept in Obsidian

This dashboard retains only the four most core entries:

00_Inbox / Inbox Dashboard: New Information Entry
01_Daily Log / README: Record daily inputs, judgments, and actions
05_Decisions / Decision Dashboard: Place problems requiring trade-offs
06_Actions / All Tasks: Place things that actually need to be pushed forward

This structure transforms chaotic notes into clearly layered workspaces. When Hermes Agent reads these Markdowns, it doesn't get cluttered text, but structured context. This model brings three significant advantages:

1. Process is fully visible: You can intuitively see which configurations, skills, and memories the Agent is using. When information is outdated or incorrect, you can easily spot it.
2. Minimalist editing and feedback: If a workflow isn't performing well, you don't need to modify complex code or configurations; you just edit the corresponding Markdown file directly. The Agent will automatically apply the new version the next time it reads it.
3. Natural connectivity: Obsidian's backlinks and folders aren't just for human visual appeal. When reading, the Agent can follow the links to understand the relationships between SOPs, projects, retrospectives, and long-term preferences, which is much more stable than stuffing massive amounts of information into a single prompt.

In the entire system, Obsidian is responsible for storing context that humans can understand, while Hermes Agent acts as the execution layer.

Hermes Agent can not only read, write, and search files, but also call tools, run commands, remember preferences, and solidify skills. It can also integrate into long-term workflows through Cron tasks, Gateways, and Sub-agents.

A typical closed-loop workflow is as follows:

1. Obsidian stores the context (input).
2. Hermes Agent reads the context and executes the task (execution).
3. Hermes Agent writes the new experience generated by the task back to Obsidian (output/solidification).

You can design the following directory structure to support this closed loop:

/Second Brain
  /Projects
    customer-research.md
    competitor-tracking.md
    saas-ideas.md
  /SOP
    validate-saas-idea.md
    analyze-user-feedback.md
    weekly-market-scan.md
  /Memory
    preferences.md
    rejected-directions.md
    pricing-lessons.md
  /Skills
    customer-interview-analysis.md
    landing-page-teardown.md

When executing tasks, you no longer need to explain the background to the AI every time. You just need to issue direct instructions:

"Read the notes in my Obsidian vault related to customer-research, competitor-tracking, and pricing-lessons, help me evaluate this vertical SaaS opportunity, and append this new finding to pricing-lessons.md."

When connecting to AI, a common mistake is trying to make the Agent read the entire Obsidian vault into memory. While this seems convenient, it is actually highly dangerous. It causes the context window to expand rapidly, wastes a large amount of tokens, and old information can easily pollute new tasks, causing the Agent to get lost in irrelevant notes.

A more robust design is to adopt a two-layer memory structure:

• First Layer: Minimal Core Memory Stores your persona, preferred reply styles, long-term disliked directions, etc. In Hermes Agent, this usually corresponds to SOUL.md or profile memory.
• Second Layer: On-demand Loaded Notes / Skills / SOPs These are loaded selectively only when relevant to the current task. For example:
  • When researching SaaS opportunities: Only read industry judgments, exclusions, and historically validated demand signals.
  • When organizing user interviews: Only read user personas, raw interviews, and willingness-to-pay records.

Prepare the following three most basic types of files in Obsidian:

1. Long-term Preferences: Memory/preferences.md
2. Specific Projects: Projects/customer-research.md
3. Reusable Processes: SOP/analyze-user-feedback.md

Verify if your Obsidian has successfully entered the Agent's execution loop through the following three steps:

1. Read and Summarize:

   "Please read Memory/preferences.md and Projects/customer-research.md in my Obsidian vault, and summarize the 10 most important rules I should follow when evaluating vertical SaaS opportunities."

2. Incremental Write:

   "Append the demand judgment rules summarized this time to SOP/analyze-user-feedback.md. Keep the original text and do not overwrite old content."

3. Closed-loop Task:

   "Based on SOP/analyze-user-feedback.md and Projects/customer-research.md, help me organize this batch of user interviews, determine which pain points are worth turning into SaaS products, and finally append the newly learned judgment experiences back to Projects/customer-research.md."

If your Obsidian only exists on your local computer, the execution of the Agent will be physically limited.

Keep your local device synchronized with a cloud VPS using Obsidian Sync or other synchronization methods (like Git, Syncthing). Deploy Hermes Agent on the VPS, combine it with Cron Jobs, and you can achieve automated operations:

• Every Morning: Automatically read the previous day's user feedback and update customer-research.md.
• Every Afternoon: Automatically scan competitors' pricing pages and update competitor-tracking.md.
• Every Weekend: Automatically extract payment signals and excluded directions, and update pricing-lessons.md.

At this stage, Obsidian is no longer just a note-taking tool; it has become a long-term workbench where you and the AI Agent collaborate.

Taking the evaluation of a new SaaS product direction as an example, we can establish the following file structure:

Projects/saas-idea/customer-pain.md
Projects/saas-idea/competitors.md
Projects/saas-idea/pricing-signals.md
Projects/saas-idea/rejected-assumptions.md
SOP/validate-saas-idea.md
SOP/analyze-user-feedback.md

In practice, Hermes Agent will continuously write back the following dynamic information to these files:

• Which user pain points are repeatedly appearing?
• Which demands seem booming on the surface, but users are actually unwilling to pay for?
• Which competitors are only stacking features, and which channels already have people buying traffic?
• Which assumptions were overturned by new evidence, and which judgments need to be documented to avoid repeating past mistakes?

These dynamically updated contents are the true living files. With them, you don't need to retrain the AI every time you start a new conversation; the Agent will become smarter and smarter as your notes iterate.

• A radical shift in context ownership: Traditional AI interactions leave the context in chat histories (temporary flows), requiring re-explanation with every new conversation. Hermes Agent + Obsidian extracts the context and places it back into a Markdown file system (assets) that both humans and Agents can read and write to, allowing experiences to be reused across tasks.
• Say no to full loading: Do not let the Agent blindly read the entire knowledge base. Adopt a two-layer structure of "core memory + on-demand loading" to ensure task accuracy and save tokens.
• Keep it minimalist, prioritize the closed loop: Don't start by building a massive life-long Second Brain right away. Start with a specific workflow (such as writing, competitor research, or operations), run through the closed loop of "reading notes -> executing tasks -> writing back experience," and then gradually expand to synchronization, VPS, and multi-agent collaboration.
• The Second Brain "grows": A true Second Brain is not built through exquisite typesetting and classification, but grows naturally when it actually starts participating in your next judgment and execution.