eugeniughelbur/obsidian-second-brainPublic

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.

AI summary: A structured methodology and configuration set for building a robust 'Second Brain' knowledge base in Obsidian.

Stars
5.4K
+55 today
Forks
656
Watchers
31
Open issues
6
Open PRs
1
Contributors
~58
Commits
678
Branches
25
Views (30d)
6

PythonMITCreated Mar 24, 2026Last push 2d agoLatest release v0.20.0+96 stars this week+585 this month

Quick answers

What is obsidian-second-brain?
A structured methodology and configuration set for building a robust 'Second Brain' knowledge base in Obsidian.
What does obsidian-second-brain do?
Obsidian Second Brain provides a comprehensive template and methodological framework for organizing personal knowledge using the Obsidian application. It implements established knowledge management concepts, such as PARA (Projects, Areas, Resources, Archives), structuring the vault for optimal information retrieval and linking. The repository includes pre-configured folders, templates, and plugin recommendations designed to minimize setup time and maximize productivity. It transforms a blank Obsidian installation into a highly organized, interconnected digital workspace for managing complex research and personal data.
Who is obsidian-second-brain for?
Knowledge workers, students, and researchers looking for a structured, pre-configured framework to implement a Second Brain in Obsidian. It requires a solid understanding of ai and related concepts.
How do I get started with obsidian-second-brain?
Clone or download the repository to use as a starting template for your Obsidian vault.
How popular is obsidian-second-brain on GitHub?
eugeniughelbur/obsidian-second-brain has 5,379 stars and 656 forks on GitHub, and gained 96 stars in the last 7 days.
What license does obsidian-second-brain use?
eugeniughelbur/obsidian-second-brain is released under the MIT license.

Star history

since Jul 29, 2026
02K4KJul 2026Sep 2026Oct 2026Nov 2026
5.4K stars as of Nov 18, 2026. Measured daily since Jul 29, 2026; GitHub no longer exposes earlier star timestamps.

Update history

