Hermes + Obsidian: The Agentic Second Brain Pattern
Avi Chawla published a list of the top Hermes integrations on June 5, 2026. The post hit 1,633 likes, 242 retweets, and 2,849 bookmarks - numbers that suggest developers are actively assembling their agent toolchains and looking for patterns that work. The #1 integration on the list was Obsidian, described as:
"The Karpathy-style second brain, but one that talks back. Every note, page, and backlink in the vault becomes live context. The agent doesn't just store knowledge, it reasons over it across everything that's been written and saved."
- Avi Chawla, June 5, 2026
The technical pattern behind this integration is straightforward but has implications for how agent memory should work. Here is what makes it tick and what builders are doing with it.
How It Works
Obsidian stores all notes as plain Markdown files in a local directory called a vault. There is no proprietary database, no API layer between the user and their data. Every note is a .md file on disk.
Hermes Agent already has filesystem access through its read_file, write_file, and search_files tools. Connecting the two requires one environment variable:
OBSIDIAN_VAULT_PATH=/home/user/vault
Set this in ~/.hermes/.env and Hermes can read, write, and search any note in the vault. No plugin, no MCP server, no REST API. The agent sees the vault as a directory of Markdown files and its existing tools handle the rest.
Alternatively, for users who want programmatic note creation including YAML frontmatter and backlinks, the Obsidian Local REST API plugin exposes localhost:27123 with full CRUD endpoints. Hermes accesses it through the same tool gateway.
Why This Matters for Agent Memory
Hermes Agent ships with a built-in memory system capped at 2,200 characters. That is enough for user preferences, frequent settings, and a few durable facts. It is not enough for detailed technical notes, work logs, design documents, or research summaries.
The Obsidian pattern separates memory into two tiers:
| Tier | Storage | Content |
|---|---|---|
| Agent Memory | ~/.hermes/memory/ | Preferences, settings, compact facts (2,200 char limit) |
| Shared Knowledge | Obsidian vault | Notes, logs, design docs, research (no practical limit) |
The agent reads its own memory for who you are and how you work. It reads the vault for what you know and what you are working on. Both human and agent can read and edit the same files, which eliminates the information asymmetry that builds up when only the agent can access its memory store.
Real Builds
Mete Polat described his daily-driver Hermes + Obsidian setup in a Substack post on May 20, 2026. He uses it across five domains:
Business idea capture. Voice notes sent via Telegram to Hermes. The agent transcribes, structures, enriches with competitive research, and files each idea as a formatted Obsidian note with metadata, tags, and an MVP scope section.
Content engine. Random thoughts during a dog walk become voice notes. Hermes transcribes, cleans, tags, and files them. It also reviews old ideas, marks posted ones with links, syncs Threads posts into a local archive, and compares published newsletters against local drafts.
Fitness coach. A dedicated Hermes profile generates weekly workouts based on injury history, goals, and preferences. After each workout, a voice report logs feedback and adjusts future plans. For travel or injuries, the agent modifies the program in real time - including a multi-agent "fitness council" that debates program changes.
Recipe management. Any source - link, screenshot, WhatsApp message, photo of a handwritten note - goes to the agent, which formats it uniformly into the vault.
Bill payment. Stripe Link for Agents gives Hermes a wallet with approval-gated temporary credentials. A photo of a bill triggers payment and receipt filing without exposing raw financial data.
In a separate build documented on Zenn, a Japanese developer runs Hermes Agent on a Raspberry Pi 5 with Ubuntu 24.04, using DeepSeek V4 Flash through OpenRouter. The total hardware cost is $35. The agent writes Obsidian notes directly to the filesystem, and a Flask-based web viewer makes them readable from any browser.
Cost
Running the full stack on a Pi 5 with OpenRouter:
| Component | Cost |
|---|---|
| Hardware (Raspberry Pi 5) | $35 (one-time) |
| API (DeepSeek V4 Flash, light use) | ~$2/month |
| API (DeepSeek V4, active dev) | ~$3-5/month |
| Obsidian Sync (optional) | $5/month |
| Total (monthly, light use) | $7/month |
For comparison, the MetEd setup - heavy daily use with Claude as the model, five active workflows, and Obsidian Sync - runs about $5/month for Obsidian plus API costs on top. Even at the high end, the entire stack costs less than a single ChatGPT Teams seat.
Why Local-First Wins
The pattern succeeds for one reason that has nothing to do with AI: Obsidian stores notes as plain Markdown files on disk. This means:
- The agent writes files the same way any other process would. No special API, no auth token, no rate limit.
- The human reads and edits those same files with Obsidian, VS Code, or any text editor.
- Backups are
rsync. Sync across devices is a file sync tool. Export is copy-paste. - If Hermes changes or the Obsidian integration breaks, the data is still plain Markdown. Nothing is locked in.
Contrast this with cloud-native note apps. The agent has to authenticate, respect rate limits, handle API versioning, and parse proprietary formats. The human cannot easily audit what the agent wrote without opening the app. The data lives in someone else's database.
Local-first Markdown sidesteps every one of these problems. The agent writes files. The human reads files. The filesystem is the API.
The Broader Pattern
The Obsidian integration topped a list of 12 integrations in Chawla's post, ahead of GitHub, Firecrawl, Google Workspace, Stripe, Discord, and others. The full list suggests developers are building agent toolchains that mirror their own workflows: notes for thinking, GitHub for shipping, Stripe for revenue, Discord for communication.
What distinguishes Obsidian is that it closes the loop. Other integrations are primarily output channels (the agent posts to Discord, queries Stripe, searches Firecrawl). Obsidian is a two-way knowledge surface - the agent reads what the human wrote, writes what it discovers, and both sides stay in sync over the same files.
When Akshay Pachaar published his Hermes Agent Masterclass in mid-May, it crossed 6,200 likes and 22,600 bookmarks. The core architecture he described - three-tier memory, self-evolving skills, isolated profiles - is what makes the Obsidian pattern work at scale. Each Hermes profile gets its own config, memory, skills, and SOUL.md. Point each one at a different vault folder and you have specialized agents with isolated knowledge bases, reading and writing the same Markdown files you do.
[^1]: Avi Chawla. "The top Hermes integrations." Daily Dose of Data Science. May 19, 2026. [^2]: Mete Polat. "#013: My Hermes & Obsidian Setup and Use Cases." Substack. May 20, 2026. [^3]: "Streamlining Note Management by Combining Hermes Agent with Obsidian." Zenn. 2026. [^4]: Akshay Pachaar. "Hermes Agent Masterclass." Daily Dose of Data Science. May 2026.