eugeniughelbur

eugeniughelbur/obsidian-second-brain

Persistent memory for Claude Code, Codex and 6 other AI agents, stored as plain markdown in your Obsidian vault. New: Crew, one shared logbook so Claude Code, Codex, Cursor and Grok Bot know what each other did. 48 commands: semantic search, self-rewriting notes, key-less research, scheduled agents.

View on GitHub Website / Demo Back to listing

5.1kstars 634forks 50contributors Python

README.md

View on GitHub

Your vault is the memory. Claude, Grok Bot, Codex - same brain.
 
 Your vault outlives whichever CLI you switch to.

<h1 align="center">obsidian-second-brain: AI second brain for Obsidian - persistent memory for Claude Code, Codex, Cursor and Grok Bot</h1>

## Crew: one logbook for all your agents

**Crew works without Obsidian.** Claude Code, Codex, Cursor, and Grok Bot share job records in any plain folder.
Each agent sees what the others finished and can leave a lesson for review.

- Grok Bot joins the same team through its existing runner.
- A lesson becomes a rule only when a human runs `keep`.
- Crew runs no background loop.

```bash
curl -fsSL https://raw.githubusercontent.com/eugeniughelbur/obsidian-second-brain/main/scripts/quick-install.sh | bash
```

Restart Claude Code, then type `/crew setup`. Pick `~/crew` or `wiki/team/` inside your Obsidian vault.
Codex users run `/hooks` once to trust Crew's hooks. Setup prints a Grok Bot profile block to paste.

```text
18:40 | codex | brand | Astra pass, 0 errors
```

[Setup, exact commands, and limits](references/crew.md). Python 3.10 or later; no extra packages for Crew.
Shared agent memory isn't new. What Crew adds is the three parts above.

An evolution of <a href="https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f">Karpathy's LLM Wiki pattern</a>: a vault that rewrites itself.
 
 Every source updates existing pages instead of just appending new ones. Contradictions reconcile automatically. Your vault compounds while you sleep.
 
 Powered by <a href="references/freshness-policy.md">OKM - Open Knowledge Metabolism</a>: every stored fact is timeless, dated, or a pointer - so your knowledge base never fills with facts that used to be true.
 
 Built for developers &middot; founders and operators &middot; writers &middot; researchers - <a href="#choose-your-preset">pick a preset at setup</a>
 
 Start with three: <code>/obsidian-init</code> to set up, <code>/obsidian-save</code> to capture, <code>/obsidian-find</code> to recall. The other 42 are there when you need them.
 
 auto-synthesis &middot; thinking tools that argue with you
 
 live research from X, the web, and YouTube &middot; 4 scheduled agents &middot; 4 role presets
 
 write-time AI-first validator &middot; <code>/create-command</code> interview flow &middot; multilingual trigger schema
 
 <a href="#install">Install &rarr;</a> &middot;
 <a href="DEMOS.md">Demos</a> &middot;
 <a href="#what-happens-when-you-install-this">See it in action</a> &middot;
 <a href="#49-commands">All commands</a> &middot;
 <a href="#choose-your-preset">Presets</a> &middot;
 <a href="#the-vault-is-alive">OKM</a> &middot;
 <a href="https://github.com/eugeniughelbur/obsidian-second-brain/discussions">Discussions</a>

<a href="DEMOS.md">
 <img src="media/obsidian-save.gif" alt="One /obsidian-save command turns a conversation into five cross-linked AI-first notes: a person, a project with the decision, a task, a board card, and the daily note." width="100%" />
 </a>
 
 One <code>/obsidian-save</code> - five cross-linked notes. Real footage, synthetic vault. <a href="DEMOS.md">More demos &rarr;</a>
 
 If this looks useful, <a href="https://github.com/eugeniughelbur/obsidian-second-brain">star the repo</a>. It is how other people find it.

v0.18 - Crew (October 2026): Claude Code, Codex, Cursor and Grok Bot now share one logbook, so each agent knows what the others did. 
 One line per job in any plain folder or your vault, read through each agent's own hooks; lessons agents leave each other become rules only when you keep them; no background loop. Plus source quality labels and German triggers from contributors.
 <a href="CHANGELOG.md">See the changelog &rarr;</a>

---

## The Problem

You use Claude every day. Every session starts from scratch. You re-explain everything. The conversation ends. Everything disappears. Claude Code has no persistent memory across sessions - and neither does Grok Bot, Codex, Gemini, or any of the others.

You take notes in Obsidian. Hundreds of files. They just sit there. You make the same decision twice because you forgot you made it six months ago. Ideas rot in daily notes. Nobody connects the dots.

**Two powerful tools. Completely disconnected.** You already have the long-term memory. The thing doing the thinking cannot reach it.

---

## How this extends Karpathy's LLM Wiki

Karpathy's pattern is brilliant. Drop sources, LLM creates wiki pages, ask questions. This skill takes it further:

| | Karpathy's LLM Wiki | obsidian-second-brain |
|---|---|---|
| **New sources** | Append new pages, cross-reference | **Rewrite existing pages.** People get updated, claims revised, stale facts replaced. |
| **Contradictions** | Flagged, you resolve manually | `/obsidian-reconcile` resolves them automatically |
| **Patterns** | Surface when you ask | `/obsidian-synthesize` finds unnamed patterns and writes synthesis pages on its own |
| **When it runs** | On demand, when you prompt | 4 scheduled agents: morning brief, nightly consolidation, weekly review, vault-health check |
| **Note format** | Human-readable wiki pages | AI-first: `## For future agent` preamble + frontmatter for LLM retrieval, not human review |

If Karpathy's wiki is a knowledge base you maintain with an LLM, this is a knowledge base that maintains itself.

---

## What Happens When You Install This

**After a meeting:** `/obsidian-save`
Claude pulls out every decision, person, task, and idea and saves each one to the right note. You do nothing.

**You recorded a voice memo:** `/obsidian-ingest meeting.m4a`
Claude transcribes it with a local Whisper install, attributes speakers where the transcript makes them identifiable, extracts every promise and action item, and distributes across entity pages, task boards, and the daily note.

**You screenshot a whiteboard:** `/obsidian-ingest photo.png`
Claude reads the image, extracts text and structure, creates concept notes, links to related projects. A photo becomes knowledge.

