TL;DR

obsidian-wiki (Ar9av/obsidian-wiki) turns Andrej Karpathy’s “LLM Wiki” idea into something you can install. The idea: an AI agent writes what you learn into linked markdown pages once and keeps them current. You do not ask a model the same question again, and you do not search raw files every time. The product is mostly 39 markdown skills (/wiki-ingest, /wiki-query, /wiki-lint and others). Claude Code, Codex, Cursor, Gemini CLI, OpenClaw, Hermes, Pi and about ten more agents can read and run them. Around the skills sits an optional Python package: a CLI, a lock-protected memory writer, a local web viewer and an MCP server.

Facts as of November 20, 2026:

  • 3,789 GitHub stars, 376 forks, created April 6, 2026
  • MIT license
  • Latest release v2026.11.7 (November 19, 2026). The repository lists 50 GitHub releases since v2026.07.4 on July 11, 2026, and it uses CalVer tags.
  • 5 open issues; 39 contributors with GitHub accounts
  • On PyPI as obsidian-wiki. It needs Python 3.9 or later, and 3.10 or later for the [server] extra (web viewer, MCP, self-hosting).

Not run by us: our hands-on lab (a throwaway GitHub Actions container) could not start on November 20, 2026, because GitHub refused the job over a billing limit on the account. Everything below comes from the repository, its docs, the release notes and PyPI. We did not install obsidian-wiki, build a vault or run its benchmark, so every speed and accuracy figure here is the project’s own.

Our verdict: obsidian-wiki is the most complete open-source take on the LLM Wiki pattern we have read. Its best decision is also its most limiting one: there is no LLM, no embedding model and no vector store inside it. That keeps your memory as plain markdown that you can read, grep and fix by hand. It also means search is lexical, and how good the vault gets depends on the agent you point at it. Choose it if you already work in Claude Code or Codex every day and want your findings to outlast one chat. Choose a vector memory layer if you need “find what I meant” search over text you never organised.

What problem it solves

The README opens with a familiar story. You fix a hard bug on a Tuesday. Three months later, in another repo, you fix it again from scratch, because the answer lived in a chat log you will never find.

Agent memory products deal with this in two common ways. Vector memory layers (Mem0, Cognee, Hindsight) store embeddings and let an LLM decide what to keep. Transcript recorders (such as Claude-Mem) save sessions and replay a summary. obsidian-wiki takes the third path, from Karpathy’s LLM Wiki gist. The agent compiles knowledge into pages. New information merges into the page it belongs on, contradictions get flagged, and the result is a normal Obsidian vault with [[wikilinks]].

The README also says what it is not: not a transcript recorder, not a sync service, and “not an oracle”.

How it works: skills, not a runtime

The architecture doc puts it in one line: “The wiki is the artifact. The agent is the maintainer. Obsidian is the viewer.”

No pipeline process runs your knowledge base. Each skill is a SKILL.md file with instructions. Your agent reads the instructions and does the work with the read, write and search tools it already has. obsidian-wiki setup symlinks one skills/ directory into each agent’s skill folder (~/.claude/skills/, ~/.codex/skills/, ~/.openclaw/skills/ and so on). When you upgrade the package, every agent gets the new skills.

The ingest process has four stages:

  1. Ingest: the agent reads the source directly. That can be markdown, PDFs in page ranges, chat exports, transcripts, or images (which need a vision model).
  2. Pull information: concepts, entities, claims, decisions and open questions. Each page gets a 1–2 sentence summary: in its frontmatter.
  3. Merge: if a page exists, it is updated and contradictions are noted. If not, a new page is created.
  4. Schema: categories and the index grow with the sources instead of being fixed at the start.

A .manifest.json records every source that has been ingested, so the next run processes only the delta. The architecture doc also lists what is skipped: audio, video, archives and binaries. Office files are “only as good as your agent’s ability to read them”.

Two features make the vault easier to trust than most LLM-written notes:

  • Provenance tags. Every claim is extracted (the default), ^[inferred] or ^[ambiguous]. A provenance: block summarises the mix per page, and wiki-lint flags pages that drift into mostly speculation.
  • Staged writes. Set WIKI_STAGED_WRITES=true and pages the LLM wrote wait in _staging/ until you promote them with /wiki-stage-commit.

Install and first commands

The README’s 60-second path:

pip install obsidian-wiki
obsidian-wiki setup --vault ~/brain

setup writes the global config to ~/.config/obsidian-wiki/config. It installs the skills into every agent it finds and registers two Claude Code hooks: a SessionStart recap that injects who you are and what is open, and a Stop capture that suggests saving anything reusable. Pass --no-hooks to skip the hooks, or --vault-only to create only the vault and the config.

uv tool install obsidian-wiki and pipx install obsidian-wiki also work. The installation doc warns against uvx obsidian-wiki setup. uvx runs in a throwaway environment, and setup symlinks skills into the installed package, so every skill link would point at a deleted path. If you must use uvx, add --copy.

Claude Code users who do not want Python can install the skills as a plugin:

