• 10 min read •By Tiago Marques

Hermes Agent + Obsidian: Crystallizing a Persistent Thinking Partner

A few months ago, I started using an AI agent called Hermes Agent in a way I had not tried before: not as a chatbot for one-off questions, but as a persistent thinking partner that remembers what we talk about across sessions.

The shift in the interface is tiny; the shift in the outcome is massive. A chatbot answers your question and forgets. An agent with memory builds shared understanding over time — and that changes what you can do with it.

Hermes is built by Nous Research, the lab behind the Hermes model series. The pitch is that it is the only agent with a native learning loop: it creates skills from experience, improves them during use, and persists knowledge across sessions. In practice, what that means is the agent builds a working model of who you are, not by reading a profile you filled out, but by remembering what you talk about and how you react.

The Problem: Context That Evaporates

Most personal growth insights are fleeting. You notice something about yourself: a pattern in how you respond to stress, a career decision that felt right at the time but looks different in hindsight, a creative block that keeps showing up in the same shape. And you tell yourself you’ll remember it. Then you don’t.

I have tried every system for capturing this: Obsidian vaults, journaling, periodic reviews. They all share the same failure mode: the capture is manual, and getting it back out is a chore. You have to remember to write it down, and then you have to remember where you wrote it.

The vault I settled on uses the PARA method (Projects, Areas, Resources, Archives): a structure designed for actionability, not just storage. 10 Projects/ holds active work with deadlines (a festival, a band album, a career goal). 20 Areas/ holds ongoing responsibilities without a finish line (music practice, professional development, personal reflections). 30 Resources/ holds reference material (repertoire, lesson notes, tech plans). 90 Archive/ holds completed or stalled work. This structure is the backbone of everything that follows.

The Shift: From Capture to Crystallization

To pair Hermes with Obsidian, I mapped the structure of my notes for Hermes, defined a formal protocol for how it should navigate my PARA folders, and encapsulated that logic into a persistent “skill.” Now, every time we start a session, Hermes doesn’t just respond—it updates its understanding of my evolving context.

I realized I no longer needed to carry the entire cognitive load of documenting and synthesizing my own growth. I could offload the crystallization to the agent itself.

Here is how it works in practice:

0. Initialize the protocol. Before beginning, I provided Hermes with a map of my vault and dictated the rules for the interaction into a custom skill. This is a one-time architectural investment: it creates the handshake between the agent and my files, allowing Hermes to autonomously read, index, and update my notes without further manual intervention.

1. Persistent memory across sessions. Hermes saves durable facts: preferences, environment details, project context, lessons learned. These get injected into every future conversation, saving me from having to re-establish context every time I open a chat.

2. Session search for past decisions. Every conversation is indexed and searchable. When I need to recall what we discussed about a specific topic or a past analysis, I can search across sessions. The agent returns not just the relevant messages, but the surrounding context: the goal of the session, the resolution, the decisions made.

3. Skills as reusable procedures. When I discover a workflow that works, I save it as a skill. A debugging procedure. A framework for analyzing team dynamics. A template for a recurring task. The next time something similar comes up, the agent loads the skill and follows the established approach.

4. Cron jobs for recurring analysis. I have set up scheduled tasks that run autonomously: checking on specific metrics, monitoring trends, running analyses at regular intervals. The agent executes them and delivers the results back to me.

The Next Layer: Vault-Native Context Recall

The built-in memory system works well for compact facts: preferences, stable truths, environment details. But it has a hard limit (~2,200 characters). For a growing Obsidian vault with hundreds of notes spanning months of project logs, career reflections, and technical analysis, that limit is reached quickly.

To actually make this work without blowing up a context window requires getting slightly deep into the plumbing. The solution was to add a retrieval layer between the agent and the vault.

flowchart LR A[Obsidian Vault] --> B[Talon] B --> C[Hybrid Search] C --> D[MCP Server] D --> E[Hermes Agent] subgraph C[Hybrid Search] direction TB C1[BM25 Keywords] C2[Dense Vectors] C3[Graph Signals] end

I installed Talon, an open-source Rust binary that indexes an Obsidian vault and serves it back as hybrid search with graph-aware ranking via a stateless MCP server. On every agent turn, Talon distills the prompt into search phrases, runs a hybrid search combining BM25 keyword matching with dense vector embeddings and graph signals, fuses the results, and injects a compact recall block into the agent’s context. The agent sees relevant vault content without reading files. The vault stays the source of truth; the retrieval layer handles the navigation.

The Career Strategy Lens

One skill worth singling out: I gave Hermes a dedicated lens for career strategy: a set of frameworks drawn from systems thinking, incentive theory, and organizational behaviour. The idea is simple: given a career situation, the agent can rotate through different perspectives on the same facts.

flowchart TD S[Career Situation] --> I[Incentives Lens] S --> P[Power Lens] S --> Sy[Systems Lens] I --> O1[What does this environment reward?] P --> O2[Where does influence actually sit?] Sy --> O3[What is this organization optimizing for?]

