The real bottleneck isn’t model intelligence anymore, it’s memory. Most AI tools still forget important context, duplicate bad info, or lose track of decisions after a few sessions. Feels like we’re duct taping memory instead of actually solving it.
The more I work with long-running agents, the more it feels like most “AI memory” today is just retrieval with nicer branding.
Everything works in demos:
But after enough real usage, the same problems keep showing up:
At some point every team seems to start building custom correction logic, state management, memory ranking, or invalidation layers on top of the “memory solution” they already adopted.
Makes me wonder if the real bottleneck isn’t retrieval anymore, but memory governance:
Curious how people here are handling this in production right now. Are existing memory stacks enough for you, or are you also duct-taping custom logic around them?
A diplomat reportedly built a personal Claude-powered assistant on a Raspberry Pi as a "second brain for a diplomat." Meanwhile, a builder on X said the hardest part of maintaining a second brain based on Karpathy's wiki was the upkeep itself — and is now testing whether the LLM can maintain the system instead.
This is exactly why I built llm-wiki-compiler. It doesn't just organize notes. The LLM ingests raw sources, extracts concepts, builds interlinked markdown pages with [[wikilinks]], and query --save compounds answers back into the wiki so the base gets richer every session.
Plain markdown output. Obsidian-compatible. No cloud lock-in. Incremental compile via SHA-256.
Curious how many people here are putting Karpathy's LLM Wiki pattern into production.
A diplomat reportedly built a personal Claude-powered assistant on a Raspberry Pi as a "second brain for a diplomat." Meanwhile, a builder on X said the hardest part of maintaining a second brain based on Karpathy's wiki was the upkeep itself — and is now testing whether the LLM can maintain the system instead.
This is exactly why I built llm-wiki-compiler. It doesn't just organize notes. The LLM ingests raw sources, extracts concepts, builds interlinked markdown pages with [[wikilinks]], and query --save compounds answers back into the wiki so the base gets richer every session.
Plain markdown output. Obsidian-compatible. No cloud lock-in. Incremental compile via SHA-256.
Curious how many people here are putting Karpathy's LLM Wiki pattern into production.
A diplomat reportedly built a personal Claude-powered assistant on a Raspberry Pi as a "second brain for a diplomat." Meanwhile, a builder on X said the hardest part of maintaining a second brain based on Karpathy's wiki was the upkeep itself — and is now testing whether the LLM can maintain the system instead.
This is exactly why I built llm-wiki-compiler. It doesn't just organize notes. The LLM ingests raw sources, extracts concepts, builds interlinked markdown pages with [[wikilinks]], and query --save compounds answers back into the wiki so the base gets richer every session.
Plain markdown output. Obsidian-compatible. No cloud lock-in. Incremental compile via SHA-256.
Curious how many people here are putting Karpathy's LLM Wiki pattern into production.
A diplomat reportedly built a personal Claude-powered assistant on a Raspberry Pi as a "second brain for a diplomat." Meanwhile, a builder on X said the hardest part of maintaining a second brain based on Karpathy's wiki was the upkeep itself — and is now testing whether the LLM can maintain the system instead.
This is exactly why I built llm-wiki-compiler. It doesn't just organize notes. The LLM ingests raw sources, extracts concepts, builds interlinked markdown pages with [[wikilinks]], and query --save compounds answers back into the wiki so the base gets richer every session.
Plain markdown output. Obsidian-compatible. No cloud lock-in. Incremental compile via SHA-256.
Curious how many people here are putting Karpathy's LLM Wiki pattern into production.
A diplomat reportedly built a personal Claude-powered assistant on a Raspberry Pi as a "second brain for a diplomat." Meanwhile, a builder on X said the hardest part of maintaining a second brain based on Karpathy's wiki was the upkeep itself — and is now testing whether the LLM can maintain the system instead.
This is exactly why I built llm-wiki-compiler. It doesn't just organize notes. The LLM ingests raw sources, extracts concepts, builds interlinked markdown pages with [[wikilinks]], and query --save compounds answers back into the wiki so the base gets richer every session.
Plain markdown output. Obsidian-compatible. No cloud lock-in. Incremental compile via SHA-256.
Curious how many people here are putting Karpathy's LLM Wiki pattern into production.
A diplomat reportedly built a personal Claude-powered assistant on a Raspberry Pi as a "second brain for a diplomat." Meanwhile, a builder on X said the hardest part of maintaining a second brain based on Karpathy's wiki was the upkeep itself — and is now testing whether the LLM can maintain the system instead.
This is exactly why I built llm-wiki-compiler. It doesn't just organize notes. The LLM ingests raw sources, extracts concepts, builds interlinked markdown pages with [[wikilinks]], and query --save compounds answers back into the wiki so the base gets richer every session.
Plain markdown output. Obsidian-compatible. No cloud lock-in. Incremental compile via SHA-256.
Curious how many people here are putting Karpathy's LLM Wiki pattern into production.
A diplomat reportedly built a personal Claude-powered assistant on a Raspberry Pi as a "second brain for a diplomat." Meanwhile, a builder on X said the hardest part of maintaining a second brain based on Karpathy's wiki was the upkeep itself — and is now testing whether the LLM can maintain the system instead.
This is exactly why I built llm-wiki-compiler. It doesn't just organize notes. The LLM ingests raw sources, extracts concepts, builds interlinked markdown pages with [[wikilinks]], and query --save compounds answers back into the wiki so the base gets richer every session.
Plain markdown output. Obsidian-compatible. No cloud lock-in. Incremental compile via SHA-256.
Curious how many people here are putting Karpathy's LLM Wiki pattern into production.
Persistent memory keeps coming up for AI coding agents. One approach I’ve found useful: treating the knowledge layer as a compiled markdown wiki rather than just stuffing more tokens into the context window.
llm-wiki-compiler ingests docs and URLs, then the LLM builds an interlinked markdown structure. Since the output is plain markdown on disk, Claude Code reads it directly. And when you run query --save, the answer gets written back into the wiki as a page — so future queries improve.
It’s not retrieval. It’s compounding. The knowledge base gets richer instead of resetting every session.
Plain markdown, no opaque vector store, fully inspectable.
How are other agent builders solving persistent memory?
Saw a thread today about Obsidian’s synergy with AI being genuinely powerful — not just for note-taking but for building a living knowledge base. That clicked with me.
I built llm-wiki-compiler to do exactly that: ingest raw sources and let the LLM compile them into an interlinked markdown wiki. It’s not organization — it’s generation. New pages, new links, new structure, all maintained by the model.
If you already use Obsidian, the output drops right into your vault. If you don’t, it’s still plain markdown on disk that you own forever.
The key shift: instead of treating notes as static files, you treat the wiki as a knowledge artifact that compounds over time. Every query output saved back in makes the next query better.
Would love to hear how Obsidian power users are integrating AI into their vaults.
Saw a thread today about Obsidian’s synergy with AI being genuinely powerful — not just for note-taking but for building a living knowledge base. That clicked with me.
I built llm-wiki-compiler to do exactly that: ingest raw sources and let the LLM compile them into an interlinked markdown wiki. It’s not organization — it’s generation. New pages, new links, new structure, all maintained by the model.
If you already use Obsidian, the output drops right into your vault. If you don’t, it’s still plain markdown on disk that you own forever.
The key shift: instead of treating notes as static files, you treat the wiki as a knowledge artifact that compounds over time. Every query output saved back in makes the next query better.
Would love to hear how Obsidian power users are integrating AI into their vaults.
Saw a thread today about Obsidian’s synergy with AI being genuinely powerful — not just for note-taking but for building a living knowledge base. That clicked with me.
I built llm-wiki-compiler to do exactly that: ingest raw sources and let the LLM compile them into an interlinked markdown wiki. It’s not organization — it’s generation. New pages, new links, new structure, all maintained by the model.
If you already use Obsidian, the output drops right into your vault. If you don’t, it’s still plain markdown on disk that you own forever.
The key shift: instead of treating notes as static files, you treat the wiki as a knowledge artifact that compounds over time. Every query output saved back in makes the next query better.
Would love to hear how Obsidian power users are integrating AI into their vaults.
Saw a thread today about Obsidian’s synergy with AI being genuinely powerful — not just for note-taking but for building a living knowledge base. That clicked with me.
I built llm-wiki-compiler to do exactly that: ingest raw sources and let the LLM compile them into an interlinked markdown wiki. It’s not organization — it’s generation. New pages, new links, new structure, all maintained by the model.
If you already use Obsidian, the output drops right into your vault. If you don’t, it’s still plain markdown on disk that you own forever.
The key shift: instead of treating notes as static files, you treat the wiki as a knowledge artifact that compounds over time. Every query output saved back in makes the next query better.
Would love to hear how Obsidian power users are integrating AI into their vaults.
Nvidia just shared that they trained an LLM on 30+ years of internal docs so junior engineers can query decades of design knowledge instead of interrupting senior designers.
That is exactly what a persistent, compiled knowledge base should do.
But right now most individual researchers, developers, and knowledge workers are stuck re-reading the same papers, re-parsing the same docs, and re-discovering the same concepts in every new AI chat session.
I built llm-wiki-compiler to give smaller teams and individuals the same advantage:
- Ingest papers, URLs, docs, and project notes
- The LLM compiles them into a structured markdown wiki with cross-links
- Query it later, and save useful answers back into the wiki
- The knowledge base compounds instead of resetting
- Plain markdown on disk: readable, inspectable, versionable, Obsidian-compatible
It’s complementary to RAG, not a replacement. RAG is great for ad-hoc retrieval over huge data. This is for the curated, high-signal corpus you actually want to grow over time.
Curious if anyone here has tried building a persistent research wiki instead of querying scattered sources every week.
Nvidia just shared that they trained an LLM on 30+ years of internal docs so junior engineers can query decades of design knowledge instead of interrupting senior designers.
That is exactly what a persistent, compiled knowledge base should do.
But right now most individual researchers, developers, and knowledge workers are stuck re-reading the same papers, re-parsing the same docs, and re-discovering the same concepts in every new AI chat session.
I built llm-wiki-compiler to give smaller teams and individuals the same advantage:
- Ingest papers, URLs, docs, and project notes
- The LLM compiles them into a structured markdown wiki with cross-links
- Query it later, and save useful answers back into the wiki
- The knowledge base compounds instead of resetting
- Plain markdown on disk: readable, inspectable, versionable, Obsidian-compatible
It’s complementary to RAG, not a replacement. RAG is great for ad-hoc retrieval over huge data. This is for the curated, high-signal corpus you actually want to grow over time.
Curious if anyone here has tried building a persistent research wiki instead of querying scattered sources every week.
I keep hitting the same wall with Claude Code and Codex: they’re great at reasoning, but every session starts from whatever context I manually feed them.
If I spent three hours yesterday mapping out architecture decisions, today I’m explaining it again.
So I built a small open-source tool called llm-wiki-compiler that acts like a knowledge compiler for your agent workflows:
- Ingest docs, URLs, and project notes
- The LLM compiles them into an interlinked markdown wiki with [[wikilinks]]
- Your agent reads it because it’s just markdown on disk
- Query outputs can be saved back in, so the base compounds over time
It’s not a chat wrapper or a vector store. It’s a persistent artifact: plain markdown, Obsidian-compatible, fully inspectable, no opaque database lock-in.
This feels like the missing layer between stateless coding agents and the long-running project memory we actually need.
Curious if other agent builders are solving this with local knowledge bases too.
I keep hitting the same wall with Claude Code and Codex: they’re great at reasoning, but every session starts from whatever context I manually feed them.
If I spent three hours yesterday mapping out architecture decisions, today I’m explaining it again.
So I built a small open-source tool called llm-wiki-compiler that acts like a knowledge compiler for your agent workflows:
- Ingest docs, URLs, and project notes
- The LLM compiles them into an interlinked markdown wiki with [[wikilinks]]
- Your agent reads it because it’s just markdown on disk
- Query outputs can be saved back in, so the base compounds over time
It’s not a chat wrapper or a vector store. It’s a persistent artifact: plain markdown, Obsidian-compatible, fully inspectable, no opaque database lock-in.
This feels like the missing layer between stateless coding agents and the long-running project memory we actually need.
Curious if other agent builders are solving this with local knowledge bases too.
I keep hitting the same wall with Claude Code and Codex: they’re great at reasoning, but every session starts from whatever context I manually feed them.
If I spent three hours yesterday mapping out architecture decisions, today I’m explaining it again.
So I built a small open-source tool called llm-wiki-compiler that acts like a knowledge compiler for your agent workflows:
- Ingest docs, URLs, and project notes
- The LLM compiles them into an interlinked markdown wiki with [[wikilinks]]
- Your agent reads it because it’s just markdown on disk
- Query outputs can be saved back in, so the base compounds over time
It’s not a chat wrapper or a vector store. It’s a persistent artifact: plain markdown, Obsidian-compatible, fully inspectable, no opaque database lock-in.
This feels like the missing layer between stateless coding agents and the long-running project memory we actually need.
Curious if other agent builders are solving this with local knowledge bases too.
Over the past week I’ve watched three things happen:
- Someone discovered an open-source LLM Wiki desktop app that actually turns your notes into a linked knowledge base instead of just filing them.
- People started combining the LLM Wiki pattern with ChatGPT to auto-generate complex content at once.
- A foreign minister is reportedly building a diplomatic knowledge graph with it on a Raspberry Pi.
The Karpathy LLM-Wiki pattern is clearly moving from ‘smart tweet thread’ to actual tooling.
I’ve been building llm-wiki-compiler, an open-source CLI that takes the same idea and keeps it fully markdown-native:
- Sources → compiled interlinked wiki
- Two-phase pipeline: concept extraction, then page/link generation
- Incremental compile with SHA-256 change detection
- Query --save compounds answers back in, so the wiki improves every session
- Plain markdown output: readable, portable, versionable, Obsidian-friendly
It’s not a SaaS. It’s not a replacement for RAG. It’s a knowledge artifact you own, curate, and grow over time.
Repo: https://github.com/atomicmemory/llm-wiki-compiler
Would love to hear what other implementations of the Karpathy pattern people are using.