**You have a finished text document:** `/obsidian-ingest report.docx`
Word (`.docx`, `.doc`) and OpenDocument (`.odt`) files uploaded or copied into the vault follow the same local-source rules as PDFs and Markdown. The helper converts a private copy to a temporary PDF, then ingestion uses the existing PDF path. Text and figures use that path; comments and revision markup are excluded. The original stays unchanged and remains the source under the existing provenance rules. Requires Python 3.10+ and [LibreOffice 26.2+](https://www.libreoffice.org/download/download-libreoffice/), installed separately. Run `python scripts/document_to_pdf.py "path/to/report.docx"`; it prints the PDF path. Put `soffice` on PATH or add `--soffice` with its executable path (Windows: `C:/Program Files/LibreOffice/program/soffice.com`; macOS: `/Applications/LibreOffice.app/Contents/MacOS/soffice`). Remove the generated PDF and its temporary parent folder after capture. No additional Python packages are needed. See [the ingest command](commands/obsidian-ingest.md). Presentation and spreadsheet formats remain outside scope.

**You find a great video:** `/obsidian-ingest https://youtube.com/...`
Claude doesn't summarize into one note. It REWRITES your existing pages. People get updated. Contradictions get resolved. Patterns trigger new synthesis pages. One URL in. The vault is smarter.

**Before a big decision:** `/obsidian-challenge`
Claude searches your vault for past failures and reversed decisions on the same topic. Pushes back with your own words. Your vault holds you accountable.

**You want to see the big picture:** `/obsidian-visualize`
Claude generates a visual canvas of your entire vault. Hub nodes centered, color-coded by type, orphans highlighted. Open it in Obsidian and see the shape of your knowledge.

**You go to sleep:** The nightly agent runs 5 phases: closes the day, reconciles contradictions, synthesizes cross-source patterns, heals orphan notes, and rebuilds the index. You wake up to a smarter vault.

**You start a new day:** `/obsidian-daily`
Claude pulls your calendar events, overdue tasks, and overnight changes into today's note. Your morning starts informed.

**Someone shares an X post:** `/x-read https://x.com/...`
Grok with live X access fetches the post, the thread, and the replies. Returns verbatim text + TL;DR + key claims + reply sentiment + voices to watch. No more screenshots.

**You're planning today's content:** `/x-pulse "AI automation"`
Grok scans X for what's trending in your topic right now. Returns 3-5 emerging themes (with rep posts + key voices), gaps nobody is filling, hook formats that are working, and 3 specific post ideas you could write today.

**You need real research:** `/research "AI memory tools"`
Perplexity Sonar Pro pulls a deep dossier with citations: summary, key facts (every claim with a recency marker and source domain), timeline, key players, contrarian views, recommended further reading, open questions. Saved to your vault, auto-opens in Obsidian.

**You want vault-first deep research:** `/research-deep "AI memory tools"`
Scans your vault for what you already know. Identifies gaps. Spawns 3-5 targeted searches via Perplexity (web) and Grok (X discourse). Synthesizes a delta report: what's new, what's confirmed, contradictions to resolve, recommended vault updates. Vault baseline doesn't get re-researched. Only gaps get filled.

**You hit a great YouTube video:** `/youtube https://youtu.be/...`
Free transcript via youtube-transcript-api. Optional metadata + top comments via YouTube Data API v3. Gemini (free tier, Grok fallback) summarizes into TL;DR, Key Points, Notable Quotes (verbatim), Themes, Comment Sentiment, and Worth Following Up On. Saved as an AI-first note in your vault. Add `--visual` to also *watch* it: scene-change frame extraction (ffmpeg) that Claude reads with its own vision to capture on-screen text, code, diagrams, and demos the transcript misses.

**You never open Obsidian.** Everything happens through Claude.

---

## Before & After

| | Without this skill | With this skill |
|---|---|---|
| Saving decisions | Copy-paste or lose them | Auto-saved to the right project note |
| Daily notes | Write it yourself, forget half the time | Created automatically |
| Finding patterns | Re-read dozens of notes | `/obsidian-emerge` finds them for you |
| Challenging yourself | Nobody pushes back | `/obsidian-challenge` uses your own history against you |
| Session continuity | Re-explain every time | `/obsidian-world` loads full context in 10 seconds |
| Ingesting content | Read it, forget it | `/obsidian-ingest` rewrites 5-15 vault pages from 1 source (URLs, PDFs, Word/OpenDocument text files, audio, screenshots) |
| Contradictions | You don't know they exist | `/obsidian-reconcile` resolves them automatically |
| Synthesis | You connect dots manually | `/obsidian-synthesize` finds patterns across sources on its own |
| Sharing vault data | Only Claude can read it | `/obsidian-export` gives any AI tool a clean snapshot |
| Facts change over time | Old info gets overwritten | Bi-temporal facts track when it was true AND when the vault learned it |
| Starting a new session | Re-explain who you are | `CRITICAL_FACTS.md` loads your identity in ~120 tokens |
| Reading an X thread | Open X, scroll, screenshot, paste | `/x-read [url]` returns post + thread + sentiment + voices |
| Knowing what to post | Guess what's trending | `/x-pulse` scans X and returns hot themes + gaps + hooks + post ideas |
| Web research | Open 12 tabs, copy quotes manually | `/research [topic]` returns a sourced dossier with recency markers |
| Researching what you already know | Re-research from scratch | `/research-deep` scans vault first, fills only the gaps, flags contradictions |
| YouTube videos | Watch passively, forget | `/youtube [url]` transcript + summary + quotes saved to vault |
| Vault notes for future agent | Notes for human reading | AI-first rule: every note has "For future agent" preamble + recency markers + citations |
## More from the author

*The product is above. This is where it came from and where it goes next.*

From the blog &middot; <a href="https://theaioperator.io">The AI Operator &rarr;</a>

Featured: <a href="https://theaioperator.io/p/huge-update-on-obsidian-second-brain">"HUGE update on obsidian-second-brain: The Architect"</a> 
 <code>/obsidian-architect</code> &middot; document your codebase into your vault &middot; the full before-and-after

Deep dive: <a href="https://theaioperator.io/p/i-rebuilt-karpathys-llm-wiki-heres">"I rebuilt Karpathy's LLM Wiki. Here's what's missing from the original."</a> 
 Why append-only breaks at scale &middot; the AI-First Vault Principle &middot; three bugs in v1

Origin story: <a href="https://theaioperator.io/p/i-built-this-for-myself-then-1374">"I built this for myself. Then 1,374 strangers cloned it."</a> 
 Two disconnected tools &middot; the institutional-amnesia problem &middot; 1,000+ stars in 7 weeks

One post per Tuesday on Obsidian + AI workflows and bringing AI into real work.

Research toolkit &middot; dual-track 
 <code>/x-read</code> &middot; <code>/x-pulse</code> &middot; <code>/research</code> &middot; <code>/research-deep</code> &middot; <code>/notebooklm</code> &middot; <code>/youtube</code> &middot; <code>/podcast</code>

Open-web track &middot; <code>/research-deep</code> via Perplexity + Grok. Pulls fresh signal from outside. 
 Source-grounded track &middot; <code>/notebooklm</code> via Gemini File Search. Reads your own vault. 
 Run both for high-stakes topics. Contradictions across the two are where the insight is.

Built by <a href="https://github.com/eugeniughelbur">Eugeniu Ghelbur</a> &middot; AI Automation Engineer @ Single Grain 
 building in public &middot; sharing what works

### Follow along

*Weekly posts on AI second-brain systems, vault patterns, and what actually works.*

</td>
</tr>
</table>

</div>

---

## How It Works

49 commands total. The calendar command (`/obsidian-calendar`) is Claude Code only (needs the Google Calendar MCP), so the Codex / Gemini / OpenCode / Hermes / Pi / Agent Skills builds ship 48.

**Layer 1** saves, organizes, ingests, reconciles, exports, schedules your calendar, and maintains your vault.
**Layer 2** challenges your ideas, surfaces hidden patterns, bridges unrelated domains, and graduates ideas into projects.
**Layer 3** loads your identity and current state so every session picks up where the last one ended.
**Layer 4** pulls live external knowledge into the vault: X posts, X trends, web research with citations (key-less by default), YouTube and podcast transcripts. Vault-first synthesis knows what you already know.
**Always On** keeps the vault alive without you lifting a finger.

---

## 49 Commands

### Operations -- Claude remembers

| Command | What it does |
|---|---|
| `/obsidian-save` | Saves everything from the conversation -- decisions, tasks, people, ideas |
| `/obsidian-ingest` | Ingest a URL, file, or resumable folder batch (text, PDFs, `.docx`/`.doc`/`.odt` via LibreOffice, audio, images). The vault REWRITES itself. 5-15 pages touched per source. |
| `/obsidian-synthesize` | Auto-finds patterns across sources and writes synthesis pages |
| `/obsidian-reconcile` | Finds contradictions and resolves them. The vault maintains its own truth. |
| `/obsidian-checkin` | Asks you whether old people and project notes still hold. Shows what each says, re-asks until you answer, saves the news. |
| `/obsidian-export` | Clean JSON/markdown snapshot any AI tool can read |
| `/obsidian-daily` | Creates or updates today's daily note |
| `/obsidian-calendar <mode>` | One calendar command, four modes: `agenda` (read a snapshot), `reconcile` (flag commitments not yet scheduled), `meeting` (event to note), `schedule` (create/move an event from a task or standalone) |
| `/obsidian-recurring` | Tracks a recurring obligation with a cadence and a computed next-due date |
| `/obsidian-log` | Logs a work session, links it everywhere |
| `/obsidian-task` | Adds task to the right board with priority and due date |
| `/obsidian-person` | Creates or updates a person note |
| `/obsidian-capture` | Zero-friction idea capture |
| `/obsidian-catchup` | Process captures dumped from the Telegram bot (voice/text/image/PDF/link) into the vault |
| `/obsidian-find` | Smart search with context |
| `/obsidian-recap` | Summary of a day, week, or month |
| `/obsidian-review` | Structured weekly or monthly review |
| `/obsidian-board` | Kanban board view and updates |
| `/obsidian-board-hygiene` | Bulk-triage a board -- surface stale/overdue items, then archive / reschedule / mark-Done in one pass |
| `/obsidian-project` | Project note with board and daily links |
| `/obsidian-projects` | Live project status from git + local docs -- infers all context from vault notes, no config required |
| `/obsidian-health` | Vault audit -- contradictions, gaps, stale claims, orphans, freshness violations (the [freshness policy](references/freshness-policy.md): every fact timeless, dated, or a pointer), typed-edge lint (unknown types, dangling targets, contradiction cycles in the `relations:` graph), and a tag taxonomy audit ([opt-in](references/taxonomy-format.md) via `_meta/taxonomy.md`) |
| `/obsidian-merge` | Merge two near-duplicate notes from `/obsidian-health` into one -- dry run by default, frontmatter union, retired note becomes a redirect (never deleted) |
| `/obsidian-reindex` | Refreshes the incremental semantic index and reports coverage before and after, with clear embedding-backend failures |
| `/obsidian-retrieval-eval` | Measures vault search quality -- recall@k + MRR on natural-language questions, with the concrete failures and ranked fixes |
| `/obsidian-decide [--formal]` | Logs decisions to the right project notes; `--formal` writes a full ADR record (the vault knows why it's structured this way) |
| `/obsidian-visualize` | Generates a visual canvas map of your second brain |
| `/obsidian-learn` | Reviews vault learnings, prunes stale ones, surfaces patterns to promote into rules |
| `/obsidian-init` | Generates `_CLAUDE.md`, `index.md`, `log.md` |
| `/obsidian-architect` | Scans a codebase and writes maintained architecture notes (overview, modules, decisions) into the vault; re-run to refresh |
| `/crew setup` | Shared job log and lessons with a human keep decision; works without Obsidian |
| `/create-command` | Interview flow that scaffolds a new command into `commands/<name>.md`, no markdown editing |

### Thinking -- Claude thinks with you

| Command | What it does |
|---|---|
| `/obsidian-brainstorm [topic]` | Multi-turn Socratic interview - one question per turn until the idea converges, then a design note with named alternatives |
| `/obsidian-challenge` | Your vault argues against your idea using your own history |
| `/obsidian-panel` | Convenes a panel of distinct perspectives on a decision, one verdict each + synthesis |
| `/obsidian-emerge` | Surfaces patterns from 30 days of notes you never named |
| `/obsidian-connect [A] [B]` | Bridges two unrelated domains to spark new ideas |
| `/vault-deep-synthesis [topic]` | Cross-references every note on a topic: agreements, contradictions, stale claims, gaps |
| `/obsidian-distill [note or source]` | Condenses a long note/source into key claims, each tagged with provenance back to the exact source block |
| `/idea-discovery` | Ranks 3-5 next-direction candidates from ideas, open questions, and orphan research |
| `/obsidian-graduate` | Turns an idea fragment into a full project with tasks |

### Context -- Claude knows you

| Command | What it does |
|---|---|
| `/obsidian-world` | Loads identity + state with progressive token budgets (L0-L3) |

### Research -- Claude pulls knowledge in

Powered by xAI Grok (live X access) + Perplexity Sonar (web research) + YouTube. Findings save to `Research/` as AI-first notes (preamble, frontmatter, recency markers, sources verbatim).

| Command | What it does |
|---|---|
| `/x-read [url]` | Deep-read an X post: verbatim post + thread + TL;DR + claims + reply sentiment + voices |
| `/x-pulse [topic]` | Scan X for what's trending: themes, voices, hooks, post ideas |
| `/research [topic]` | Web research with citations: full dossier with recency markers and open questions. Uses Perplexity when keyed, free key-less sources (Wikipedia, HackerNews, arXiv, Reddit, and more) otherwise |
| `/research-deep [topic]` | Vault-first synthesis (open web): scans your vault, finds gaps, fills them via Perplexity + Grok (or free key-less sources when unkeyed), propagates updates across people/projects/ideas |
| `/notebooklm [topic]` | Vault-grounded synthesis via Gemini File Search. Uploads top 12 vault notes, returns a grounded answer with citations. No browser, one HTTP call. Pairs with `/research-deep` for dual-track research. |
| `/youtube [url] [--visual]` | Extract transcript + metadata + top comments → AI-first summary. `--visual` adds scene-change frame extraction Claude reads with its own vision |
| `/podcast [url]` | Apple Podcasts or RSS → transcript (RSS tag / Whisper / show-notes) + AI-first summary |

**Setup:** copy `.env.example` to `~/.config/obsidian-second-brain/.env`, add your keys (xAI, Perplexity, YouTube optional, OpenAI optional for podcast Whisper). Run `install.sh` and answer "y" to the research prompt to do this automatically.

**No keys? `/research` and `/research-deep` still work.** With no `PERPLEXITY_API_KEY` set they automatically fall back to free, key-less sources (Wikipedia, HackerNews, arXiv, Reddit, Lobsters, dev.to, OpenAlex, Semantic Scholar, CrossRef, DuckDuckGo - plus Tavily/Brave when keyed) and Claude synthesizes the dossier. Pass `--free` to force it even when keyed, or `--academic` to restrict to scholarly sources. The other research commands (`/x-read`, `/x-pulse`, `/notebooklm`, `/youtube`) still need their respective keys.

<details>
<summary>See the thinking tools in action</summary>

**`/obsidian-challenge`**

You: *"I want to rewrite the API in Rust."*

Claude finds your 2025 post-mortem where the Rust rewrite failed. Finds your decision log committing to TypeScript for 2 years. Says: *"Your own notes say this failed. Still want to proceed?"*

---

**`/obsidian-emerge`**

Claude scans 30 daily notes. You mentioned "onboarding friction" in 4 unrelated projects.

*"Onboarding is your bottleneck across projects. You never named it."*

---

**`/obsidian-connect "distributed systems" "cooking"`**

Traces both clusters in your link graph. Finds shared concepts: preparation and load distribution. Generates 3 actionable ideas at the intersection.

---

**`/obsidian-graduate`**

An idea from 3 weeks ago. Claude reads it, finds related projects and people, generates a full spec with goals, phases, tasks, and board entries. The idea gets tagged `graduated`.

</details>

<details>
<summary>See /obsidian-ingest in action</summary>

```
/obsidian-ingest https://youtube.com/watch?v=example
```

1. Saves original to `raw/videos/` (immutable)
2. REWRITES entity pages with new context
3. REWRITES concept pages if the source adds depth or contradicts them
4. Creates synthesis pages when patterns emerge
5. Resolves contradictions and documents why
6. Updates `index.md`, `log.md`, daily note

**One URL in. The vault rewrites itself.**

</details>

<details>
<summary>See the research toolkit in action</summary>

**`/x-read https://x.com/garrytan/status/2048121438914154664`**

Grok with live X access fetches the post and replies. You get verbatim text, TL;DR, key claims, reply sentiment (~70% positive, 20% skeptical, 10% off-topic), notable counter-arguments with the @ handles of who said them, and "voices to watch" (the replies that added real signal). ~$0.05/call.

---

**`/x-pulse "AI automation"`**

```
WHAT'S HOT (last 24-72h)
  1. Agentic AI vs Basic Automation — voices: @NVIDIAAP, @woisau1
  2. Self-Improving Sovereign Agents — voices: @tom_doerr, @AIDailyGems
  3. Control Layers & Execution Gaps — voices: @ZIQING_JP

WHAT'S UNDEREXPLORED
  - ROI numbers for non-developer small business users
  - Integration of digital agents with physical robotics

HOOKS THAT ARE WORKING
  - "Automation executes. Autonomy reasons." — @NVIDIAAP

POST IDEAS FOR YOU TODAY
  1. Thread: "I gave an open-source agent its own GitHub repo and watched it self-improve"
  2. Single: "Automation executes. Autonomy reasons. Here's the control layer..."
```

What you'd spend 2 hours scrolling X to find. Returned in 30 seconds for ~$0.13.

---

**`/research "AI memory tools"`**

Returns a structured dossier: Summary, Key Facts (each with `(as of YYYY-MM, source.com)`), Timeline, Key Players, Contrarian Views, Recommended Further Reading, Open Questions, full citations. Saved to `Research/Web/` as an AI-first note. ~$0.05/call.

---

**`/research-deep "AI memory tools"`**

```
Phase 1: Vault scan
  Found 8 relevant notes (e.g. Knowledge/2026-02-15 - Mem0 vs Letta.md)

Phase 2: Gap analysis (Perplexity sonar-pro)
  Identified 5 targeted queries to fill what vault is silent or stale on

Phase 3: Targeted research
  [web] Anthropic Claude memory tool 2026 features
  [web] Mem0 Series A reactions and concerns
  [x]   developer reactions to Letta vs Mem0
  ...

Phase 4: Synthesis (sonar-reasoning-pro)
  → What's New Since Vault Baseline
  → What's Confirmed
  → Contradictions / Updates Needed (with [[wikilinks]] to specific vault files)
  → Synthesis bullets
  → Recommended Vault Updates (instructions for /obsidian-save)
  → Open Questions
```

Vault-first means it doesn't waste tokens re-researching what you already knew. ~$0.40/call.

---

**`/notebooklm "AI-first vault rule"`** - vault-grounded, no browser

Scans the vault, uploads the top 12 most relevant notes to a Gemini File Search store, asks Gemini 2.5 Flash to synthesize against THOSE sources only with citations, writes the synthesis to `Research/NotebookLM/` as an AI-first note, deletes the store.

```
Vault baseline: 12 notes
Model: gemini-2.5-flash
Uploading 12 notes... done
Asking Gemini, grounded against the uploaded sources...

=== SAVED ===
Research/NotebookLM/2026-05-15 - ai-first-vault-rule.md
```

Pair with `/research-deep` on the same topic. Open-web view + vault-grounded view rarely contradict. Where they do, that's where you have a take worth posting. ~$0.004/call on free-tier Flash, ~$0.06 on paid Pro.

---

**`/youtube https://youtu.be/...` (add `--visual` to watch, not just read)**

Free transcript via youtube-transcript-api + optional metadata + comments via YouTube Data API v3 (free tier). Gemini (gemini-2.5-flash, free tier) summarizes into TL;DR, Key Points, Notable Quotes (verbatim), Themes, Comment Sentiment, and Worth Following Up On - Grok is the automatic fallback (~$0.04) when no Gemini key is set. Frontmatter includes view count, channel, published date, like count for Dataview queries.

`--visual` downloads the video (yt-dlp, <=720p) and extracts one frame per scene change (ffmpeg scene detection, not a fixed timer), so on-screen text, code, diagrams, slides, UI, and b-roll are captured. Claude reads the frames with its own vision (no extra API call) and writes a timestamp-keyed `## Visual notes` section; hero frames are embedded in the note. Requires `yt-dlp` + `ffmpeg` on PATH; skips gracefully if missing. `--max-frames N` caps frames read (default 24). Pipeline ported from [claude-watch](https://github.com/taoufik123-collab/claude-watch) / [claude-video](https://github.com/bradautomates/claude-video) (MIT).

---

**`/podcast https://podcasts.apple.com/...`** (or paste an RSS feed URL)

Resolves Apple Podcasts URLs to RSS via the free iTunes Lookup API. Picks the best transcript source available: `<podcast:transcript>` tag in the RSS feed (free, high fidelity) → Whisper API if `OPENAI_API_KEY` is set (~$0.006/min) → show-notes fallback. Grok summarizes into TL;DR, Key Points, Notable Quotes, Themes, Guests & People Mentioned, and Worth Following Up On. ~$0.04 for the Grok call (plus Whisper if used). Spotify URLs aren't supported (DRM).

---

**Auto-open after every save.** Obsidian pops open at the new note. Disable with `RESEARCH_AUTOOPEN=0` if you're running batch saves.

</details>

---

## The Vault is Alive

Traditional vaults are filing cabinets. You put things in. They sit there.

This vault rewrites itself with every input:

- **Ingest a source** -- existing pages get rewritten, contradictions resolved, patterns synthesized
- **Save a conversation** -- entities, concepts, and decisions distribute across the vault
- **Ask a question** -- the Two-Output Rule means every answer also updates pages
- **A fact changes** -- bi-temporal facts track when it was true AND when the vault learned it. "You believed X on Tuesday. After ingesting Y on Wednesday, you shifted to Z." Full audit trail.
- **Do nothing** -- background agent and scheduled agents maintain it while you sleep
- **Wait a week** -- auto-synthesis finds cross-source patterns and writes connection pages

The vault after a week is fundamentally different from the vault you started with.

**The maintenance layer has a name: OKM (Open Knowledge Metabolism).** Storage is the easy half; keeping stored knowledge *true* is the hard half, and it is where this project spends its effort. OKM is the open spec behind that: **every stored fact must be timeless, dated, or a pointer.** Slow-changing knowledge (how things work, decisions, ownership) is stored; fast-changing facts (counts, statuses, balances) are linked to where they live with an `as of` stamp, never copied in to rot. The rule is a one-page spec ([references/freshness-policy.md](references/freshness-policy.md)), enforced by a linter ([scripts/freshness_lint.py](scripts/freshness_lint.py)) that `/obsidian-health` runs. It is the companion to OKF (Google's Open Knowledge Format), and the division is sharper than format-versus-freshness: OKF v0.2 added fields for recording that something went stale (`status`, `stale_after`, `verified`), but a field cannot stop a note claiming "the pipeline has 13 deals" with no stamp on it. OKM is the *rule* about what may be stored bare at all, and a linter that fails the build when it is not. One spec, one reference linter, no second implementation yet. It is storage-agnostic: any folder of markdown an AI maintains, not just Obsidian vaults.

---

## Choose Your Preset

Pick your role at bootstrap. Each preset creates tailored folder structures, templates, and kanban boards.

| Preset | Who it's for | Kanban style |
|---|---|---|
| **executive** | Founders, operators, managers | OKRs / Quarterly / Weekly |
| **builder** | Developers, engineers, architects | Backlog / Sprint / Done |
| **creator** | Writers, YouTubers, marketers | Ideas / Drafts / Published |
| **researcher** | Academics, analysts, deep-divers | Reading / Processing / Synthesized |

```bash
uv run python scripts/bootstrap_vault.py --path ~/my-vault --name "Your Name" --preset builder
```

No preset? You get a general-purpose vault that works for everyone.

Every preset builds the Obsidian-style layout (`Daily/`, `People/`, `Projects/`, ...). Add `--style wiki` for the wiki-style layout described under [Vault Architecture](#vault-architecture):

```bash
uv run python scripts/bootstrap_vault.py --path ~/my-vault --name "Your Name" --preset builder --style wiki
```

---

## Background Agent & Scheduled Agents

**Background:** fires after every context compaction. You keep working. The vault updates itself.

```
PostCompact -> obsidian-bg-agent.sh -> claude -p (headless) -> vault updated
```

**What arming it costs.** The headless run uses `--dangerously-skip-permissions`, because nobody is there to approve each write. That is why the agent ships inert and stays opt-in. Its tool surface is restricted with `--tools "Read,Write,Edit,Glob,Grep"` (the flag that removes every other built-in tool, not just pre-approves these) and no MCP servers are loaded, so it cannot run shell commands or reach the network, and it only adds and updates - it never deletes or merges. If that trade is not one you want, leave it off; every other command works without it.

**Scheduled:**

| Agent | When | What |
|---|---|---|
| `morning` | 8 AM | Daily note + overdue tasks |
| `nightly` | 10 PM | Sleeptime consolidation: close day + reconcile + synthesize + heal orphans |
| `weekly` | Fridays 6 PM | Weekly review |
| `health` | Sundays 9 PM | Vault health audit |

**Save reminders:** Claude nudges you to `/obsidian-save` after 10+ exchanges or when you say "done" or "thanks". No lost conversations.

**Bounded recall (opt-in):** on every prompt, a `UserPromptSubmit` hook injects a small brief of the most relevant vault notes - max 4 notes, ~900 chars - or **nothing at all** when confidence is low (abstention beats noise). Read-only, fail-closed, and every inject/abstain decision is logged to `<vault>/.claude-runs/` for audit. Ships inert; arm it with `OBSIDIAN_RECALL_ENABLED=1` per [hooks/recall.hook.example.json](hooks/recall.hook.example.json).

---

## Vault Architecture

**Starting with personal notes?** `/obsidian-init` offers an optional [First-Brain wiki-style variant](references/vault-schema.md#first-brain-wiki-style-variant) for an existing, evolving collection of human notes. Human notes live in the `First-Brain/` folder, immutable ingestion captures in `raw/`, and AI-maintained knowledge in `wiki/`. Initialization ensures the `First-Brain/` source folder exists and configures ownership and routing; it does not move or ingest notes. Then use `/obsidian-ingest` on an individual First Brain file or the collection. Original notes stay in place under instruction-based protection, not a filesystem sandbox. See [the initialization command](commands/obsidian-init.md) for the full procedure.

**Importing a collection?** `/obsidian-ingest Sources/ --preview` discovers eligible text files, PDFs, audio, and images without reading source bodies or writing progress. `/obsidian-ingest Sources/ --batch-size 10` processes up to ten sources sequentially through the existing ingestion workflow. Repeat the same command for the next batch or after an interrupted session has stopped; completed unchanged sources are skipped, and unfinished sources reuse their raw captures. Sensitive-content rules and rewrite approvals still apply. Required pending or declined approvals never count as completion.

Progress uses one hidden completion comment per processed source version in existing `Logs/YYYY-MM-DD.md` files, or legacy `log.md`; there is no separate state file or additional readable status line. The comment contains the source path, byte hash, raw reference, and timestamp. Each source finishes its catalog, daily-note, and normal log updates before the comment is written. Unfinished work has no completion comment and is retried on the next run; errors and pending approvals appear in the normal report. Removing completion history requires reprocessing, with raw deduplication retained. Run only one folder ingestion per vault at a time; this minimal helper does not track active sessions, enforce locking, or validate semantic extraction quality. See [the ingestion procedure](commands/obsidian-ingest.md#directory-ingestion) for supported extensions, provenance hashes, custom routing, and recovery. First Brain warm start is simply `/obsidian-ingest First-Brain/`; other layouts and source collections use the same workflow. Binary originals remain untouched; captures retain existing transcripts, PDF extracts, or image descriptions rather than archive binaries.

Two layouts are supported. `scripts/bootstrap_vault.py` builds the Obsidian-style layout by default: `Daily/`, `People/`, `Projects/` and the preset's topic folders such as `Goals/` and `Mentions/`, as laid out in [references/vault-schema.md](references/vault-schema.md). Pass `--style wiki` for the wiki-style layout below. A preset folder the wiki layout renames moves to that name (`People/` to `wiki/entities/`, `Ideas/` and `Knowledge/` to `wiki/concepts/`); one it does not rename keeps its own name under `wiki/` (`Goals/` to `wiki/goals/`, `Sources/` to `wiki/sources/`), so a preset builds the same vault in either layout.

### Wiki-style -- LLM-first

Claude is the reader and writer. The vault is a database.

```
vault/
+-- _CLAUDE.md          # Operating manual
+-- index.md            # Page catalog (Claude reads FIRST)
+-- log.md              # Activity timeline
+-- SOUL.md             # Your identity
+-- CRITICAL_FACTS.md   # ~120 tokens, always loaded (timezone, manager, location)
+-- raw/                # IMMUTABLE source material
+-- wiki/               # Claude's workspace
|   +-- entities/       # People, companies, tools
|   +-- concepts/       # Ideas, frameworks, synthesis
|   +-- projects/       # Project notes
|   +-- daily/          # Daily notes
|   +-- logs/           # Work session logs
|   +-- reviews/        # Weekly/monthly reviews
|   +-- tasks/          # Task notes
|   +-- decisions/      # ADRs
+-- boards/             # Kanban boards
+-- templates/          # Note templates
```

---

## Install

> **One codebase, eight builds.** Pick yours below. The vault behavior is identical across all of them; only the install path and the dispatcher file (`CLAUDE.md` / `AGENTS.md` / `GEMINI.md` / `.agents/skills/` / `.pi/` / workflow SKILL.md) differ.

Rather than ask you to take that on faith, here is what each build currently passes:

| Build | Emits a real tree | Script paths resolved | Docs reachable | Toolkit runnable |
|---|---|---|---|---|
| Agent Skills | pass | pass | pass | pass |
| Claude Code | pass | pass | pass | pass |
| Codex CLI | pass | pass | pass | pass |
| Gemini CLI | pass | pass | pass | pass |
| Grok Bot | pass | pass | pass | pass |
| Hermes | pass | pass | pass | pass |
| OpenCode | pass | pass | pass | pass |
| Pi | pass | pass | pass | pass |

*Generated by `scripts/conformance_report.py`, verified in CI on every push. Each build is compiled from the same source tree, then checked for a non-empty output, a resolved script root, reference paths that actually exist in that build, and a Python project shipped beside the scripts. A red cell here is a real red cell, not a missing test.*

**Prerequisites:** [Claude Code](https://claude.com/claude-code) (or one of the other six platforms below), `git`, and [`uv`](https://docs.astral.sh/uv/) for the Python helpers (health check, research toolkit, bootstrap). `jq` is **required for the classic script install** - `scripts/setup.sh` uses it to edit `~/.claude/settings.json` safely and exits if it is missing. Not needed on the plugin path. Optional: [Ollama](https://ollama.com) for local semantic search, `openai-whisper` (installed on first audio ingest, pulls in PyTorch). No API keys needed for the core vault commands.

### Crew only (no vault)

Want the shared logbook without Obsidian? Run the quick install above, restart Claude Code, and type `/crew setup`. Pick a plain folder such as `~/crew`. Or run the helper directly:

```bash
python3 ~/.claude/skills/obsidian-second-brain/scripts/crew.py --dir ~/crew setup
```

Codex users then run `/hooks` once to trust the hooks. Restart Cursor after setup. Full guide: [references/crew.md](references/crew.md).

### Claude Code (default)

**Native plugin install (recommended).** Inside any Claude Code session:

```
/plugin marketplace add eugeniughelbur/obsidian-second-brain
/plugin install obsidian-second-brain@obsidian-second-brain
```

That ships all 49 commands, the skill manual, the session-context hook, the opt-in background agent (inert until you arm it - see [hooks/postcompact.hook.example.json](hooks/postcompact.hook.example.json)), and the vault MCP server. Then tell Claude where your vault lives by adding to the `env` section of `~/.claude/settings.json`:

```json
"env": { "OBSIDIAN_VAULT_PATH": "/path/to/your/vault" }
```

Restart Claude Code, then run `/obsidian-second-brain:obsidian-init` inside your vault. Plugin commands are namespaced, so every command is `/obsidian-second-brain:<name>` (type `/obsidian-second-brain:` to see all 49). Update later with `/plugin update obsidian-second-brain`.

**Classic install (script).** Use this if you want the commands as bare names (`/obsidian-init`, `/research`, ...) or you are developing the skill and want live edits. One line (clones the skill, installs the slash commands, registers the session-context hook, and offers the research env):

```bash
curl -fsSL https://raw.githubusercontent.com/eugeniughelbur/obsidian-second-brain/main/scripts/quick-install.sh | bash
```

Or step by step:

```bash
git clone https://github.com/eugeniughelbur/obsidian-second-brain ~/.claude/skills/obsidian-second-brain
bash ~/.claude/skills/obsidian-second-brain/install.sh
bash ~/.claude/skills/obsidian-second-brain/scripts/setup.sh "/path/to/your/vault"
```

> Cloning it? A [star](https://github.com/eugeniughelbur/obsidian-second-brain) costs you nothing and is how the next person finds this.

**No vault yet?** Create a ready-to-use one first (folders, templates, boards, dashboards - passes its own health check out of the box):

```bash
cd ~/.claude/skills/obsidian-second-brain
uv run python scripts/bootstrap_vault.py --path ~/Documents/MyVault --name "Your Name"
bash scripts/setup.sh ~/Documents/MyVault
```

Then open Claude Code and run `/obsidian-init` inside your vault.

### Codex CLI / Gemini CLI / OpenCode

> **Codex and OpenCode users: prefer the [Agent Skills build](#google-antigravity-and-any-agentsskills-harness) below.** The standalone `codex-cli` and `opencode` builds are deprecated and superseded by it; both print that notice in their own `INSTALL.md`. They still work, and will until they are removed. Gemini CLI has no replacement build, so this is the right path there.

```bash
git clone https://github.com/eugeniughelbur/obsidian-second-brain
cd obsidian-second-brain
bash scripts/build.sh --platform codex-cli   # or gemini-cli, or opencode
cp -R dist/codex-cli/. /path/to/your/vault/   # or dist/gemini-cli/. or dist/opencode/.
```

Then start your CLI from the vault root.

The **Codex build emits native [Codex Agent Skills](https://developers.openai.com/codex/skills)**: one skill per command under `.agents/skills/<name>/SKILL.md`. Codex discovers them automatically with progressive disclosure (only each skill's name + description load until it's selected), and they run **in your current session** - invoke one with `$<name>`, pick it from `/skills`, or just describe the task and let Codex match it implicitly. `AGENTS.md` stays as a thin always-on manual (vault conventions + the AI-first rule); there is no routing table to maintain because the skill list is the router. The Gemini / OpenCode builds still emit a `GEMINI.md` / `AGENTS.md` dispatcher with an auto-generated routing table to command files under `.gemini/` / `.opencode/`.

Run `bash scripts/build.sh` with no arguments to build every platform at once. See [`dist/<platform>/INSTALL.md`](scripts/build.sh) after building for platform-specific notes.

### Google Antigravity (and any `.agents/skills/` harness)

Antigravity, Codex CLI, OpenCode, and GitHub Copilot CLI have all converged on the open [Agent Skills](https://github.com/vercel-labs/skills) standard: workspace skills at `.agents/skills/<name>/SKILL.md`. The `agent-skills` build emits one spec-compliant tree they all read - and any future harness on the same standard works with zero repo changes.

```bash
git clone https://github.com/eugeniughelbur/obsidian-second-brain
cd obsidian-second-brain
bash scripts/build.sh --platform agent-skills

# install with skills.sh (writes one shared .agents/skills/ tree), from your vault root:
npx skills add /path/to/obsidian-second-brain/dist/agent-skills -a antigravity -a codex -a opencode
# or copy manually, no skills.sh required:
cp -R dist/agent-skills/skills/. /path/to/your/vault/.agents/skills/
```

Each command becomes a skill under `.agents/skills/`; a shared `obsidian-core` skill carries the Python toolkit and the AI-first write spec the others call into. The skills are self-sufficient (they resolve the vault root from `$OBSIDIAN_VAULT_PATH` or the working directory and embed the write spec), so they need no session-start hook. This is the recommended path for **Google Antigravity**, whose skill discovery differs from classic Gemini CLI: Antigravity still reads the `gemini-cli` build's `GEMINI.md` as passive context, but only detects active skills under `.agents/skills/`, so install this build (not `gemini-cli`) if you want Antigravity to surface the commands as skills. See [`dist/agent-skills/INSTALL.md`](scripts/build.sh) for the full story (skills.sh, manual copy, per-harness notes, and the optional always-on vault-routing rule).

### Pi Coding Agent

```bash
git clone https://github.com/eugeniughelbur/obsidian-second-brain
cd obsidian-second-brain
bash scripts/build.sh --platform pi
pi install ./dist/pi          # or: cp -R dist/pi/.pi/ /path/to/your/vault/
```

The **Pi build emits a native [Pi](https://pi.dev) package**: prompt templates under `.pi/prompts/` (invoke as `/obsidian-save`, `/obsidian-daily`, etc.) plus a discovery skill under `.pi/skills/obsidian-second-brain/` (load with `/skill:obsidian-second-brain`). Pi reads the same `~/.config/obsidian-second-brain/.env` keys as the other platforms. It has no background-agent equivalent, and the scheduled agents (`obsidian-nightly` and the others) are prompts, not commands, so Pi has no `/obsidian-nightly` to type. To run one, copy its prompt from the scheduled agents section of `SKILL.md` into a Pi session, by hand or from your own scheduler. (Contributed by @Gepetdo.)

### Use it in Grok Bot

Obsidian Second Brain turns what's on your mind into linked notes in your Obsidian vault, keeps your daily notes, and answers your questions from your own notes with links back to the source.

Start from the official Obsidian Second Brain bot template: https://x.ai/bot/Oj_doyprowDl817Yk5Rbh

### Grok Bot / Sand

```bash
git clone https://github.com/eugeniughelbur/obsidian-second-brain
cd obsidian-second-brain
bash scripts/build.sh --platform grok-bot
# Review dist/grok-bot/INSTALL.md for platform-specific instructions
```

What you need: a plan that includes Grok Bot. Premium, Super and Ultra on The X Subscription include it, with one weekly usage pool shared with Grok and Cursor. Older paid Cursor plans and linked SuperGrok or X Premium+ accounts work too (https://cursor.com/help/grok-bot/plans).

The **Grok Bot build emits workflow SKILL.md files** that Grok Bot and Sand agents invoke with `/` or `@`. Each skill is a self-contained playbook (name, description, operating instructions). The `user-obsidian-second-brain` MCP server (already connected in Grok Bot) provides the vault I/O layer via `obsidian_*` tools (`obsidian_search`, `obsidian_read_note`, `obsidian_save_note`, `obsidian_update_note`, `obsidian_validate_note`, etc.). Skills tell the agent which MCP tool to call and how to structure the data. Set `$OBSIDIAN_VAULT_PATH` to your vault root. No hooks, no scheduled agents - Grok Bot has no hook runtime.

Grok Bot can write a live Page, such as a report, a dashboard, or a plan. The Page opens from a card in the chat, stays in the bot's Library, and you can share it with only you, your team, or anyone with the link. A weekly review or a project dashboard from your vault fits this.

On an iPhone 15 Pro or later, pressing and holding the Action Button starts a voice chat with Grok Bot. You need Grok Bot 1.16 or later, and you set it in iPhone Settings > Action Button > Shortcut. Use it to speak a thought and save it into the vault.

### Run on Hermes / open models

The skill is model-agnostic. The OpenCode build (and the Codex / Gemini builds) are plain instruction files, so they run on whatever model the host CLI is pointed at - including open models like [Nous Research Hermes](https://github.com/NousResearch/hermes-agent). No separate build, no code changes. You set the model on OpenCode's side.

There is also a dedicated **Hermes Agent build** that emits the commands as native Hermes skills (`skills/<category>/<name>/SKILL.md`, agentskills.io-compatible), so Hermes discovers and runs them through its own Skills System rather than via a host CLI:

```bash
bash scripts/build.sh --platform hermes
# then follow dist/hermes/INSTALL.md (copy into ~/.hermes/skills/ or add as a tap)
```

Do not run `hermes plugins install` on this repo's URL. The repo root is not a Hermes plugin (it has no `plugin.yaml`), and Hermes reports success anyway while registering nothing ([#298](https://github.com/eugeniughelbur/obsidian-second-brain/issues/298)). Use the skills build above.

This is the skill/playbook half of the Hermes work; the bounded vault-data half is the [MCP connector](integrations/obsidian-mcp-server/). Native cron and lifecycle-hook integration are tracked in [Issue #79](https://github.com/eugeniughelbur/obsidian-second-brain/issues/79).

Point OpenCode at Hermes via OpenRouter. Authenticate once (`/connect`, search OpenRouter, paste your key - or `export OPENROUTER_API_KEY=...`), then in `opencode.json`:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "model": "openrouter/nousresearch/hermes-4-70b",
  "provider": {
    "openrouter": {
      "models": {
        "nousresearch/hermes-4-70b": {}
      }
    }
  }
}
```

Hermes models on OpenRouter (as of 2026-06, [openrouter.ai](https://openrouter.ai/models?q=hermes)):

| Model id | Best for | Cost (in / out per 1M tokens) |
|---|---|---|
| `nousresearch/hermes-4-70b` | Default. Cheap, capable, 131k context. | $0.13 / $0.40 |
| `nousresearch/hermes-4-405b` | Strongest instruction-following for the synthesis-heavy commands. | $1.00 / $3.00 |
| `nousresearch/hermes-3-llama-3.1-405b:free` | Zero-cost trial (needs any OpenRouter key to authenticate). | free |

For the privacy story, run a smaller Hermes locally through [Ollama](https://ollama.com) or LM Studio and point OpenCode at the local endpoint - no data leaves your machine.

What to expect (open models follow instructions less reliably than Claude, so this is honest, not a promise of parity): the core commands - `/obsidian-save`, `/obsidian-daily`, `/obsidian-capture`, `/obsidian-find`, `/obsidian-task`, and `/research` in free mode - hold up well. The sub-agent-heavy commands and the deep synthesis ones (`/obsidian-architect`, `/obsidian-reconcile`, `/research-deep`) lean hard on instruction-following, so prefer `hermes-4-405b` (or Claude) for those. The AI-first vault rule still applies on every write regardless of model.

### Research toolkit (optional)

The 7 research commands use API keys (2 of them fall back to free sources without any).

**Installed the plugin?** You have no repo checkout, so `install.sh`, `.env.example`, and `uv sync` are not on your disk. Create the env file by hand instead - the research scripts read this path regardless of how you installed, and the plugin's MCP server already runs under `uv run --no-project --with 'mcp<2'`, so there is nothing to `uv sync`:

```bash
mkdir -p ~/.config/obsidian-second-brain
touch ~/.config/obsidian-second-brain/.env
chmod 600 ~/.config/obsidian-second-brain/.env
# then paste the keys from the table below into that file
```

**On Windows** (Git Bash / MSYS2) the file lives under your Windows profile, `%USERPROFILE%\.config\obsidian-second-brain\.env`: that is where Python (`Path.home()`), Claude Code, and the bash scripts resolve the home, even when a corporate `HOME` points at another drive. Bash's own `~` still follows `HOME`, so on such a machine create the file from `USERPROFILE` instead of with the commands above:

```bash
CONFIG="$(cygpath -u "$USERPROFILE")/.config/obsidian-second-brain"
mkdir -p "$CONFIG" && touch "$CONFIG/.env" && chmod 600 "$CONFIG/.env"
```

To keep the file anywhere else, set `OBSIDIAN_ENV_FILE` to its full path; every reader and writer (the research loaders, the eval, the MCP server, the write-time hook, `install.sh`, `scripts/setup.sh`) honors it. On Windows give it a native path (`C:/Users/me/osb.env`, or with backslashes), which bash and Python can both open; the Git Bash spellings `/c/...` and `/cygdrive/c/...` mean something to bash only. This assumes the native Windows Python that `uv` installs; a Cygwin- or MSYS-built Python resolves its home from `HOME` instead, so use `OBSIDIAN_ENV_FILE` there.

**Installed from a clone?** Run `install.sh` and answer "y" to the research prompt, which does the same thing for you. Or do it manually:

```bash
mkdir -p ~/.config/obsidian-second-brain
cp .env.example ~/.config/obsidian-second-brain/.env
chmod 600 ~/.config/obsidian-second-brain/.env
# then paste keys into the file
uv sync   # installs Python deps
```

Keys you need:

| Key | Where | Required for | Cost |
|---|---|---|---|
| `XAI_API_KEY` | [console.x.ai](https://console.x.ai) | `/x-read`, `/x-pulse`, `/research-deep` X pulse, `/youtube` summary | Pay-per-use, ~$0.05/call |
| `PERPLEXITY_API_KEY` | [perplexity.ai/settings/api](https://perplexity.ai/settings/api) | `/research`, `/research-deep` | Pay-per-use, ~$0.02-$0.50/call |
| `GEMINI_API_KEY` | [aistudio.google.com/apikey](https://aistudio.google.com/apikey) | `/notebooklm`, `/youtube` summary (Grok fallback) (vault-grounded synthesis via Gemini File Search) | Free tier covers it. Paid: ~$0.004/call (Flash), ~$0.06/call (Pro). |
| `YOUTUBE_API_KEY` | [console.cloud.google.com](https://console.cloud.google.com) | `/youtube` metadata + comments (optional, transcripts free without) | Free tier 10k units/day |
| `OPENAI_API_KEY` | [platform.openai.com](https://platform.openai.com/api-keys) | `/podcast` Whisper transcription (optional, falls back to show-notes if unset) | ~$0.006/min |

Without keys, the 38 non-research commands work fully, and `/research` + `/research-deep` fall back to free, key-less sources. The rest of the research toolkit degrades gracefully.

### Semantic search (optional, off by default)

Search (`/obsidian-find` and the MCP connector) works out of the box as fast keyword search - **no setup, no model, nothing to install.** You can optionally add a meaning-based layer that finds notes even when your query shares no words with them. It is opt-in by setup and, when present, leads the ranking with keyword search as tiebreak and freshness signals on top (measured on a ~2,350-note vault: keyword recall@10 1.0, paraphrased-question recall@10 77%, and non-English queries went from 13% to 63% recall@5, a 5x gain, with the multilingual default model - full reference in scripts/eval/BASELINE.md). If the model is ever unreachable, search silently falls back to keyword - it never breaks or hangs.

Two ways to provide the embedding model:

- **Local + private (recommended), via [Ollama](https://ollama.com):** install Ollama, `ollama pull bge-m3`, then build the index: `uv run python scripts/eval/semantic_search.py --path "<vault>" --build`. Your notes never leave the machine. Re-run it as you write - see below.
- **No Ollama? Any OpenAI-compatible endpoint.** Set `OBSIDIAN_EMBED_BACKEND=openai`, `OBSIDIAN_EMBED_URL=<base url>`, `OBSIDIAN_EMBED_MODEL=<model>`, and `OBSIDIAN_EMBED_KEY=<key if needed>`. This covers other local runtimes (LM Studio, llama.cpp's server) for free/private use, **or** a cloud API (OpenAI, a gateway) for top quality - note a cloud endpoint means note text leaves your machine, so use `OBSIDIAN_EMBED_EXCLUDE=<folder prefixes>` to keep private folders local-only.

**Keep it current.** The index does not update itself, and a note that is not in it can only be found by literal word match - which on a query in another language means it cannot be found at all. Re-run `--build` regularly; it is incremental, so only new and changed notes re-embed. `/obsidian-health` reports coverage, and search warns on stderr once the index falls more than 5% behind (tune with `OBSIDIAN_INDEX_STALE_WARN_PCT`).

Knobs: `OBSIDIAN_SEARCH_SEMANTIC=0` disables the layer entirely. `OBSIDIAN_EMBED_MAX_CHUNKS=<n>` raises the per-note embedding cap from the default 8 chunks (~9,600 characters); a long-form vault of research dossiers or book-length notes embeds more of each note at the cost of a slower build, and text past the cap is not embedded. A value below 1 or one that is not a number falls back to 8 and says so on stderr, because the cap is applied as a slice: `0` would embed nothing and drop the note from the index. `OBSIDIAN_RRF_LEX_DEPTH=<n>` caps how many lexical results get a vote in the hybrid fusion (default 25, which caps nothing); lower it to 5-10 when a tail of term-frequency matches pushes an exact match out of the top results (#262). The index file is large and regenerable - gitignore it.

### Capture from your phone (optional)

Send a voice note, text, photo, PDF or link to a private Telegram bot, and it lands in your vault. A small poller on your computer does the work and replies to confirm:

- **Voice** is transcribed (OpenAI Whisper, or local Whisper with no key) and added to today's daily note.
- **Photos** are read and filed to the note they belong to. **PDFs** become a literature note. **Links** go to `/youtube`, `/x-read` or `/research`.
- Every capture also joins a `catchup.md` queue. Back at your laptop, run `/obsidian-catchup` to review and integrate them together.

Create the bot with @BotFather, then run one command:

```bash
cd integrations/telegram-journal && ./setup.sh
```

You need a Telegram bot token, an Anthropic API key, and for voice an OpenAI key or local Whisper. Full guide: [integrations/telegram-journal](integrations/telegram-journal/README.md).

---

## FAQ

### Can I search without an agent?
Run `uv run python scripts/vault_search.py "query" --limit 6 --lexical` for a JSON result array.
The script uses `OBSIDIAN_VAULT_PATH` from the environment or toolkit config; omit `--lexical` to follow the existing semantic-search environment setting.

### Codex vs Claude Code: do I have to pick one?
No. Crew lets Claude Code, Codex and Cursor work as one team. After every job, each agent writes one line to a shared logbook, and the others read it before they answer. Run `/crew setup` once. See [Crew](#crew-one-logbook-for-all-your-agents).

### How do Claude Code, Codex and Cursor share memory?
Through Crew's logbook: plain markdown files in `~/crew` or in `wiki/team/` inside your vault. Claude Code and Codex read new lines through their `SessionStart` and `UserPromptSubmit` hooks. Cursor reads through `sessionStart` and `postToolUse`. Grok Bot reads the same folder from its profile instructions.

### Does Crew need Obsidian?
No. Crew is one standard-library Python file and a folder of markdown files. Point it at `~/crew` and it never touches a vault. Pick a vault only if you want the log next to your notes.

### Can a log line give my agent orders?
Every read starts with a header that says the lines are records, not instructions, and each field is cleaned to one line. That framing helps a model separate data from orders; it can't guarantee it. Crew runs no background loop, so nothing acts on a line by itself. A lesson changes an agent's rules only after you run `keep`.

### What is a Claude Code skill?
A Claude Code skill is a reusable behavior package for Anthropic's Claude Code CLI. It bundles slash commands, scripts, references, and operating instructions that Claude loads automatically. Skills give Claude domain expertise without prompt-engineering each session.

### Is this an Obsidian plugin or a Claude Code skill?
This is a Claude Code skill, not an Obsidian plugin. An Obsidian plugin lives inside Obsidian and adds UI features there. A Claude Code skill lives inside Claude Code (Anthropic's terminal AI coding agent) and gives Claude the ability to read, write, and reason over your Obsidian vault from outside Obsidian. You install this skill into Claude Code, not into Obsidian. Your vault is unchanged, just better-leveraged.

### What's the difference between an Obsidian Claude Code skill and a regular Obsidian plugin?
An Obsidian plugin runs inside Obsidian and is written in TypeScript against Obsidian's plugin API. A Claude Code skill for Obsidian runs inside Claude Code and is written as a set of markdown command files plus optional Python scripts. Plugins are constrained to what Obsidian's API exposes. Skills are constrained only by what Claude can do in your shell, which is why this skill can do things plugins can't: pull live web research into vault notes, run scheduled agents that update your vault while you sleep, and synthesize knowledge across years of notes using Anthropic's Claude.

### How do I add this Obsidian Claude skill to Claude Code?
Run the one-line installer from the [Install](#install) section above. It clones the repo to `~/.claude/skills/obsidian-second-brain` and symlinks the slash commands into `~/.claude/commands/` so Claude Code picks them up automatically. Restart Claude Code after install. The skill loads on every session that touches an Obsidian vault.

### Does this work with Codex CLI, Gemini CLI, or OpenCode?
Yes. The repo ships a build script that compiles the platform-neutral source into eight platform-specific outputs: Claude Code (slash commands + `CLAUDE.md`), Codex CLI (native Agent Skills), Gemini CLI (`GEMINI.md` + `.gemini/commands/`), OpenCode (`AGENTS.md` + `.opencode/commands/`), Hermes (native skills), Pi (`package.json` + `.pi/`), Grok Bot (workflow SKILL.md files + MCP), and a unified Agent Skills build (one `.agents/skills/` tree for Antigravity / Codex / OpenCode / GitHub Copilot CLI and any other Agent Skills harness). Run `bash scripts/build.sh --platform codex-cli` (or another platform name), then copy the resulting `dist/<platform>/` tree into your vault. The non-Claude builds either emit native skills or auto-generate a routing table that maps natural-language triggers to command files, so the same 44 cross-platform commands work no matter which CLI you use (the calendar command is Claude Code only, since it depends on the Google Calendar MCP). The vault rules (AI-first notes, frontmatter, wikilinks, recency markers) are identical across every platform.

### Does this run on Hermes or other open models?
Yes. The skill is model-agnostic - the OpenCode, Codex, and Gemini builds are plain instruction files, so they run on whatever model the host CLI uses, including open models like Nous Research Hermes. The most common path is OpenCode pointed at Hermes via OpenRouter (or a local Hermes through Ollama / LM Studio for full privacy). See "Run on Hermes / open models" in the Install section for the exact config. Honest expectation: the core save / daily / capture / find / task commands and free-mode `/research` hold up well; the sub-agent-heavy and deep-synthesis commands (`/obsidian-architect`, `/obsidian-reconcile`, `/research-deep`) want a stronger instruction-follower, so prefer `hermes-4-405b` or Claude for those.

### Does this work with Obsidian Sync?
Yes. The skill writes to your vault as standard markdown files. Obsidian Sync, iCloud, Syncthing, and Git-based sync all work without modification.

### Can I add notes from my phone?
Yes, through the optional Telegram bot. Send a voice note while you walk, and it is transcribed into today's daily note. Photos, PDFs and links are filed too. See [Capture from your phone](#capture-from-your-phone-optional).

### Do I need API keys to use this?
Mostly no. The vault commands (`/obsidian-save`, `/obsidian-daily`, etc.) need no API keys. `/research` and `/research-deep` are also key-free now - with no Perplexity key they automatically fall back to free, key-less sources (Wikipedia, HackerNews, arXiv, Reddit, and more) and Claude synthesizes the dossier. The remaining research commands (`/x-read`, `/x-pulse`, `/notebooklm`, `/youtube`, `/podcast`) need their respective keys (xAI Grok, Perplexity, Google Gemini, optionally YouTube Data API v3 / OpenAI Whisper) and exit with a clear setup message when one is missing. The calendar command (`/obsidian-calendar`, all four modes) needs the Google Calendar MCP connector rather than an API key.

### How is this different from Notion AI or Mem?
Notion AI and Mem are closed-source SaaS products that own your data. This skill stores everything as plain markdown in your local Obsidian vault, with no vendor lock-in. The AI is on top of your data, not behind it. You can switch tools or stop using the skill at any point and still have your full vault.

### Can it document my codebase?
Yes - that is the headline of v0.10 ("The Architect"). The `/obsidian-architect` command scans a software project (languages, modules, dependencies, entry points) and writes maintained architecture notes into your vault: an overview with a diagram, one note per module, and a key-decisions note mined from your git history. Re-running it refreshes only the generated content and never overwrites the notes you added by hand, so the docs stay current as the code changes. It puts "how does this project work, and why" in the same vault as your ideas and decisions.

### How does the code documentation stay current without overwriting my edits?
`/obsidian-architect` writes generated content inside sentinel markers (`` blocks). On a re-run it replaces only what is inside those blocks and leaves your `` blocks (and anything outside the markers) untouched. So you can hand-annotate the architecture notes and re-run the scan as the code evolves without losing your additions.

### What is the AI-first vault rule?
The principle that vault notes are written for future agent to retrieve and reason over, not for human reading. Notes have machine-readable structure, recency markers per claim, mandatory `[[wikilinks]]`, source URLs preserved verbatim, and confidence levels. See [`references/ai-first-rules.md`](references/ai-first-rules.md) for the full specification with frontmatter schemas per note type.

### Is this safe to run on my existing vault?
Yes. The skill never deletes or modifies notes destructively without explicit confirmation. Existing notes stay as-is. New notes follow the AI-first rule. `/obsidian-health` flags pre-AI-first notes so you can update them on your own schedule.

### What is OKM (Open Knowledge Metabolism)?
The maintenance layer, given a name. Its one rule: every stored fact must be timeless, dated, or a pointer - so a knowledge folder can never quietly fill with facts that used to be true. Slow knowledge is stored; fast facts are linked to their live source with an `as of` stamp instead of copied in. It ships as a one-page spec ([`references/freshness-policy.md`](references/freshness-policy.md)) and a stdlib-only linter ([`scripts/freshness_lint.py`](scripts/freshness_lint.py)) that `/obsidian-health` runs, and it is storage-agnostic (any markdown folder an AI maintains). Think of it as the companion to OKF (Open Knowledge Format). OKF v0.2 gives you fields for recording staleness (`status`, `stale_after`, `verified`); OKM is the rule about what may be stored bare in the first place, plus the linter that fails the build when it is not.

### What does `/research-deep` do that `/research` doesn't?
`/research` runs a single Perplexity query and returns a dossier with citations. `/research-deep` is vault-first: it scans your existing notes, identifies what you already know about the topic, spawns 3-5 targeted follow-up searches to fill only the gaps, and produces a delta report (what's new, what's confirmed, contradictions to resolve, recommended vault updates). Vault-first means you stop re-researching what's already in your notes.

### What do the research commands cost?
Approximate per-call costs as of 2026-04: `/x-read` ~$0.05, `/x-pulse` ~$0.13, `/research` ~$0.04, `/research-deep` ~$0.40-$0.80, `/youtube` ~$0.04, `/podcast` ~$0.04 Grok call (plus ~$0.006/min if Whisper is used; free if RSS provides a `<podcast:transcript>` tag or you accept the show-notes fallback). Costs for paid calls (Grok, Perplexity, Gemini) are logged to `~/.research-toolkit/usage.log` for visibility. No hard caps. You're trusted to monitor your own spend.

### Can I use this on Windows or Linux?
The core vault commands work anywhere Claude Code runs. `install.sh` supports Linux, macOS, and Windows (MSYS2/Git Bash): on Linux/macOS slash commands are symlinked so `git pull` keeps them current; on Windows they are copied and `update.sh` refreshes them. The research toolkit auto-open step uses `open` on macOS, `xdg-open` on Linux, and `notepad` on Windows. On Windows the config file and Claude Code state hang off `%USERPROFILE%` (see the research toolkit section); `OBSIDIAN_ENV_FILE` relocates the config file for every part of the toolkit.

### A research command said it saved, but my daily note or `log.md` did not change (Windows)
Since #248 the research toolkit (`/research`, `/research-deep`, `/x-pulse`, `/youtube`, `/podcast`) reads and writes vault files as UTF-8 on every platform. Before appending to today's daily note or to `log.md` it checks that the existing file is valid UTF-8. A file that is not - typically a note an earlier Windows run rewrote in the system code page (cp1252) before that fix - is left exactly as it is and the append is skipped, because UTF-8 bytes added to a cp1252 file would leave something that decodes correctly as neither. The research note itself is still saved; only the daily-note or log append is skipped, and a `[vault]` line on stderr says so. Re-save that one file as UTF-8 once (Obsidian and VS Code both do this on save, or `iconv -f cp1252 -t utf-8 old.md > new.md`) and the next run appends normally. Files the toolkit creates are always UTF-8.

### Can I have a separate vault per project (multi-repo workflows)?
Yes. The default `scripts/setup.sh` writes `OBSIDIAN_VAULT_PATH` globally to `~/.claude/settings.json`, but every hook in this skill reads that env var at fire-time. Claude Code merges per-project `.claude/settings.json` on top of the global one, so you can put `{"env": {"OBSIDIAN_VAULT_PATH": "/path/to/repo-vault"}}` in each repo's `.claude/settings.json` and Claude will use that repo's vault whenever you launch a session from that directory. The slash commands and hooks remain globally installed; only the vault path changes. Full recipe in [`SKILL.md`](SKILL.md#per-project-vaults-multi-repo-workflows). One thing this does NOT give you: isolation within a single vault (no `--scope` on commands yet).

### Can I run this alongside another Obsidian plugin?
Yes, and nothing breaks at the hook level. Claude Code merges hook entries instead of replacing them, and "All matching hooks run in parallel" ([docs](https://code.claude.com/docs/en/hooks)). Both SessionStart hooks fire and both outputs reach your context.

The cost is a schema clash, not a crash. Each plugin states its own folder map and frontmatter fields for the same vault, so a note can land under either one. Since #300 this skill detects the other hook and opens its injected context with a precedence note naming what it found, and the vault's own `_CLAUDE.md` governs every write. It detects only. Your other plugin is never edited, disabled or unregistered.

To see what a session would find, run `python scripts/vault_plugin_scan.py`. To run only one system, remove the other plugin or its hook entry yourself.

### How do I update to the latest version?
```bash
cd ~/.claude/skills/obsidian-second-brain && git pull
```
On Linux/macOS: nothing else to run - slash commands are symlinked so they pick up the new files automatically. On Windows: also run `bash update.sh` to refresh the copied command files. Restart Claude Code after either path. See [CHANGELOG.md](CHANGELOG.md) for what's in each release.

### Where do I file issues or feature requests?
Command reference: https://eugeniughelbur.github.io/obsidian-second-brain/ - every command, with the plain-language phrases that trigger it in English, German, Spanish, Portuguese and Simplified Chinese.

Retrieval benchmark: [scripts/eval/BENCHMARK.md](scripts/eval/BENCHMARK.md) - a reproducible 300-note synthetic corpus and three query sets, so the search numbers are something you can run yourself rather than something this README claims.

The rule on its own: [AI-FIRST.md](AI-FIRST.md) - the note spec as a 50-line block you can paste into any `CLAUDE.md` or `AGENTS.md`. Installs nothing, works without this project, keep the attribution line.

GitHub Issues: https://github.com/eugeniughelbur/obsidian-second-brain/issues. PRs welcome, see Contributing below.

---

## Philosophy

Most second brain tools make you the janitor.

This skill inverts that. You think, work, and talk. Claude handles the memory. Then it uses that memory to make you think better -- surfacing what you'd miss, challenging what you'd assume, connecting what you'd never link, and synthesizing patterns you didn't ask for.

The vault doesn't grow. It evolves.

**Your notes are the moat.**

Inspired by [Andrey Karpathy's LLM-Wiki](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f).

---

## Contributing

**Want a specific place to start?** [Good first issues](https://github.com/eugeniughelbur/obsidian-second-brain/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) are scoped to name the exact files and lines, what to watch out for, and how big the change is. They range from adding trigger phrases in a language you speak (no Python at all) to a one-command lint fix to a new slash command. Comment on one to claim it.

PRs welcome more generally:
- New thinking tools
- Note type schemas (habits, books, investments)
- MCP integrations (Calendar, Linear, Slack)
- Alternative vault structures
- VS Code / Cursor setup guides

**Own a platform.** Eight builds, one maintainer who can test two. [adapters/OWNERS.md](adapters/OWNERS.md) has the open list; using the platform is the whole qualification, and your handle ships inside that build.

Building a domain-specific fork (academic, legal, finance, medical)? See [ECOSYSTEM.md](ECOSYSTEM.md). The upstream repo ships primitives; forks own the domain knowledge. First proof case: [`scholarbrain`](https://github.com/SHzzzAyys/scholarbrain) for academic research.

Customizing your own fork? Copy [`references/DELTAS.template.md`](references/DELTAS.template.md) to a `DELTAS.md` at your fork root and record your local deviations there. Upstream never touches that file, so you can keep merging `upstream/main` cleanly instead of fighting conflicts in stock commands.

### Contributors

This project is maintained by one person but built with many. 18+ external contributors have landed merged PRs - security fixes, platform ports (Pi came from a contributor), Windows compatibility, translations, and the first automated test. Ideas from closed or stalled PRs get reimplemented with the original author credited as co-author rather than dropped. See the full list on the [contributors graph](https://github.com/eugeniughelbur/obsidian-second-brain/graphs/contributors).

If your PR goes quiet mid-review, that is normal life - the idea stays on the table, and if it lands later you stay on the commit.

---

## Sponsors

Sponsorships help fund ongoing development of obsidian-second-brain: new commands, research-toolkit API costs, and ongoing maintenance.

[![Sponsor on GitHub](https://img.shields.io/badge/Sponsor-eugeniughelbur-EA4AAA?style=for-the-badge&logo=github-sponsors&logoColor=white)](https://github.com/sponsors/eugeniughelbur)

---

## Author

Built by **Eugeniu Ghelbur**, AI Automation Engineer @ Single Grain

*If this skill helped you, the best thanks is following along.*

</td>
</tr>
</table>

</div>

---

## License

MIT