One pass reads it through incentives: what does this environment reward, and does that align with where I want to go? Another reads it through power: where does influence actually sit, and what does that mean for what I can accomplish here? Another reads it through systems: what is this organization optimizing for, whether it knows it or not, and how does that shape my options? The output is structured analysis: the same situation, seen through different lenses, with the contradictions between them often being the most useful part.

This lens applies to more than the current role. It works for evaluating a career move: what does the new path reward, and does that match what you want to build? It works for long-term goals: if you want to be in a certain position in five years, what does the path actually reward, and does that match what you are willing to do? The real value is not the generated output. It is the forced interaction with your own data.

When you run these lenses over a long enough timeline, they start revealing things you miss in the day-to-day: which problems are yours to solve and which are not, how to make a case land when being right isn’t enough, why a role that looked perfect on paper feels wrong six months in, how to evaluate a decision when the short-term cost and the long-term gain point in opposite directions. The value is having it brought up consistently across sessions until it sticks.

The lenses are especially sharp during a job hunt. Interviews are dense with signals: the questions they ask, the ones they dodge, the way the panel interacts with each other, the public reviews that all mention the same thing in different words. Individually, each data point is easy to dismiss. Fed into Hermes across multiple conversations, they start to form a picture. The agent does not tell you whether to take the offer. But it does tell you what you are looking at — which is more than most people get before signing.

The Strategy Layer: Turning Reflection into Action

To turn reflection into action without handing your internal monologue over to a product manager in Mountain View, you have to talk about architecture. My memory store and retrieval layer run entirely on my personal disk, and I keep my sensitive reflection notes strictly local. For heavy inference tasks, I offload to Ollama Cloud, which operates on a transient, no-retention basis. But the context itself never lives anywhere but my own hardware.

ChatGPT and Gemini are both adding memory now. I learned what that means the hard way. I asked Gemini for a translation for my band’s website, and a few conversations later it casually mentioned my upcoming trip to Scotland — something I had never told it directly, pieced together from context scattered across unrelated chats. The convenience is real, and so is the surveillance.

There is a gray area here that does not get talked about enough. When you reflect on a situation that involves other people, the data is personal but it is not only about you. Put that into a cloud chatbot and you are handing over information that traces back to other actors, often without their knowledge. The workplace is the most common version of this, and in many organizations it already violates AI usage policies. Even where it does not, the sane advice is the same: don’t do it. Most reflections only belong in your head. Some reflections belong on your own hardware. With Hermes, the platform sees inference requests, not a person.

I told Hermes early on that I wanted neutral, detached responses. No cheerleading, no validation. Over time, it stopped needing the reminder. It learned the tone from how I reacted, not from anything I put in a config file.

Here is what that looks like in practice. Once a month, I do a personal retrospective: a wheel of life across career, health, relationships, creative work. I write it in Obsidian. Hermes reads it through the career strategy lens. Over time, it has started connecting dots across months: a theme in how I describe my growth, a goal I keep mentioning but never acting on, a trajectory that only becomes visible when you lay six months side by side.

flowchart LR R[Reflect] --> E[Extract] --> A[Apply] --> R

Reflect. I write down where I am: what is working, what is not, what I am avoiding. The agent asks questions, offers frames, connects it to past retrospectives. The goal is clarity, not answers.

Extract. At the end of a session, I ask: what is the one thing worth carrying forward? Sometimes it is a principle, or just a question I need to sit with. Other times it is a raw next step. The agent helps me name it and save it.

Apply. The next time a similar situation arises, I have the crystallized insight ready. Not as a rule to follow blindly, but as a lens to see through.

What This Changes

The shifts above did not come from a single conversation. They accumulated over weeks, across sessions, with the agent returning to earlier points each time a new piece of the picture emerged. A chatbot would have given the same advice once and moved on. Hermes held the thread — it turns context into stable knowledge just by talking to it.

There is a deeper point here about what persistent memory actually does. When you document a reflection, you are creating a reference point that future conversations can connect to. Reading one monthly retrospective tells you how you felt on a Tuesday. Having an agent read six of them side by side, and the thing you have been actively avoiding for half a year gets harder to ignore. The memory turns sporadic observations into something you can act on.

The Risk I Am Watching For

I wrote earlier about AI Rumination, the dynamic where AI expands uncertainty instead of resolving it. Persistent memory amplifies both the benefits and the risks of this.

The upside is obvious: it connects dots across sessions you would otherwise miss. The trap is subtler. Because the agent trains on your own chat logs, it can quietly institutionalize your blind spots, feeding your own biases back to you disguised as objective analysis.

The mitigation is the same one I described in that post: anchor the conversation to decisions. Every session should produce a next step. Reflection is good, but rumination is a loop that will keep you stuck. The difference is whether you are moving toward closure.


This post was written in conversation with Hermes Agent, which also holds the persistent memory it describes.

Tiago Marques
Written by

Tiago Marques

Principal Data Analytics Engineer specializing in cloud data platforms, Databricks, Kimball dimensional modeling, and reliable BI architectures.