eugeniughelbur/obsidian-second-brain

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

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.

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.

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

Setup, exact commands, and limits. 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 Karpathy's LLM Wiki pattern: 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 OKM - Open Knowledge Metabolism: 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 · founders and operators · writers · researchers - pick a preset at setup

Start with three: /obsidian-init to set up, /obsidian-save to capture, /obsidian-find to recall. The other 42 are there when you need them.

auto-synthesis · thinking tools that argue with you

live research from X, the web, and YouTube · 4 scheduled agents · 4 role presets

write-time AI-first validator · /create-command interview flow · multilingual trigger schema

Install → · Demos · See it in action · All commands · Presets · OKM · Discussions

One /obsidian-save - five cross-linked notes. Real footage, synthetic vault. More demos →

If this looks useful, star the repo. 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. See the changelog →

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.

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

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

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 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.

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

From the blog · The AI Operator →

Featured: "HUGE update on obsidian-second-brain: The Architect"
/obsidian-architect · document your codebase into your vault · the full before-and-after

Deep dive: "I rebuilt Karpathy's LLM Wiki. Here's what's missing from the original."
Why append-only breaks at scale · the AI-First Vault Principle · three bugs in v1

Origin story: "I built this for myself. Then 1,374 strangers cloned it."
Two disconnected tools · the institutional-amnesia problem · 1,000+ stars in 7 weeks

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

Research toolkit · dual-track
/x-read · /x-pulse · /research · /research-deep · /notebooklm · /youtube · /podcast

Open-web track · /research-deep via Perplexity + Grok. Pulls fresh signal from outside.
Source-grounded track · /notebooklm 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 Eugeniu Ghelbur · AI Automation Engineer @ Single Grain
building in public · sharing what works

  +------------------------------------------+
  |                                          |
  |   LAYER 1: Operations (31 commands)      |
  |   Claude remembers everything            |
  |                                          |
  +------------------------------------------+
  |                                          |
  |   LAYER 2: Thinking Tools (9 commands)   |
  |   Claude thinks with you                 |
  |                                          |
  +------------------------------------------+
  |                                          |
  |   LAYER 3: Context Engine (1 command)    |
  |   Claude knows who you are               |
  |                                          |
  +------------------------------------------+
  |                                          |
  |   LAYER 4: Research Toolkit (7 commands) |
  |   Claude pulls knowledge in              |
  |                                          |
  +------------------------------------------+
  |                                          |
  |   ALWAYS ON                              |
  |   Background agent + 4 scheduled agents  |
  |   Auto-synthesis + save reminders        |
  |                                          |
  +------------------------------------------+

48 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 47.

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.

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).

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.

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

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..."

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 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

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), enforced by a linter (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.

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

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:

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

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 pinned to Read,Write,Edit,Glob,Grep, 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:

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.

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. 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.

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

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:

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 (or one of the other six platforms below), git, and 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 for local semantic search, openai-whisper (installed on first audio ingest, pulls in PyTorch). No API keys needed for the core vault commands.

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:

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.

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 48 commands, the skill manual, the session-context hook, the opt-in background agent (inert until you arm it - see 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:

"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 48). 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):

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

Or step by step:

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 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):

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 and OpenCode users: prefer the Agent Skills build 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.

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: 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 after building for platform-specific notes.

Antigravity, Codex CLI, OpenCode, and GitHub Copilot CLI have all converged on the open Agent 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.

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 for the full story (skills.sh, manual copy, per-harness notes, and the optional always-on vault-routing rule).

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 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.)

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

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.

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. 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 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). Use the skills build above.

This is the skill/playbook half of the Hermes work; the bounded vault-data half is the MCP connector. Native cron and lifecycle-hook integration are tracked in Issue #79.

Point OpenCode at Hermes via OpenRouter. Authenticate once (/connect, search OpenRouter, paste your key - or export OPENROUTER_API_KEY=...), then in opencode.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):

For the privacy story, run a smaller Hermes locally through Ollama 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.

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:

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:

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:

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:

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.

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: 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.

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.

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.

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.

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.

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.

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.

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.

Run the one-line installer from the 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.

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.

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.

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

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.

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.

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.

/obsidian-architect writes generated content inside sentinel markers (<!-- @generated --> blocks). On a re-run it replaces only what is inside those blocks and leaves your <!-- @user --> 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.

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 for the full specification with frontmatter schemas per note type.

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.

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) and a stdlib-only linter (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.

/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.

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.

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.

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.

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. One thing this does NOT give you: isolation within a single vault (no --scope on commands yet).

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). 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.

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 for what's in each release.

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 - 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 - 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.

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.

Want a specific place to start? Good first issues 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 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. The upstream repo ships primitives; forks own the domain knowledge. First proof case: scholarbrain for academic research.

Customizing your own fork? Copy 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.

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.

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.

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

MIT