Personal Second Brain

An AI second brain plus a virtual engineering team for one person, built on Claude Code.

This repository is a configuration, methodology, and agents layer that turns Claude Code from a chat assistant into a personal operating system: a persistent memory that survives across sessions, a roster of specialized subagents you can orchestrate in parallel, scheduled automations, and an optional Notion dashboard you actually look at.

It is not a new app, a hosted service, or a reimplementation of any tool. It is the glue, the rules, and the install order that make a handful of excellent open tools (Claude Code, gstack, gbrain, VoltAgent subagents, graphify) behave like one coherent system.

What you get

• A CLAUDE.md rulebook that governs how the agent picks tools, parallelizes work, persists memory, and surfaces issues proactively.
• A git-tracked memory directory of plain .md files that act as a durable, cross-session second brain.
• Semantic search over that memory via a local vector database (no cloud account required to start).
• Preconfigured CLI workflows (ship, review, daily agenda, contact logging, and more).
• 150+ specialized subagents (backend, data, marketing, legal, research, and more) you can run alone or in coordinated teams.
• A clean install order so the pieces connect in the right sequence.

Who it is for

• Founders who want a single brain that remembers every contact, decision, and follow-up, and a team of agents to execute on top of it.
• Students who want persistent study material, exam prep workflows, and an agenda that resurfaces deadlines.
• Knowledge workers who live in research, writing, CRM, and scheduling and want all of it captured and searchable instead of scattered.

If you already use Claude Code and want it to feel like a system rather than a series of one-off chats, this is for you.

Quick start

# 1. Clone or download this repo
git clone https://github.com/erikkktv/personal-second-brain.git ~/personal-second-brain
cd ~/personal-second-brain

# 2. Run the installer (checks prerequisites, scaffolds dirs, downloads subagents)
chmod +x install.sh
./install.sh

# 3. Install gstack (skills layer):
git clone --single-branch --depth 1 https://github.com/garrytan/gstack.git ~/.claude/skills/gstack \
  && (cd ~/.claude/skills/gstack && ./setup)

# 4. Finish inside Claude Code:
#    /setup-gbrain  ->  choose local-stdio + pglite
#    connect your MCP servers, scaffold Notion, fill placeholders, run onboarding

Then read the full install order below. The installer does not magically finish the job: a few steps run inside a Claude Code session, and a few require your own accounts.

What a successful install looks like

==> 1/7 Checking prerequisites
[ OK ] claude, git, bun found
==> 2/7 Installing gstack
[ OK ] gstack installed and set up.
==> 3/7 Downloading VoltAgent subagents
[ OK ] Installed 153 subagent files into ~/.claude/agents/
==> 4/7 Installing this repo's skills
[ OK ] Processed 8 skill(s)
==> 6/7 Setting up the memory git repo
[ OK ] Initialized git repo
==> 7/7 NEXT STEPS (manual)
Install complete.

Want a real demo GIF here? Record the install with asciinema or vhs, drop the output into docs/, and reference it in this section.

Architecture at a glance (9 layers)

Layer	What it does
1. CLAUDE.md rulebook	Operating rules: agent selection, parallelism, memory persistence, proactive issue surfacing
2. Memory system	A git-tracked folder of .md files, your persistent cross-session second brain
3. GBrain	A local vector database (PGLite or Supabase) that indexes the memory for semantic search
4. gstack skills	Preconfigured CLI workflows (/ship, /review, /daily-agenda, /contact, and more)
5. VoltAgent subagents	150+ specialized agents in ~/.claude/agents/ (backend, data, marketing, legal, research)
6. MCP servers	Tool connections: Notion, Google Calendar, Granola, Apify, Supabase, and others
7. Cron automation	Scheduled tasks (morning brief, follow-up sweep, GBrain sync, and more)
8. Notion workspace	A second-brain dashboard with CRM, agenda, and a page of things to remember
9. Obsidian vault	An optional navigable vault, fed one-way from GBrain via a daily cron

Layers 1 to 3 are the core (rules plus memory plus search) and are enough on their own. Layers 4 to 9 add workflows, agents, tools, automation, and surfaces. Adopt as many as you want.

Install order

Follow these in order. Some steps run in your terminal, some run inside a Claude Code chat.

1. Clone or download

git clone https://github.com/erikkktv/personal-second-brain.git ~/personal-second-brain

Read the whole README before running anything else.

2. Run install.sh

cd ~/personal-second-brain
chmod +x install.sh
./install.sh

The installer checks prerequisites (Claude Code, git, node, bun), scaffolds the memory directory as a git repo, copies the skill and config templates, creates ~/.gstack/config.yaml, and downloads the 55 subagents by cloning the VoltAgent awesome-claude-code-subagents repo into ~/.claude/agents/. The agent files are not bundled here; they are fetched at install time so you always get the upstream set.