/plugin marketplace add Ar9av/obsidian-wiki
/plugin install obsidian-wiki@obsidian-wiki

The plugin ships the skills only. It does not include the hooks or the CLI, and its commands are namespaced (/obsidian-wiki:wiki-ingest).

After that, the docs say you only need three skills:

/wiki-setup                                  # once
/wiki-capture                                # save what this session worked out
/wiki-query what do I know about rate limiting?

The other skills are there when you need them:

/wiki-ingest ~/research              # docs, PDFs, chat exports, URLs
/wiki-update                         # distil the repo you are standing in
/wiki-history-ingest claude          # mine your past Claude Code sessions
/wiki-lint                           # broken links, orphans, contradictions
/wiki-dedup                          # merge "RSC" and "React Server Components"
/cross-linker                        # link unlinked mentions
/wiki-digest week                    # what did I learn this week?

Codex uses $ instead of / ($wiki-ingest). The agent compatibility table lists 17 agents with their bootstrap file and skills directory.

The Python API: memory without an LLM

The second way in is a library. This is the part to read if you build your own agents:

from obsidian_wiki import Memory

memory = Memory("~/brain", create=True)

memory.remember("stack", "Python, FastAPI", confidence=0.9)        # about the person
memory.add("Postgres was chosen over MySQL for partial indexes.")  # knowledge
memory.todo("Benchmark the partial index on the orders table")     # open thread
memory.search("postgres")
memory.recap()                                                     # at session start

The Python API doc explains why there are three verbs instead of one add(). Vector memory layers run an LLM inside add() to decide what to keep and where. This package has no LLM, and the caller already has one, so the caller makes the routing decision:

CallStoresLives in
add(content)Knowledge, something that is true<category>/<slug>.md
remember(key, value)A durable fact about the person_meta/profile.md
todo(text)A thread to pick up next time_meta/todos.md

The doc is just as clear about the cost. Search is lexical. In its own example, searching “database choice” will not find a page that only says “Postgres” and “MySQL”. It tells you to give pages tags= and a summary= that use the words you will search for later. Open threads untouched for 30 days are flagged as stale, and nothing closes them for you. confidence is your own estimate, and the doc suggests you do not write facts below 0.5.

There is an optional semantic layer. The configuration doc describes QMD collections for semantic search, but they are a separate install, not part of the default.

Memory files and the lock

Five files carry what the vault remembers between sessions: index.md, log.md, hot.md, _meta/profile.md and _meta/todos.md. The memory doc admits that about fifteen skills used to rewrite them with no lock, so parallel writers silently lost updates. Now one code path writes all five, under an advisory lock, atomically:

obsidian-wiki memory sync INGEST source="papers/attention.pdf" pages_created=3

The 500-word cap on the hot cache is enforced in code (OBSIDIAN_HOT_MAX_WORDS); the hand-written ## Key Takeaways section is cut last.

Web viewer, MCP and self-hosting

pip install 'obsidian-wiki[server]' adds three things:

  • obsidian-wiki ui: a local viewer on 127.0.0.1:3114 with search, rendered pages and backlinks, the graph, an Inbox that drops files into _raw/, Insights (hubs, bridges, blind spots), one-click skill runs and Ask. Ask answers questions from your pages with citations. It runs on your Claude subscription through Claude Code, or on an Anthropic API key. The README says the relevant excerpts, and any web search queries, go to the model. Web search is on by default and can be switched off.
  • obsidian-wiki mcp: the memory tools over stdio for any MCP client. There are eight tools: memory_search, memory_read, memory_write, memory_context_pack, memory_recap, memory_profile, memory_todo and memory_sync.
  • obsidian-wiki serve: self-hosting with a REST API, MCP over HTTP and the viewer. It needs WIKI_API_KEY, binds to loopback unless you pass --host, supports a read-only key (which sees only the four read tools), two-way git sync and, since v2026.11.7, OAuth 2.1 sign-in with rate limiting and lockout. Docker, Fly.io, Render and Railway templates are included.

The viewer’s agent jobs run claude -p in the vault with --permission-mode acceptEdits and a file-tool allowlist, a reason to turn on staged writes before ingesting untrusted content.

The benchmark, read carefully

The README includes a small study: the same model (Claude Sonnet), the same 38-page vault and the same four structural questions, with and without obsidian-wiki installed. The project reports:

Plain agentWith obsidian-wiki
Time to answer81 s19 s
Correct answers44%83%
Tool calls9.94.6
API cost$0.202$0.208

The authors are careful about it themselves. It is 4 questions × 2 conditions × 2 repetitions on one vault, and the README calls the percentages “indicative”. Ground truth came from networkx, not from the project’s own code. One run in the “with” column failed when the model ignored the CLI and grepped by hand. The interesting finding is qualitative. The plain agent kept routing paths through index.md, which links to every page, so its “shortest paths” were meaningless. The skills exclude bookkeeping files from the graph.

Two things the numbers do not tell you. The questions are structural (“how is X connected to Y”, “which pages hold my vault together”), which is exactly where a link graph helps. They say nothing about everyday “what did I decide about X” lookups. And cost was flat, not lower: the gain is speed and correctness, not tokens.

