Claude Code gains persistent memory across sessions via an Obsidian vault

What happened

A developer publishing under the name seestack on dev.to has released an open-source project, claude-obsidian-memory, that gives Claude Code a persistent memory layer built on top of an Obsidian vault. According to the dev.to post, the goal is straightforward: Claude Code sessions typically start cold, without the background from earlier work, and the project is an attempt to fix that by storing the working context in a place the agent can read back later.

The author published the code in a public GitHub repository and recorded a full walkthrough video that covers both the initial setup and a live session-recovery test, in which a fresh session picks up where a previous one stopped.

How the system works

The setup uses an Obsidian vault as the memory store. According to the post, the vault holds several categories of material: journal entries that record what happened in past sessions, a list of unfinished tasks, commands that have proven useful, and skills and scripts accumulated along the way.

When a new session begins, Claude Code can search the vault, locate the files relevant to the current work, reconstruct the earlier context from them, and continue the task rather than starting from scratch. The author describes the result as session recovery: the agent effectively rehydrates its own working state from notes it wrote or that were written for it.

Because the substrate is Obsidian, the memory lives as ordinary notes in a vault rather than in an opaque database. That has a practical side effect: the same material is readable and editable by the human using a standard note-taking tool, and the vault can hold other knowledge alongside the agent-specific entries. The author does not claim the system is finished or universal — the post closes by asking how other developers are handling persistent context, framing the project as one answer to an open problem.

The problem it targets

Context loss between sessions is one of the recurring frustrations with agentic coding tools. A long session builds up shared understanding — which approach was tried, what broke, what remains undone — and that understanding evaporates when the session ends. Users typically compensate with hand-written summary files, such as the CLAUDE.md convention, or by re-explaining the project each time.

This project takes that compensation and structures it. Instead of a single static instructions file, the vault acts as a running record with distinct sections for history, outstanding work and reusable commands. The session-recovery test in the walkthrough video is the key demonstration: it shows a fresh Claude Code instance finding the relevant notes and resuming an interrupted task without the developer re-supplying the background.

Why it matters

The project is small in scope but sits on a live fault line in AI tooling. As coding agents take on multi-session, multi-day work, the ability to carry context forward is becoming a first-class requirement rather than a nice-to-have, and vendors and users are experimenting with memory layers of many kinds. An approach built on plain Markdown notes in an Obsidian vault is notable for its transparency: the memory is inspectable, portable and editable by the person supervising the agent, not locked inside a vendor's storage format.

For teams already running Obsidian, the barrier to trying it is low, and the structure — journals, task lists, command references — is a template others could adapt to different agents. The author's closing question suggests the real intent: to start a conversation about persistent context, with working code attached. Anyone who has watched an agent rediscover the same bug three sessions in a row will recognise the pain it aims at.