Personal Knowledge Base · A Build Whitepaper

⚠️ First, correcting a common misconception: As of 2026, ChatGPT and Gemini are no longer "stateless reasoning engines." Both have cross-session memory, Gemini integrated NotebookLM, Gemini 3's 1M+ context turns a single session into long-term state, and personalized context is automatically injected.

So why are they still insufficient for heavy knowledge workers?

2.1 Memory is a black box you don't own and can't audit

ChatGPT/Gemini extract facts automatically, but you can't see the complete memory list, can't correctly edit incorrect memories, can't export, can't version-control. It works fine but you don't own it.

2.2 NotebookLM-style mounting solves "read," not "write"

Sources are read-only attachments; the LLM cannot modify, extend, or restructure them; sources have no typed graph; Gemini cannot natively invoke local Bash/Git to modify your markdown source files.

2.3 Memory is flat semantic facts, not a structured knowledge graph

"User likes Python," "user is a CTO" flat sentences. No entity concept, concept evolution, topic threads, timeline / provenance, or backlink graph.

2.4 Compounding doesn't happen at YOUR layer

The more you use ChatGPT, the more OpenAI understands your usage patterns (product-improvement asset → OpenAI's); the next-gen models train on all user data (capability compounding → OpenAI's). Your side is left with one non-exportable memory list.

In early 2026, OpenClaw became an overnight phenomenon one-click Render deploy, personality framework, multi-platform gateway (Telegram/Discord/Slack), official credibility (YC president Garry Tan running it on his own machine), with technical media coverage and "I installed OpenClaw" posts flooding Twitter.

But after a week of usage, most people discovered:

• ❌ It still can't remember what you said 3 weeks ago
• ❌ PDFs you give it work in the moment, but it forgets days later
• ❌ It has no entity concept the same person appears as five strangers across five conversations
• ❌ It has no timeline all your conversations are mush

Garry Tan himself wrote in the first line of the gbrain README:

"Your AI agent is smart but forgetful. GBrain gives it a brain."

This is the industry's most interesting self-diagnosis: OpenClaw (agent) + gbrain (brain) = complete solution; OpenClaw alone = articulate amnesiac.

Root cause: agent is personality + interface; brain is storage + retrieval. They are two different things.

4.1 Philosophy: Karpathy's LLM Wiki gist

Traditional RAG "rediscovers" knowledge on every query wasteful and non-compounding. Karpathy's proposal: let the LLM continuously compile a wiki:

"the wiki is a persistent, compounding artifact"

Architecture: raw/ immutable source documents; wiki/ markdown pages fully maintained by the LLM; SCHEMA.md co-maintained rules; index.md catalog; log.md operation log.

Three core operations:

• Ingest single source → triggers 5-15 wiki page updates
• Query search + synthesize + optionally save as exploration page
• Lint periodic check for contradictions / orphans / staleness

"The tedious part of maintaining a knowledge base is not the reading or the thinking it's the bookkeeping."

The LLM doesn't tire, doesn't forget, can touch 15 files in one operation. This drops maintenance cost to near zero the first time a personal KB has had long-term sustainability.

4.2 Engineering: gbrain's production-grade implementation

postgres-native personal knowledge brain with hybrid RAG search. Concretizes Karpathy's philosophy into a deployable product.

• Storage: PGLite (Postgres + WASM, zero-server)
• Embedding: OpenAI text-embedding-3-large
• Retrieval: vector + BM25 + RRF fusion + multi-query expansion
• Graph: automatic typed-link extraction (mentions / works_at / invested_in / founded ...)
• MCP server: 30+ tools, native support for Claude Code / Cursor / Claude Desktop
• Autopilot daemon: launchd / systemd incremental sync (5 min)

Stack the two pillars (Karpathy philosophy + gbrain engineering) into a runnable four-layer architecture:

+----------------------------------------------------------------+
|  Layer 4: Interaction  Claude Code / Codex / Cursor            |
|  Natural-language driven + skill multi-step workflows          |
|  + scheduled tasks for background automation                   |
+------------+---------------------------------+-----------------+
             | MCP (stdio)                     | filesystem + bash
             v                                 v
+----------------------------+   +------------------------------+
|  Layer 3: Machine Index    |   |  Layer 2: Human UI           |
|  gbrain                    |   |  Obsidian (mobile + desktop) |
|  vector + BM25 + RRF       |   |  write/read/graph view       |
|  typed-link graph          |   |  backlinks panel             |
|  autopilot daemon (5 min)  |   |  cross-device OneDrive sync  |
+------------+---------------+   +--------------+---------------+
             | index                            | read/write
             v                                  v