4 recorded
  • Oct 28, 2026New release v0.20.0 (previously v0.18.0).
  • Oct 17, 2026New release v0.18.0 (previously v0.17.0).
  • Oct 17, 2026Description changed from "Persistent memory for Claude Code and 6 other CLI agents, stored as plain markdown in your Obsidian vault. Stop re-expla" to "Persistent memory for Claude Code, Codex and 6 other AI agents, stored as plain markdown in your Obsidian vault. New: Cr".
  • Oct 8, 2026New release v0.17.0 (previously v0.16.0).

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-23: 0 commits2025-11-24: 0 commits2025-11-25: 0 commits2025-11-26: 0 commits2025-11-27: 0 commits2025-11-28: 0 commits2025-11-29: 0 commits2025-11-30: 0 commits2025-12-01: 0 commits2025-12-02: 0 commits2025-12-03: 0 commits2025-12-04: 0 commits2025-12-05: 0 commits2025-12-06: 0 commits2025-12-07: 0 commits2025-12-08: 0 commits2025-12-09: 0 commits2025-12-10: 0 commits2025-12-11: 0 commits2025-12-12: 0 commits2025-12-13: 0 commits2025-12-14: 0 commits2025-12-15: 0 commits2025-12-16: 0 commits2025-12-17: 0 commits2025-12-18: 0 commits2025-12-19: 0 commits2025-12-20: 0 commits2025-12-21: 0 commits2025-12-22: 0 commits2025-12-23: 0 commits2025-12-24: 0 commits2025-12-25: 0 commits2025-12-26: 0 commits2025-12-27: 0 commits2025-12-28: 0 commits2025-12-29: 0 commits2025-12-30: 0 commits2025-12-31: 0 commits2026-01-01: 0 commits2026-01-02: 0 commits2026-01-03: 0 commits2026-01-04: 0 commits2026-01-05: 0 commits2026-01-06: 0 commits2026-01-07: 0 commits2026-01-08: 0 commits2026-01-09: 0 commits2026-01-10: 0 commits2026-01-11: 0 commits2026-01-12: 0 commits2026-01-13: 0 commits2026-01-14: 0 commits2026-01-15: 0 commits2026-01-16: 0 commits2026-01-17: 0 commits2026-01-18: 0 commits2026-01-19: 0 commits2026-01-20: 0 commits2026-01-21: 0 commits2026-01-22: 0 commits2026-01-23: 0 commits2026-01-24: 0 commits2026-01-25: 0 commits2026-01-26: 0 commits2026-01-27: 0 commits2026-01-28: 0 commits2026-01-29: 0 commits2026-01-30: 0 commits2026-01-31: 0 commits2026-02-01: 0 commits2026-02-02: 0 commits2026-02-03: 0 commits2026-02-04: 0 commits2026-02-05: 0 commits2026-02-06: 0 commits2026-02-07: 0 commits2026-02-08: 0 commits2026-02-09: 0 commits2026-02-10: 0 commits2026-02-11: 0 commits2026-02-12: 0 commits2026-02-13: 0 commits2026-02-14: 0 commits2026-02-15: 0 commits2026-02-16: 0 commits2026-02-17: 0 commits2026-02-18: 0 commits2026-02-19: 0 commits2026-02-20: 0 commits2026-02-21: 0 commits2026-02-22: 0 commits2026-02-23: 0 commits2026-02-24: 0 commits2026-02-25: 0 commits2026-02-26: 0 commits2026-02-27: 0 commits2026-02-28: 0 commits2026-03-01: 0 commits2026-03-02: 0 commits2026-03-03: 0 commits2026-03-04: 0 commits2026-03-05: 0 commits2026-03-06: 0 commits2026-03-07: 0 commits2026-03-08: 0 commits2026-03-09: 0 commits2026-03-10: 0 commits2026-03-11: 0 commits2026-03-12: 0 commits2026-03-13: 0 commits2026-03-14: 0 commits2026-03-15: 0 commits2026-03-16: 0 commits2026-03-17: 0 commits2026-03-18: 0 commits2026-03-19: 0 commits2026-03-20: 0 commits2026-03-21: 0 commits2026-03-22: 0 commits2026-03-23: 0 commits2026-03-24: 7 commits2026-03-25: 3 commits2026-03-26: 0 commits2026-03-27: 0 commits2026-03-28: 0 commits2026-03-29: 0 commits2026-03-30: 0 commits2026-03-31: 0 commits2026-04-01: 0 commits2026-04-02: 0 commits2026-04-03: 0 commits2026-04-04: 0 commits2026-04-05: 3 commits2026-04-06: 11 commits2026-04-07: 3 commits2026-04-08: 0 commits2026-04-09: 8 commits2026-04-10: 0 commits2026-04-11: 0 commits2026-04-12: 0 commits2026-04-13: 0 commits2026-04-14: 0 commits2026-04-15: 0 commits2026-04-16: 0 commits2026-04-17: 0 commits2026-04-18: 0 commits2026-04-19: 2 commits2026-04-20: 0 commits2026-04-21: 0 commits2026-04-22: 2 commits2026-04-23: 1 commit2026-04-24: 0 commits2026-04-25: 2 commits2026-04-26: 13 commits2026-04-27: 17 commits2026-04-28: 0 commits2026-04-29: 2 commits2026-04-30: 0 commits2026-05-01: 0 commits2026-05-02: 1 commit2026-05-03: 0 commits2026-05-04: 0 commits2026-05-05: 0 commits2026-05-06: 2 commits2026-05-07: 2 commits2026-05-08: 0 commits2026-05-09: 0 commits2026-05-10: 2 commits2026-05-11: 4 commits2026-05-12: 0 commits2026-05-13: 6 commits2026-05-14: 1 commit2026-05-15: 3 commits2026-05-16: 2 commits2026-05-17: 0 commits2026-05-18: 1 commit2026-05-19: 0 commits2026-05-20: 3 commits2026-05-21: 1 commit2026-05-22: 1 commit2026-05-23: 0 commits2026-05-24: 4 commits2026-05-25: 0 commits2026-05-26: 0 commits2026-05-27: 11 commits2026-05-28: 3 commits2026-05-29: 0 commits2026-05-30: 4 commits2026-05-31: 9 commits2026-06-01: 2 commits2026-06-02: 0 commits2026-06-03: 0 commits2026-06-04: 3 commits2026-06-05: 2 commits2026-06-06: 1 commit2026-06-07: 0 commits2026-06-08: 1 commit2026-06-09: 0 commits2026-06-10: 0 commits2026-06-11: 1 commit2026-06-12: 1 commit2026-06-13: 0 commits2026-06-14: 3 commits2026-06-15: 3 commits2026-06-16: 0 commits2026-06-17: 8 commits2026-06-18: 0 commits2026-06-19: 0 commits2026-06-20: 0 commits2026-06-21: 0 commits2026-06-22: 2 commits2026-06-23: 0 commits2026-06-24: 0 commits2026-06-25: 0 commits2026-06-26: 0 commits2026-06-27: 28 commits2026-06-28: 5 commits2026-06-29: 3 commits2026-06-30: 0 commits2026-07-01: 0 commits2026-07-02: 0 commits2026-07-03: 7 commits2026-07-04: 1 commit2026-07-05: 1 commit2026-07-06: 2 commits2026-07-07: 2 commits2026-07-08: 0 commits2026-07-09: 0 commits2026-07-10: 2 commits2026-07-11: 32 commits2026-07-12: 14 commits2026-07-13: 3 commits2026-07-14: 0 commits2026-07-15: 0 commits2026-07-16: 4 commits2026-07-17: 2 commits2026-07-18: 25 commits2026-07-19: 0 commits2026-07-20: 1 commit2026-07-21: 1 commit2026-07-22: 2 commits2026-07-23: 2 commits2026-07-24: 0 commits2026-07-25: 9 commits2026-07-26: 38 commits2026-07-27: 5 commits2026-07-28: 1 commit2026-07-29: 0 commits2026-07-30: 0 commits2026-07-31: 6 commits2026-08-01: 3 commits2026-08-02: 0 commits2026-08-03: 0 commits2026-08-04: 5 commits2026-08-05: 0 commits2026-08-06: 0 commits2026-08-07: 0 commits2026-08-08: 2 commits2026-08-09: 0 commits2026-08-10: 0 commits2026-08-11: 0 commits2026-08-12: 0 commits2026-08-13: 0 commits2026-08-14: 0 commits2026-08-15: 7 commits2026-08-16: 5 commits2026-08-17: 0 commits2026-08-18: 0 commits2026-08-19: 1 commit2026-08-20: 0 commits2026-08-21: 1 commit2026-08-22: 0 commits2026-08-23: 0 commits2026-08-24: 2 commits2026-08-25: 0 commits2026-08-26: 3 commits2026-08-27: 5 commits2026-08-28: 1 commit2026-08-29: 0 commits2026-08-30: 6 commits2026-08-31: 0 commits2026-09-01: 1 commit2026-09-02: 6 commits2026-09-03: 8 commits2026-09-04: 4 commits2026-09-05: 1 commit2026-09-06: 3 commits2026-09-07: 1 commit2026-09-08: 1 commit2026-09-09: 0 commits2026-09-10: 0 commits2026-09-11: 0 commits2026-09-12: 0 commits2026-09-13: 14 commits2026-09-14: 5 commits2026-09-15: 9 commits2026-09-16: 3 commits2026-09-17: 0 commits2026-09-18: 4 commits2026-09-19: 1 commit2026-09-20: 3 commits2026-09-21: 0 commits2026-09-22: 0 commits2026-09-23: 0 commits2026-09-24: 3 commits2026-09-25: 1 commit2026-09-26: 5 commits2026-09-27: 0 commits2026-09-28: 8 commits2026-09-29: 2 commits2026-09-30: 0 commits2026-10-01: 1 commit2026-10-02: 0 commits2026-10-03: 0 commits2026-10-04: 0 commits2026-10-05: 2 commits2026-10-06: 0 commits2026-10-07: 0 commits2026-10-08: 0 commits2026-10-09: 0 commits2026-10-10: 3 commits2026-10-11: 2 commits2026-10-12: 1 commit2026-10-13: 0 commits2026-10-14: 0 commits2026-10-15: 1 commit2026-10-16: 0 commits2026-10-17: 3 commits2026-10-18: 0 commits2026-10-19: 2 commits2026-10-20: 10 commits2026-10-21: 2 commits2026-10-22: 0 commits2026-10-23: 0 commits2026-10-24: 11 commits2026-10-25: 3 commits2026-10-26: 2 commits2026-10-27: 4 commits2026-10-28: 4 commits2026-10-29: 1 commit2026-10-30: 0 commits2026-10-31: 0 commits2026-11-01: 0 commits2026-11-02: 0 commits2026-11-03: 0 commits2026-11-04: 5 commits2026-11-05: 0 commits2026-11-06: 0 commits2026-11-07: 5 commits2026-11-08: 5 commits2026-11-09: 2 commits2026-11-10: 4 commits2026-11-11: 0 commits2026-11-12: 0 commits2026-11-13: 0 commits2026-11-14: 4 commits2026-11-15: 3 commits2026-11-16: 1 commit2026-11-17: 0 commits2026-11-18: 1 commit2026-11-19: 0 commits2026-11-20: 0 commits2026-11-21: 0 commits
563 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Very active

    563 commits in 52 weeks

  • Well documented

    High community health score

  • Permissive license

    MIT

  • Continuous integration

    Automated checks passing