Community and activity

Hacker News has no front-page thread about obsidian-wiki, and we could not find a Reddit discussion to cite. Adoption shows up elsewhere: 3,789 stars and 376 forks in about seven months, 39 contributors with GitHub accounts, and listings in several agent-skill directories. Release speed is high: three releases between November 15 and 19, 2026.

The project takes security reports seriously for a skills repo. SECURITY.md defines the threat model as “a vault, source document, or agent session whose content you do not control”. In scope are prompt injection that makes the agent run commands, writes outside the vault path, and secrets leaking into pages. Out of scope is “your own agent doing what you told it”. One of the five open issues (#346, opened November 20, 2026) points out that SECURITY.md links to a private-advisory form that does not appear on the repo. It is a small gap, but it matters if you plan to report something.

Honest limitations

  • Quality depends on your agent. The skills are instructions. A weaker model, or one that ignores the CLI (as in the benchmark’s failed run), will write weaker pages. The vault is only as good as whatever maintains it.
  • Lexical search by default. Paraphrases are not matched unless you add tags and summaries, or set up QMD.
  • Token cost moves to ingest. Compiling knowledge means the agent reads and rewrites pages on every ingest and lint pass. This is cheaper per query and more expensive per source. OBSIDIAN_MAX_PAGES_PER_INGEST (default 15) limits each run.
  • Many moving parts. 39 skills, hooks, a manifest, a trust ledger, OKF export, a session brain, a browser extension and a server. Expect to read docs.
  • The hooks are Claude Code hooks. Other agents get the skills and the bootstrap file, not the automatic recap.
  • Fast-moving. Fifty releases in about four months; only the latest PyPI release gets fixes.

How it compares

obsidian-wikiVector memory layers (Mem0, Cognee, Hindsight)Session recorders (Claude-Mem)
StorageMarkdown vault you ownDatabase plus embeddingsDatabase of session summaries
Who decides what to keepYour agent, guided by skillsAn LLM inside the memory layerAutomatic capture
SearchLexical, index-first; optional QMDSemanticSemantic or keyword
Readable by a humanYes, in Obsidian or any editorThrough an API or dashboardThrough a viewer
Works with17 listed agents + MCP + PythonSDK or MCPMainly Claude Code
Needs an API keyNo (Ask in the viewer does)UsuallyDepends

If your notes already live in Obsidian and you want an agent inside it, Agentic Copilot runs Claude Code as an Obsidian plugin. obsidian-wiki works the other way round: your agent stays in the terminal and maintains the vault. For per-repo documentation rather than personal memory, OpenWiki is the closer match.

FAQ

Does obsidian-wiki need Obsidian?

No. The vault is plain markdown with YAML frontmatter, and the CLI, the Python API and the obsidian-wiki ui web viewer work without Obsidian installed. Obsidian adds the graph view and the editor. The project ships an 18-page sample vault in examples/demo-vault/ that you can open in Obsidian before you build your own.

Does it need an API key or send my notes anywhere?

The skills, CLI and Python API need no API key and make no network calls of their own. Your agent reads pages with whatever model it already uses, so excerpts reach that model’s provider. In the web viewer, Ask sends the relevant excerpts and any web search queries to Claude, through Claude Code or an Anthropic API key. The README says the rest of the vault stays on your machine.

Which agents does it work with?

The compatibility table lists Claude Code, Cursor, Windsurf, Codex, Gemini CLI, Google Antigravity, Kiro, Hermes, OpenClaw, OpenCode, Aider, Factory Droid, Trae, GitHub Copilot (VS Code and CLI), Kilocode and Pi. Any MCP client can also use the eight memory tools through obsidian-wiki mcp. The history-ingest skills can mine past sessions from Claude, Codex, Copilot, Hermes, OpenClaw and Pi.

How is it different from RAG over my notes?

RAG searches raw chunks again on every question. obsidian-wiki compiles sources into merged, cross-linked pages once, and queries read titles, tags and summaries before page bodies. The project says query cost stays roughly flat from 20 pages to 2,000. The trade-off is that ingest costs more and search is lexical unless you add QMD.

Can several agents write to the same vault at once?

Yes, for the memory files. index.md, log.md, hot.md, the profile and the todo list all go through one writer that takes an advisory lock and writes atomically. The project added this after parallel writers silently lost updates. Content pages are written by the agents themselves, so turn on staged writes if you want to review them first.

Verdict

obsidian-wiki takes a simple idea seriously. The agent should maintain your knowledge the way a good engineer maintains a wiki: merge, link, mark what is a guess, and clean up. Keeping all intelligence in the agent and all state in markdown makes the vault transparent and portable across tools. It also makes lexical search and agent quality the two things to watch. The documentation is unusually candid about both, and about its own benchmark. If you spend your day in Claude Code, Codex or OpenClaw and keep losing what you worked out last month, start with setup, /wiki-capture and /wiki-query, and add the other 36 skills only when you need them.

Sources