+----------------------------------------------------------------+
|  Layer 1: Data Layer (source of truth)                         |
|  markdown files (raw/ + wiki/ + SCHEMA.md)                     |
|  vendor-neutral, grep-friendly, version-controlled             |
+----------------------------------------------------------------+

Four-layer stability: each layer is replaceable. Switch LLM agent (Claude Code → Codex) → migrate skills/MCP config; switch index engine → data layer untouched; switch client (Obsidian → Logseq) → markdown files untouched; switch backup → any of them works.

5.1 Layer 1: Data Layer (source of truth)

Pure markdown files + 3-layer organization (raw / wiki / SCHEMA) + 2 root indices (index.md / log.md) + private GitHub backup. Markdown remains readable when any tool dies Notion / Roam / Obsidian / Logseq are all views; the files are the data.

5.2 Layer 2: Human UI (Obsidian)

Obsidian is not the data, it is the data's UI. The files are your markdown, synced wherever you want, intact even if you close Obsidian. Want to switch tools? Copy the vault folder.

5.3 Layer 3: Machine Index (gbrain)

PGLite + OpenAI embedding + autopilot daemon (5-min incremental) + MCP server + auto typed-link graph. Never the source of truth rebuildable, replaceable, duplicable.

5.4 Layer 4: Interaction Layer (coding agent)

Why a coding agent rather than ChatGPT:

• Read local markdown native filesystem access vs. manual upload
• Invoke local CLI (gbrain / git) Bash tool vs. ❌
• MCP server stdio native vs. weak
• Scheduled tasks + programmable workflows ✅ vs. ❌

5.5 Key implementation principles

1. Thin retrieval over fat storage: storage:retrieval = 100:1. The more carefully markdown is written, the thinner retrieval can be.
2. Automating bookkeeping is the real unlock: one ingest triggers 10-15 file updates.
3. Retrieval = vector + keyword + graph fusion (RRF).
4. Source-of-truth decoupling: any tool that locks your data into a proprietary schema is a liability.
5. Daemon-driven incremental sync is non-negotiable.

Abstract architecture is only meaningful when it lands in concrete scenarios.

6.1 Tech CTO doing competitive intel

30+ blogs + 50+ X posts + 5 podcasts a week. Three months later, can't recall "who compared vector-DB choices."

New workflow: scheduled tasks scrape YouTube + X → wiki; mobile Obsidian captures inbox in 30 seconds. Three months later, ask Claude Code: "Synthesize every position on vector-DB choice in my notes categorize as support/against/neutral, cite sources."

Structural difference: instead of decisions by gut feeling, every architecture call has a traceable data trail.

6.2 Seed VC tracking portfolio companies

40+ emails + 10+ hours of podcast + endless X scrolling weekly; concrete evidence isn't at hand at quarterly review.

New workflow: an entity page per portfolio + timeline (auto-appending news/blog/X moves). Before the LP letter: "Every key move in the portfolio related to agent products in the last 90 days + which deserves a follow-on."

6.3 PhD student in a fast-moving field

10+ new papers + 20+ X discussions weekly. Six months later, you remember "Prof X and Prof Y disagreed" but the specifics are fuzzy.

New workflow: a source page per paper + concept pages; each researcher gets an entity page with a position timeline. The literature review goes from "read 100 papers" to "ask the brain."

6.4 Content creator building a citation vault

"I remember a podcast on a similar angle which episode?" 30 minutes of Google + Spotify + Notion, still nothing.

New workflow: YouTube channel monitors scrape daily transcripts; Readwise → wiki/sources auto-sync. Before drafting: "Every angle in my notes on the failure of the attention economy + which positions I have agreed or disagreed with."

Not everyone needs a personal KB and not everyone who needs one can afford frontier APIs.

7.1 When ChatGPT / Gemini is enough

Low reading volume (under 5 deep pieces a week); not writing long-form; AI is primarily a Q&A tool for you; you're not in a fast-moving field; privacy isn't a key concern.

Don't build a second brain "just in case." A KB without a sustained ingest habit is a dead vault worse than not having one.

7.2 When you actually need a personal KB

• 10+ substantive sources read/watched/listened to weekly
• Output depends on cross-source synthesis (writing, research, investing, consulting, teaching)
• You need to revisit thinking from 6 months ago (paper review, decision audit, position evolution)
• You're in a fast-moving field and need continuous thread tracking
• You want vendor-independent assets switch AI vendors without losing data

7.3 Choosing the interaction layer

Three mainstream options:

• Claude Code ($20/mo Pro or $200/mo Max) Opus 4.7 / Sonnet 4.6, the most mature MCP support
• OpenAI Codex ($20-200/mo) GPT-5 / Codex
• Ollama + local open models ($0) 100% local, zero data egress, ceiling about a tier below frontier