What obsidian-second-brain does

Obsidian Second Brain provides a comprehensive template and methodological framework for organizing personal knowledge using the Obsidian application. It implements established knowledge management concepts, such as PARA (Projects, Areas, Resources, Archives), structuring the vault for optimal information retrieval and linking. The repository includes pre-configured folders, templates, and plugin recommendations designed to minimize setup time and maximize productivity. It transforms a blank Obsidian installation into a highly organized, interconnected digital workspace for managing complex research and personal data.

Knowledge workers, students, and researchers looking for a structured, pre-configured framework to implement a Second Brain in Obsidian. It requires a solid understanding of ai and related concepts.

  • PARA method implementation: Structures the vault logically into Projects, Areas, Resources, and Archives for clear organization.
  • Pre-configured templates: Includes ready-to-use templates for daily notes, project planning, and reading summaries.
  • Plugin recommendations: Curates a list of essential Obsidian plugins that enhance the Second Brain methodology.
  • Interconnected architecture: Promotes robust bi-directional linking strategies to build a highly networked knowledge graph.
  • Streamlined onboarding: Provides a fully structured starting point to eliminate the friction of configuring a new Obsidian vault.

Where teams use it

Personal Knowledge Management

Organize extensive personal notes, research, and ideas into a highly structured and easily retrievable digital vault.

