AI assistants can remember a surprising amount during a conversation. The problem is what happens next week, after a new session, a model change or a switch from one assistant to another.

I use Hermes Agent, Claude Code and Codex for different kinds of work. I wanted them to share the important context without depending on one provider’s private chat history. My solution was not a complicated vector database or a custom memory server. It was an Obsidian vault built from ordinary Markdown files.

The important part is not installing Obsidian. It is deciding what the vault is for and teaching every assistant to use it consistently.

The role of the vault

My Obsidian vault is the durable, human-readable record for:

It is deliberately model-agnostic. If I stop using one AI provider tomorrow, the knowledge remains readable in folders I control.

What the vault is not

Obsidian is not my source-code repository. It is not a replacement for project documentation, and it is definitely not a secrets manager.

I do not use it for:

A useful note says, “We chose this approach because…” and links to the relevant project. It does not paste five pages of code or expose a credential.

My search-first rule

The biggest risk with AI-written notes is duplication. Every assistant is happy to create a fresh summary, and soon the vault contains five slightly different accounts of the same project.

My operating rule is:

  1. Search the vault for the topic.
  2. Update the most authoritative existing note.
  3. Update the relevant index if the project’s direction or status changed.
  4. Add one dated conversation note for a substantial discussion.
  5. Create a new topical note only when no suitable home exists.

This makes curation more important than note generation.

The three layers I keep separate

1. Project repositories

The repository remains authoritative for code, tests, build instructions, release assets and technical detail.

2. Operations documentation

My private operations wiki holds practical runbooks: where things live, how services start, how to verify them and how a family member could recover them.

3. Obsidian

Obsidian holds durable narrative context: what changed, what was decided, why it matters and where the authoritative material lives.

Keeping these layers separate stops the vault becoming an unmaintainable copy of everything on the computer.

How I make different AIs follow the same process

At the root of my workspace I keep shared instruction files such as:

The shared rules tell each agent to:

Hermes also has its own persistent memory, but I treat that as a compact convenience layer. Stable user preferences can live there. The richer project and system history belongs in inspectable files.

A practical capture example

Suppose an AI repairs an automated website publisher after an FTPS server repeatedly disconnects.

The source repository should contain:

The Obsidian project note might record:

The dated conversation note might briefly record why the change was made and the verified outcome. It should not copy every error line.

Why this works better than AI memory alone

It survives model changes

Claude, Codex, Hermes and future tools can all read Markdown.

I can inspect and correct it

There is no mystery about what the AI “remembers.” I can open the note, edit a mistake and see the links.

It supports handover

A new agent—or another human—can start from the project index rather than reconstructing months of chat history.

It makes disagreement visible

If a repository says one thing and an old note says another, the conflict can be found and corrected. Hidden conversational memory is much harder to audit.

The failure modes

AI note spam

If every session creates a new summary, the vault becomes less useful, not more. Search first and update in place.

Confusing sync with backup

A synced deletion can propagate perfectly to every device. I keep versioned snapshots and at least one recovery copy outside normal agent deletion authority.

Multiple agents editing the same index

Concurrent edits can overwrite or duplicate entries. Agents should re-read a note immediately before and after patching it, make narrow changes and avoid broad reorganisations while other writers are active.

Storing too much operational detail

An Obsidian vault full of deployment commands and volatile service state becomes stale quickly. Link to the runbook instead.

Accidentally storing secrets

A shared human-and-agent knowledge base is the wrong place for credentials. Store only the fact that a recovery path exists and where the approved secret manager is—not the secret itself.

A simple folder pattern

There is no single correct vault layout, but mine uses:

The precise numbers and folder names matter less than having obvious authoritative homes.

My completion rule for AI-assisted work

At the end of meaningful work, the agent should ask internally:

  1. Did we create a durable decision, preference or warning?
  2. Did a project’s direction or status materially change?
  3. Would this context save time in a future session?
  4. Does an existing note already cover it?
  5. Is the repository or operations wiki a better home?

If the answer warrants capture, update the vault. If not, leave it alone.

Why I still use this system

Obsidian did not make my AIs magically share one brain. It gave them something more practical: a common, inspectable notebook with rules about what belongs there.

The value comes from restraint. Search first. Preserve authoritative sources. Summarise decisions, not transcripts. Keep secrets elsewhere. Done properly, a Markdown vault becomes a reliable memory layer that is independent of whichever AI happens to be running today.