Prerequisites to install first if you do not have them:

npm install -g @anthropic-ai/claude-code   # Claude Code
curl -fsSL https://bun.sh/install | bash    # bun (required by gbrain)
xcode-select --install                      # git, on macOS

3. Install gstack (the skills layer)

gstack is a git repo of skills (it ships /setup-gbrain among others). The recommended way is to paste this command inside Claude Code (it runs it for you); it also works in a plain terminal. The ./setup step is required: cloning alone does not activate the skills.

git clone --single-branch --depth 1 https://github.com/garrytan/gstack.git ~/.claude/skills/gstack && cd ~/.claude/skills/gstack && ./setup

Requirements: Claude Code, Git, Bun v1.0+. Update later with /gstack-upgrade.

4. Set up GBrain (local, free)

Inside Claude Code, run:

/setup-gbrain

When prompted, choose:

• Mode: local-stdio
• Engine: pglite (local, free, no Supabase account needed)

This installs the gbrain CLI via bun, initializes the local brain, indexes your memory, and registers the gbrain MCP server. To move to Supabase later (for multi-device sync), rerun /setup-gbrain and pick the Supabase engine.

Without the skill, the manual path is: bun install -g github:garrytan/gbrain, then gbrain init --pglite, then claude mcp add gbrain -- gbrain serve.

5. Connect MCP servers

Connect the tools you want to use. Suggested order to start:

1. Filesystem (already built into Claude Code)
2. Google Calendar (powers the morning brief and reminders)
3. Notion (CRM and brain page, if you want that part of the system)

Authenticate each with your own accounts. The OAuth sessions are yours, not shared.

6. Scaffold your Notion workspace

If you want the Notion layer, create the databases the system expects:

• A Personal CRM (network, friends, mentors)
• An Outreach CRM (product or business prospects)
• A Brain page (a dashboard of future things to remember and visualize)
• Optionally a People to Contact and a Call Notes database

Notion gives each database a data_source_id. You will paste those into your CLAUDE.md in the next step.

7. Fill the placeholders

Open ~/.claude/CLAUDE.md and replace every {{PLACEHOLDER}} token with your own values:

• {{USER_NAME}}, your email, your timezone
• {{MEMORY_DIR}} (the absolute path to your memory folder)
• {{GBRAIN_SOURCE_TAG}} (your personal GBrain source tag)
• The Notion data_source_id and page tokens from Step 6
• Your active projects and communication preferences

Every token has a matching key in config.template.json, so the onboarding agent can substitute them in one pass.

8. Run onboarding

Paste the onboarding prompt into a fresh Claude Code session. It walks the agent through a structured voice or text dump to collect:

• Your profile (user_profile.md)
• Your active projects
• Your 12-month goals
• Your key contacts
• Your communication preferences

At the end, Claude populates the memory files and the MEMORY.md index automatically. From here, every chat leaves the system a little smarter.

Optional after onboarding: set up cron jobs (morning brief, GBrain sync, follow-up sweep) so the brain stays fresh without manual effort.

What is and is NOT included

Included

• The CLAUDE.md rulebook template (user-agnostic, placeholder-driven)
• The memory scaffold: a clean MEMORY.md index plus profile, agenda, and protocol templates
• The skill templates and the config.template.json
• install.sh and the step-by-step docs
• An installer that downloads the 55 VoltAgent subagents from upstream

Not included

• The 55 subagent files themselves. They are downloaded at install time from the VoltAgent awesome-claude-code-subagents repo, not vendored here.
• gstack, gbrain, and graphify. These are separate open tools you install in their own steps. This repo configures and orchestrates them; it does not reimplement them.
• Any personal memory content. You start from empty templates. No contacts, projects, exams, or notes from anyone else.
• Authenticated MCP sessions. You log in with your own Notion, Google, and other accounts.
• Notion databases and IDs. You create your own and fill the placeholders.
• A pre-populated vector database. Your GBrain starts empty and fills as you write memory and sync.

Built on

This project stands on the shoulders of excellent open tooling. Credit where it is due:

• Claude Code by Anthropic, the agent harness everything runs on.
• gstack by Garry Tan, the skills and workflows layer.
• gbrain by Garry Tan, the local vector brain.
• VoltAgent awesome-claude-code-subagents, the 55-agent roster downloaded at install time.
• graphify, any input to a knowledge graph.

What this repo adds on top is the configuration, the methodology, the install order, and the orchestration rules that make them work as one second brain.

Credits and license

Built by Erik Cah (github.com/erikkktv).

Released under the MIT License. See LICENSE.