Project Tracking

Utilize the provided templates to manage ongoing projects and associated resources clearly within Obsidian.

Research Organization

Structure complex academic or professional research using logical folder hierarchies and bi-directional linking.

Rapid Vault Setup

Instantly deploy a fully configured, methodology-backed Obsidian workspace without spending hours on initial setup.

Getting started: Clone or download the repository to use as a starting template for your Obsidian vault.

README

main branch

obsidian-second-brain: your vault, alive. 8 agents, 48 commands, free and open source. Runs on Claude Code, Codex, Gemini, OpenCode, Antigravity, Hermes, Pi, and Grok Bot, plus Crew: one logbook for Claude Code, Codex, Cursor, and Grok Bot.

obsidian-second-brain: AI second brain for Obsidian - persistent memory for Claude Code, Codex, Cursor and Grok Bot

Your AI second brain for Obsidian. Free, open source, and plain Markdown you own.
Talk to Claude as usual. It saves what matters to your vault and remembers it next time.

Install · See it work · All commands · Crew · FAQ · Changelog

Claude Code plugin Also runs in Codex, Gemini CLI, OpenCode and Grok Bot Release License: MIT Stars

Free newsletter: what I learn building this, 3 posts a week. Subscribe to The AI Operator →

Claude forgets you when a chat ends. Your Obsidian vault doesn't. This skill connects the two, so every chat adds to one set of linked notes that the next chat reads.

  • Save. /obsidian-save turns a chat into linked notes: people, projects, decisions and tasks.
  • Feed it. /obsidian-ingest takes a link, PDF, Word file, voice memo or screenshot. It updates the notes you already have instead of piling up new ones.
  • Find. /obsidian-find answers from your own notes, with the context around each hit.
  • Push back. /obsidian-challenge checks a plan against your past decisions.
  • Work while you sleep. Optional scheduled agents fix contradictions, link lonely notes and write your morning brief.

Your notes stay as Markdown files on your computer. The core commands need no API keys.

See it work

Animated walkthrough: you tell Claude Code about a meeting, type /obsidian-save, and five linked notes land in Obsidian. Then /obsidian-ingest reads a PDF checklist and updates the project and task notes you already have. The graph view connects them, and the next day Claude answers from the vault.
Save a chat, feed it a PDF, and Claude remembers. Animated walkthrough of a made-up example. Real terminal footage →

Quick start

Inside any Claude Code session, run:

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

Then tell Claude where your vault is. Add this to the env section of ~/.claude/settings.json:

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

Restart Claude Code and run /obsidian-second-brain:obsidian-init inside your vault. Start with three commands: obsidian-init to set up, obsidian-save to capture and obsidian-find to recall.

No vault yet, another AI tool, or bare command names? See the full install guide.

On Grok Bot? Start with one prompt and no install: GROK-BOT.md.

If this helps you, a star helps other people find it.

An evolution of Karpathy's LLM Wiki pattern: a vault that rewrites itself.
Every source updates the pages you already have, not only adds new ones. How it differs →

Powered by Open Knowledge Metabolism (OKM): each fact is timeless, dated, or a pointer. Your notes never fill with facts that used to be true.


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.


Who builds this

I'm Eugeniu Ghelbur, an AI automation engineer. I built this for my own vault, and I still run my work on it every day. I review and merge every change myself, and close to 50 people have shipped fixes so far (see who).

I write up what I learn 3 times a week on The AI Operator, and post shorter notes on X and LinkedIn.

Not a coder? The Vault has 7 ready-made AI tools for paid readers, including Claude memory and an Obsidian folder set up for AI. Each one takes 10 minutes or less, with no code.


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

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.

Crew demo: a new Claude Code session shows the team log on its own and answers what Codex did at 18:40

  • Grok Bot joins the same team through its existing runner.
  • A lesson becomes a rule only when a human runs keep.
  • A new session's hook read shows other agents' recent jobs first, then open lessons. Kept and dropped lessons stay in show and digest. The read stays short enough for the host to inject the whole text.
  • 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.

More from the author

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

Two posts a week, Tuesday and Thursday, 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, AI Tooling Engineer, AI Educator
building in public · sharing what works

Follow along

Two posts a week on AI second-brain systems, vault patterns, and what works in practice.

Follow on X Connect on LinkedIn Subscribe on Substack Follow on GitHub



How It Works

  +------------------------------------------+
  |                                          |
  |   LAYER 1: Operations (32 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        |
  |                                          |
  +------------------------------------------+

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: 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 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 Keenable when RESEARCH_KEENABLE=1) 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.

Optional Keenable source, off by default. Set RESEARCH_KEENABLE=1 to add Keenable web search to the free pool; unset, it never runs, and KEENABLE_API_KEY alone does not switch it on. Keenable runs this source, and your query text is sent to Keenable (api.keenable.ai). The anonymous limit is 1,000 requests an hour and 10 a second per IP; an optional KEENABLE_API_KEY lifts it.

See the thinking tools in action

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

See /obsidian-ingest in action
/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.

See the research toolkit in action

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


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


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


Vault Architecture

Starting with personal notes? /obsidian-init offers an optional 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 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 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. 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 (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.

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:

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.

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

Installing obsidian-second-brain through the Claude Code plugin marketplace: marketplace add, plugin install, status enabled.

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

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 CLI / Gemini CLI / OpenCode

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.

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

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

Pi Coding Agent

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

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

To try it with no setup first, paste the starter prompt from GROK-BOT.md into a Grok Bot chat.

Grok Bot / Sand

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. 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 (README truncated)

Recent activity

commits and pull requests

Releases and announcements

17 total
  1. v0.20.0 - The Batchv0.20.0Oct 25, 2026

    ### Added - **Resumable directory ingestion (#329, by @2Obe).** `/obsidian-ingest` accepts mixed collections of text, PDFs, audio, and images in bounded sequential batches. It reuses existing extraction, raw deduplication, routing, and approval rules. A small helper appends one hidden completion comment per processed source version to the existing operation log. Repeating the command skips completed unchanged sources and retries unfinished work using existing captures. No start records, attempt IDs, persistent error/approval states, or locking are introduced. First Brain warm start is a directory-ingestion use case; no new command or progress file is introduced. - **Word/OpenDocument text ingestion through PDF conversion (#353, by @2Obe).** `/obsidian-ingest` accepts `.docx`, `.doc`, and `.odt` through the stdlib-only `scripts/document_to_pdf.py` helper, following the existing local-source and PDF ingestion rules. LibreOffice 26.2+ is required separately. Conversion uses a private copy and profile, excludes comments and revision markup, and prints a temporary PDF path. Original documents stay unchanged and use the existing provenance schema; no Office-specific path checks, metad

  2. v0.19.0 - The Check-Inv0.19.0Oct 24, 2026

    ### Added - **`/obsidian-checkin` asks you whether old notes still hold.** A fact check compares notes with notes, so news that never reached the vault (a bill settled, a move, a new job) left a note stale and no lint could see it. Check-in asks the owner: up to 3 people or project notes a day whose facts are older than 14 days, family and active projects first. Each card shows the note's name, the date of its facts, and 1 to 3 facts from the note. "Same" stamps a new `last-checked` field; news rewrites the stale claim and propagates; "skip" asks again after 14 days. The open questions live in `<vault>/.checkin.json`, not in the chat, so a host that drops an unanswered question after an hour re-sends the full cards on its next run until they are answered. `scripts/checkin.py` does the picking, the queue and the rendering, so every host sends the same short message. Opt a note out with `checkin: never`, or move it up with `checkin: priority`. - **`scripts/check_notes.py` gives hook-less agents the write-time check.** Claude Code checks every vault write through `hooks/validate-ai-first.sh`; Grok Bot, cron agents and scripts that patch files directly were never checked. The new scr

  3. v0.18.1v0.18.1Oct 20, 2026

    ### Fixed - **`move_note` could swap the contents of two notes in a cloud-synced vault (#324, reported by @jeonpapa, by @tonydzi).** The MCP `move_note` created the destination with `os.link(src, dst)` and then unlinked the source, so for a moment both paths were one file. OneDrive, Dropbox and iCloud track files by identity, and on OneDrive a sync pass in that window left the moved note and an existing note with a similar name in the destination folder holding each other's contents, while the move reported success. The destination is now a new file created with `os.open(dst, O_CREAT | O_EXCL | O_WRONLY)`, so "never overwrite an existing destination" stays one atomic syscall with no TOCTOU window. The bytes are written, fsynced and read back through the same descriptor, and the source is removed only if it still holds what was copied, so an edit saved mid-move fails the move instead of being lost. The source's mode and timestamps are copied over. A failed write removes the half-made destination only if it is still the file the move created, and an unreadable source now returns an error instead of raising. A test in `tests/test_mcp_codex_parity.py` checks the two inodes at the mom

  4. v0.18.0 - Crewv0.18.0Oct 17, 2026

    v0.18.0 adds Crew: 1 shared logbook for 4 agents (Claude Code, Codex, Cursor, and Grok Bot). Codex finishes a job, you open Claude Code, and it already knows what changed. <p align="center"><img src="https://github.com/eugeniughelbur/obsidian-second-brain/raw/main/media/crew-demo.gif" alt="Claude Code reads the team log and answers what Codex did" width="640" /></p> ## The problem Each AI agent you use starts blind to what the others did. So you paste the same context into every chat, again and again. The agents don't share a memory, and they can't learn from each other's mistakes. ## What Crew does - **One line per job.** After every job, an agent writes one line to a plain markdown file: `18:40 | codex | brand | Astra pass, 0 errors`. - **Instant reads.** Before an agent answers, its own hooks hand it the lines the others added since it last looked. You don't paste anything. - **Lessons you approve.** When one agent checks another's work, it can leave a lesson or name a gap. A lesson becomes a rule in that agent's rules file only when you run `keep`. It works in any plain folder, such as `~/crew`. If you use Obsidian, you can put it in `wiki/team/` inside your vault instead

  5. v0.17.0 - The Neighborsv0.17.0Sep 26, 2026

    ### Added - **A session running beside another Obsidian plugin is now told which schema governs its writes (#300).** Claude Code merges hook entries instead of replacing them: "Hook entries merge across settings levels", "All matching hooks run in parallel", and "A plugin's or skill's copy of the same handler stays separate" ([docs](https://code.claude.com/docs/en/hooks)). SessionStart adds every hook's stdout to context, so a second vault plugin's rules arrive alongside ours and the session holds two folder maps and two frontmatter schemas for one vault. Nothing errored and nothing said so: the validator still passed our writes, and the vault drifted into mixed conventions one note at a time. `scripts/vault_plugin_scan.py` reads the SessionStart entries in `~/.claude/settings.json`, a project's `.claude/settings.json` and `.claude/settings.local.json`, and every installed plugin's `hooks/hooks.json` (found through `installed_plugins.json`), and reports the vault-related ones that are not ours. It reads the `command` plus `args` form as well as a bare command string, because a plugin that registers `"command": "python3"` with the script in `args` carries its only evidence in the

Code frequency

additions and deletions
+12K-12KWeek of 2026-03-22: +3,175 linesWeek of 2026-03-22: -220 linesWeek of 2026-03-29: +0 linesWeek of 2026-03-29: -0 linesWeek of 2026-04-05: +2,339 linesWeek of 2026-04-05: -922 linesWeek of 2026-04-12: +0 linesWeek of 2026-04-12: -0 linesWeek of 2026-04-19: +105 linesWeek of 2026-04-19: -22 linesWeek of 2026-04-26: +4,782 linesWeek of 2026-04-26: -84 linesWeek of 2026-05-03: +18 linesWeek of 2026-05-03: -11 linesWeek of 2026-05-10: +2,813 linesWeek of 2026-05-10: -455 linesWeek of 2026-05-17: +642 linesWeek of 2026-05-17: -40 linesWeek of 2026-05-24: +3,667 linesWeek of 2026-05-24: -747 linesWeek of 2026-05-31: +2,116 linesWeek of 2026-05-31: -464 linesWeek of 2026-06-07: +79 linesWeek of 2026-06-07: -9 linesWeek of 2026-06-14: +1,657 linesWeek of 2026-06-14: -49 linesWeek of 2026-06-21: +3,324 linesWeek of 2026-06-21: -648 linesWeek of 2026-06-28: +1,325 linesWeek of 2026-06-28: -166 linesWeek of 2026-07-05: +3,863 linesWeek of 2026-07-05: -637 linesWeek of 2026-07-12: +4,133 linesWeek of 2026-07-12: -405 linesWeek of 2026-07-19: +1,056 linesWeek of 2026-07-19: -124 linesWeek of 2026-07-26: +12,036 linesWeek of 2026-07-26: -821 linesWeek of 2026-08-02: +394 linesWeek of 2026-08-02: -43 linesWeek of 2026-08-09: +832 linesWeek of 2026-08-09: -271 linesWeek of 2026-08-16: +1,377 linesWeek of 2026-08-16: -93 linesWeek of 2026-08-23: +3,008 linesWeek of 2026-08-23: -132 linesWeek of 2026-08-30: +3,674 linesWeek of 2026-08-30: -641 linesWeek of 2026-09-06: +268 linesWeek of 2026-09-06: -16 linesWeek of 2026-09-13: +4,304 linesWeek of 2026-09-13: -732 linesWeek of 2026-09-20: +1,691 linesWeek of 2026-09-20: -176 linesWeek of 2026-09-27: +343 linesWeek of 2026-09-27: -43 linesWeek of 2026-10-04: +638 linesWeek of 2026-10-04: -44 linesWeek of 2026-10-11: +2,820 linesWeek of 2026-10-11: -338 linesWeek of 2026-10-18: +2,472 linesWeek of 2026-10-18: -173 linesWeek of 2026-10-25: +2,246 linesWeek of 2026-10-25: -719 linesWeek of 2026-11-01: +746 linesWeek of 2026-11-01: -178 linesWeek of 2026-11-08: +2,032 linesWeek of 2026-11-08: -148 linesWeek of 2026-11-15: +704 linesWeek of 2026-11-15: -45 linesMar 22, 2026Nov 15, 2026
+74.7K lines added, -9.6K removed over the last year.

Commits per week

last 52 weeks
530Week of 2025-11-23: 0 commitsWeek of 2025-11-30: 0 commitsWeek of 2025-12-07: 0 commitsWeek of 2025-12-14: 0 commitsWeek of 2025-12-21: 0 commitsWeek of 2025-12-28: 0 commitsWeek of 2026-01-04: 0 commitsWeek of 2026-01-11: 0 commitsWeek of 2026-01-18: 0 commitsWeek of 2026-01-25: 0 commitsWeek of 2026-02-01: 0 commitsWeek of 2026-02-08: 0 commitsWeek of 2026-02-15: 0 commitsWeek of 2026-02-22: 0 commitsWeek of 2026-03-01: 0 commitsWeek of 2026-03-08: 0 commitsWeek of 2026-03-15: 0 commitsWeek of 2026-03-22: 10 commitsWeek of 2026-03-29: 0 commitsWeek of 2026-04-05: 25 commitsWeek of 2026-04-12: 0 commitsWeek of 2026-04-19: 7 commitsWeek of 2026-04-26: 33 commitsWeek of 2026-05-03: 4 commitsWeek of 2026-05-10: 18 commitsWeek of 2026-05-17: 6 commitsWeek of 2026-05-24: 22 commitsWeek of 2026-05-31: 17 commitsWeek of 2026-06-07: 3 commitsWeek of 2026-06-14: 14 commitsWeek of 2026-06-21: 30 commitsWeek of 2026-06-28: 16 commitsWeek of 2026-07-05: 39 commitsWeek of 2026-07-12: 48 commitsWeek of 2026-07-19: 15 commitsWeek of 2026-07-26: 53 commitsWeek of 2026-08-02: 7 commitsWeek of 2026-08-09: 7 commitsWeek of 2026-08-16: 7 commitsWeek of 2026-08-23: 11 commitsWeek of 2026-08-30: 26 commitsWeek of 2026-09-06: 5 commitsWeek of 2026-09-13: 36 commitsWeek of 2026-09-20: 12 commitsWeek of 2026-09-27: 11 commitsWeek of 2026-10-04: 5 commitsWeek of 2026-10-11: 7 commitsWeek of 2026-10-18: 25 commitsWeek of 2026-10-25: 14 commitsWeek of 2026-11-01: 10 commitsWeek of 2026-11-08: 15 commitsWeek of 2026-11-15: 5 commitsNov 23, 2025Nov 15, 2026
563 commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 10 commitsSun 1:00 — 8 commitsSun 2:00 — 1 commitsSun 3:00 — 0 commitsSun 4:00 — 2 commitsSun 5:00 — 1 commitsSun 6:00 — 6 commitsSun 7:00 — 0 commitsSun 8:00 — 0 commitsSun 9:00 — 0 commitsSun 10:00 — 0 commitsSun 11:00 — 3 commitsSun 12:00 — 7 commitsSun 13:00 — 14 commitsSun 14:00 — 17 commitsSun 15:00 — 7 commitsSun 16:00 — 3 commitsSun 17:00 — 10 commitsSun 18:00 — 12 commitsSun 19:00 — 13 commitsSun 20:00 — 7 commitsSun 21:00 — 2 commitsSun 22:00 — 4 commitsSun 23:00 — 11 commitsMon 0:00 — 14 commitsMon 1:00 — 19 commitsMon 2:00 — 4 commitsMon 3:00 — 2 commitsMon 4:00 — 0 commitsMon 5:00 — 0 commitsMon 6:00 — 0 commitsMon 7:00 — 1 commitsMon 8:00 — 0 commitsMon 9:00 — 1 commitsMon 10:00 — 2 commitsMon 11:00 — 0 commitsMon 12:00 — 1 commitsMon 13:00 — 6 commitsMon 14:00 — 3 commitsMon 15:00 — 4 commitsMon 16:00 — 4 commitsMon 17:00 — 1 commitsMon 18:00 — 4 commitsMon 19:00 — 1 commitsMon 20:00 — 2 commitsMon 21:00 — 4 commitsMon 22:00 — 3 commitsMon 23:00 — 5 commitsTue 0:00 — 6 commitsTue 1:00 — 3 commitsTue 2:00 — 1 commitsTue 3:00 — 0 commitsTue 4:00 — 0 commitsTue 5:00 — 1 commitsTue 6:00 — 0 commitsTue 7:00 — 1 commitsTue 8:00 — 0 commitsTue 9:00 — 2 commitsTue 10:00 — 2 commitsTue 11:00 — 1 commitsTue 12:00 — 1 commitsTue 13:00 — 8 commitsTue 14:00 — 2 commitsTue 15:00 — 4 commitsTue 16:00 — 1 commitsTue 17:00 — 1 commitsTue 18:00 — 2 commitsTue 19:00 — 0 commitsTue 20:00 — 1 commitsTue 21:00 — 2 commitsTue 22:00 — 8 commitsTue 23:00 — 3 commitsWed 0:00 — 1 commitsWed 1:00 — 4 commitsWed 2:00 — 5 commitsWed 3:00 — 0 commitsWed 4:00 — 0 commitsWed 5:00 — 0 commitsWed 6:00 — 0 commitsWed 7:00 — 1 commitsWed 8:00 — 0 commitsWed 9:00 — 0 commitsWed 10:00 — 1 commitsWed 11:00 — 1 commitsWed 12:00 — 1 commitsWed 13:00 — 6 commitsWed 14:00 — 5 commitsWed 15:00 — 12 commitsWed 16:00 — 1 commitsWed 17:00 — 3 commitsWed 18:00 — 5 commitsWed 19:00 — 1 commitsWed 20:00 — 1 commitsWed 21:00 — 5 commitsWed 22:00 — 5 commitsWed 23:00 — 6 commitsThu 0:00 — 4 commitsThu 1:00 — 2 commitsThu 2:00 — 0 commitsThu 3:00 — 0 commitsThu 4:00 — 2 commitsThu 5:00 — 0 commitsThu 6:00 — 0 commitsThu 7:00 — 0 commitsThu 8:00 — 7 commitsThu 9:00 — 0 commitsThu 10:00 — 0 commitsThu 11:00 — 0 commitsThu 12:00 — 2 commitsThu 13:00 — 0 commitsThu 14:00 — 11 commitsThu 15:00 — 2 commitsThu 16:00 — 3 commitsThu 17:00 — 1 commitsThu 18:00 — 2 commitsThu 19:00 — 1 commitsThu 20:00 — 2 commitsThu 21:00 — 3 commitsThu 22:00 — 1 commitsThu 23:00 — 2 commitsFri 0:00 — 1 commitsFri 1:00 — 1 commitsFri 2:00 — 0 commitsFri 3:00 — 0 commitsFri 4:00 — 0 commitsFri 5:00 — 0 commitsFri 6:00 — 0 commitsFri 7:00 — 0 commitsFri 8:00 — 1 commitsFri 9:00 — 0 commitsFri 10:00 — 1 commitsFri 11:00 — 0 commitsFri 12:00 — 0 commitsFri 13:00 — 1 commitsFri 14:00 — 4 commitsFri 15:00 — 2 commitsFri 16:00 — 2 commitsFri 17:00 — 2 commitsFri 18:00 — 2 commitsFri 19:00 — 2 commitsFri 20:00 — 4 commitsFri 21:00 — 1 commitsFri 22:00 — 7 commitsFri 23:00 — 4 commitsSat 0:00 — 6 commitsSat 1:00 — 7 commitsSat 2:00 — 3 commitsSat 3:00 — 0 commitsSat 4:00 — 2 commitsSat 5:00 — 0 commitsSat 6:00 — 0 commitsSat 7:00 — 0 commitsSat 8:00 — 2 commitsSat 9:00 — 0 commitsSat 10:00 — 0 commitsSat 11:00 — 0 commitsSat 12:00 — 9 commitsSat 13:00 — 18 commitsSat 14:00 — 6 commitsSat 15:00 — 4 commitsSat 16:00 — 14 commitsSat 17:00 — 6 commitsSat 18:00 — 2 commitsSat 19:00 — 6 commitsSat 20:00 — 8 commitsSat 21:00 — 16 commitsSat 22:00 — 21 commitsSat 23:00 — 21 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.

Who is committing

last 52 weeks
Maintainer commits497 (73%)
Community commits180 (27%)

677 commits in total over the last year.

DateListRankStars gained
Jul 11, 2026daily#19+2
  • public-apis/public-apis

    A collective list of free APIs

    500.5K stars · Python

  • morluto/rea

    Reverse engineer anything with agents, from app behavior down to native binaries.

    471.6K stars · TypeScript

  • donnemartin/system-design-primer

    Learn how to design large-scale systems. Prep for the system design interview. Includes Anki flashcards.

    378.7K stars · Python

  • affaan-m/ECC

    The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

    307.9K stars · JavaScript

  • practical-tutorials/project-based-learning

    Curated list of project-based tutorials

    290.1K stars · Python

  • NousResearch/hermes-agent

    The agent that grows with you

    265K stars · Python