記事一覧へ
この記事では、あなたが実行する全てのAIエージェントをより賢くする2層システムを提供します。20分のセットアップで、毎日改善し続け、完全にオープンソースです。
karpathyは最近、トークン支出の多くをコードから知識管理にシフトしていると話しました。
その投稿が共感を呼んだのは、誰もが感じている問題を名指ししたからです：エージェントはあなたのことを知りません。全ての会話がゼロから始まります。ビジネス、ボイス、目標、コンテキストを再説明し、入力にメモリがないから出力は汎用的です。
私は彼のパターンを採用し、2週間にわたって複数のアプローチをテストし、機能するものだけに単純化し、自分自身のデータで満たしました。メモ、アイデア、ツイート、記事、ブックマーク。エージェントはそれから230以上の構造化されたwikiページを、コンセプト、エンティティ、いつでもクエリできるソースとクロスリンクしながらコンパイルしました。
この記事では、ナレッジレイヤーとは何か、コンテンツクリエーション、会社、個人生活のためにどのように構築するかをカバーします。フレームワークはオープンソースで、セットアップには20分かかります。
## AIナレッジレイヤーとは
AIナレッジレイヤーは、あなたとエージェントの間に座るインフラです。エージェントが何かをする前に読むものです。なければ推測します。あれば知っています。
2つの部分があります：
**ナレッジベースレイヤー（KBL）**は動的です。ツイート、記事、ブックマーク、PDF、メモ、ボイスメモなどの生のソースをフォルダに投入します。AIエージェントはそれら全てを読み、ソースをタイプ別に分類し、クロスリファレンスを持つ構造化されたwikiページを構築し、高速スキャンのための1行サマリーを含むマスターインデックスを維持します。あなたが尋ねる全ての質問は新しいページとして保存され、wikiが時間とともに豊かになります。
**ブランドファンデーション（BF）**は静的です。これはあなただけが編集するレイヤーです。ボイスルール、ビジュアルスタイル、ポジショニング、オーディエンス定義、絶対に使わない言葉。エージェントは何かを生成する前にそれを読みますが、決して書き直しません。エージェントが作業しても全てがあなたのように聞こえるようにするアンカーです。
```
+-------------------------------------------------------+
| あなたのエージェント |
| （ライター、リサーチャー、ストラテジスト、アナリスト） |
+---------------------------+---------------------------+
| から読む | から読む
v v
+------------------+ +-------------------+
| ナレッジベース | | ブランドファンデーション|
| レイヤー (KBL) | | (BF) |
| | | |
| 動的 | | 静的 |
| エージェントが維持| | 人間が編集 |
| 時間とともに成長 | | あなたのボイス、 |
| wikiページ、 | | ルール、 |
| ソース、インデックス| | ポジショニング |
+--------+---------+ +-------------------+
|
コンパイル元
|
+--------+---------+
| raw/ 受信箱 |
| ツイート、記事 |
| ブックマーク、PDF |
| メモ、アイデア |
+-------------------+
```
**なぜRAGではないのか？**
RAGはクエリ時にドキュメントをチャンクして検索することで回答を再導出します。ナレッジレイヤーは一度コンパイルし、クロスリファレンスし、最新状態を維持します。約100記事の時点で、karpathyはコンパイルされたアプローチがQ&AでRAGを上回ることを発見しました。graphifyは生のファイルを検索するのと比較して71.5倍少ないトークンを測定しました。
進化は3つのフェーズを経ました：
- ワンショットRAG（2020〜2023）
- マルチホップ取得を持つアジェンティックRAG（2023〜2024）
- エージェントが複数のソースから独自のコンテキストを構築するコンテキストエンジニアリング（2025+）
ナレッジレイヤーはその第3フェーズのインフラです。
## なぜほとんどの人は構築しないか
日曜日にミールプレップをしない理由と同じです。1週間に10時間節約するのに1時間の前もっての作業が必要です。ほとんどの人はそれを修正するシステムのセットアップに20分費やすより、悪いAI出力について不満を言う方を好みます。
AIを使っている人の90%が今同じことをしています：プロンプトして、受け入れて、出荷する。判断も好みもなく。
ナレッジレイヤーはその90%を離れる方法です。あなたの好み、データ、パターンをエンコードして、エージェントがあなたが書いたような出力を生成するようにします。
## コンテンツクリエイターとパーソナルブランド向け
私はここから始めました。私はAIマーケティングコンテンツアカウントと代理店を運営しており、エージェントに私が書いたもの、パフォーマンスしたもの、ボイスがどのように聞こえるかを知ってもらう必要がありました。
LLM Wikidというフレームワークを構築してオープンソース化しました（さらに下で実装方法を説明します）。自分自身のデータを読み込んだときに起きたこと：
プロジェクトについてのメモ、形成中の製品アイデア、ニッチで機能していることの観察、AIマーケティングがどこに向かっているかについての考えなど、頭の中にある全てを書き出すことから始めました。生の思考、構造への焦点なし。
その後、Xアーカイブ（6週間から87ツイート）、3つの公開記事、全ブックマークを投入しました。エージェントは全てを処理して、100以上のクロスリンクを持つ15のテーマ別ソースページ、14のコンセプトページ、11のエンティティページに変えました。
さらに、X APIを通じて197のブックマークを取得し、エージェントは81の画像をダウンロードして49のビデオをトランスクライブし、ビジュアルコンテンツを分析して全てをwikiに織り込みました。私のメモ、アイデア、ツイート、ブックマーク、記事が全て接続されて検索可能に。
## 2つのレイヤーの実践
KBL（ナレッジベースレイヤー）は成長するものを全て保持します：ソースはタイプ別（トランスクリプト、記事、ツイート、論文）に分類され、wikiリンクでクロスリファレンスされ、TLDRでインデックスされます。
フォルダ構造：
```markdown
my-wiki/
raw/
clippings/ # Obsidian Webクリッパーがここに保存
ideas/ # メモ、ブレインストーミング、形成中の考え
bookmarks/ # 保存されたツイート、スレッド、ツール
articles/ # 自分の公開コンテンツ
papers/ # PDF、リサーチ
x-archive/ # X/Twitterエクスポート
assets/images/ # ソースからダウンロードされたメディア
wiki/
index.md # TLDRを持つマスターインデックス
log.md # 追記のみの変更ログ
concepts/ # アイデア、フレームワーク、トピック
entities/ # 人、会社、ツール
sources/ # 生のソース1つにつき1つのサマリー
outputs/ # クエリへの保存された答え
sops/ # 繰り返し可能なプロセス
syntheses/ # 横断的な分析
templates/ # ページタイプのスターター
CLAUDE.md # 全てをコントロールするスキーマ
```
clippings/フォルダに注意してください。これがObsidian Webクリッパーが全てを保存する場所です。ブラウザ拡張機能をインストールすると、Xをブラウズしているとき、記事を読んでいるとき、GitHubリポジトリを確認しているとき、Redditをスクロールしているとき、ワンクリックでクリップできます。フロントマターにソースURLを含めてraw/clippings/に保存します。
次に/wiki-ingestを実行すると、エージェントはURLを読み、ソースのタイプを検出し（ツイート、記事、PDF、動画）、適切なサブフォルダにソートし、フルコンテンツをフェッチし、画像をダウンロードし、wikiにコンパイルします。
BF（ブランドファンデーション）は定数を保持します：AIが言わないことのドキュメント（AIとフラグが立てられる全ての禁止された言葉、フレーズ、構造のリスト）、ビジュアルコンテンツスタイルガイド（美しい背景ではなくターミナルスクリーンショット、色分けされたフローチャート）、ボイスプロファイル。全てのエージェントは何かを生成する前にこれを読みます。
## エージェントがどのようにこれにプラグインするか
ライターエージェントはボイスのためにブランドファンデーションを読み、トピックリサーチのためにwikiをクエリし、適切なフォーマットを選ぶためにコンテンツパフォーマンスデータを確認します。
リサーチャーエージェントはX、Reddit、YouTubeでシグナルを監視し、rawフォルダに新しいソースを投入し、wikiのトピックを拡張します。コンテンツストラテジストはニッチでパフォーマンスしているものを既存のカバレッジとクロスリファレンスしてギャップを特定します。
各エージェントは読み込むナレッジレイヤーと同程度の良さしかありません。
同じエージェントが薄いナレッジベースで生成するとスラップです。同じエージェントがあなたのボイス、データ、パフォーマンス履歴を持つ200以上の構造化されたwikiページを読み込むと、あなたが書いたような作業を生成します。
## AIの5レベルとの対応
これは私が以前書いたAIマーケティングの5レベルに接続します：
- レベル1：カスタムプロンプト（ナレッジレイヤーなし）
- レベル2：手動スキル（薄いナレッジレイヤー）
- レベル3：スキル + ブランドファンデーション（BFレイヤー追加）
- レベル4：コンパイルされたナレッジから読むスキルを持つエージェント（KBL + BFが一緒に機能）
- レベル5：完全な複利ナレッジレイヤーを持つ自律エージェントチーム
ほとんどの人はレベル1か2にいます。ナレッジレイヤーが4と5に到達する方法です。
## 配信の角度
バイブコーディングがビルディングを解決しました。誰もが48時間でアプリを出荷できます。配信はまだ難しい。
ナレッジレイヤーは配信インテリジェンスを複利にする方法です。キャプチャするすべてのコンテンツインサイト、分析するすべてのブックマーク、追跡するすべてのパフォーマンス指標が次のコンテンツをより良くターゲティングします。
スケジュールトリガーが毎朝前日にクリップしたものにingestを実行します。あなたが寝ている間に配信がより賢くなります。
サービスの角度もあります。誰かのナレッジレイヤーをセットアップすることは、月$300〜$500のリテーナーを持つ$1,500〜$3,000のサービスです。10クライアントで1年目に$56,800。
## 会社とプロジェクト向け
同じアーキテクチャが会社規模でも機能します。
違いは複数の人のエージェントが同じナレッジレイヤーから読み書きすること、そしてレイヤーがコンテンツナレッジだけでなく運用ナレッジを保持することです。
新しいチームメンバーがエージェントをナレッジベースに向けると、ドキュメント化されていない仕事の方法を学ぶために数週間費やす代わりに初日から生産的になります。
## 個人生活向け
最も過小評価された使用法。同じシステムがコンテンツパフォーマンスを追跡するのと同じように思考を追跡できます。
日記、本のメモ、ポッドキャストのハイライト、健康指標、目標レビュー、夜中の2時のランダムなアイデア。
全てがraw/に入ります。エージェントはそれを構造化されたページにコンパイルします。
「エネルギーレベルにどんなパターンが見えますか」や「先四半期に生産性について何を学びましたか」と尋ねると、自分自身のデータから引用付きの答えが返ってきます。その答えは保存され、次の質問がより賢くなります。
**品質コントロール：**
- バイアスチェックが全てのページに反論とデータのギャップを強制
- バリデーションゲートは全てのAI生成ページを`explored: false`で始める——人間だけがレビュー済みとマークできる
- 信頼度レベルが全ページを高、中、低、または不確かとしてタグ付け
## 20分のセットアップガイド
**ステップ1：リポジトリをクローン（2分）**
```markdown
git clone https://github.com/shannhk/llm-wikid.git my-wiki
cd my-wiki
```
フォルダをObsidianボルトとして開きます。
**ステップ2：エージェントを実行（3分）**
フォルダでClaude Code（またはマークダウンを読んでbashを実行するエージェント）を開きます。CLAUDE.mdを読みます：
```markdown
# CLAUDE.md（簡略版）
## ディレクトリ構造
- raw/ → 散らかった受信箱、何でもここに投入
- wiki/ → コンパイルされたページ、フラット構造
- wiki/index.md → TLDRを持つマスターインデックス
## オペレーション
- /wiki-ingest → raw/をwikiページに処理
- /wiki-query → 質問し、引用付きの答えを得る
- /wiki-explore → ページをブラウズして検証
- /wiki-lint → 矛盾、古いコンテンツをキャッチ
```
**ステップ3：満たす（10分）**
設定からXアーカイブをリクエストします。Obsidian Webクリッパー拡張機能を入れて、保存する価値のあるツイート、記事、スレッドをクリップし始めます。10分間、頭の中にある全てを書き出します。ブックマークを投入します。80%以上関連性があると感じるものはraw/に入ります。
**ステップ4：ingestを実行（5分）**
```markdown
> /wiki-ingest
```
エージェントはクリッピングをソートし、URLからフルコンテンツをフェッチし、画像をダウンロードして分析し、ソースをタイプ別に分類し、クロスリファレンスでwikiページを構築し、全ページに反論とデータのギャップを追加し、マスターインデックスを更新します。
**/wiki-queryの実践例：**
```markdown
> /wiki-query 最も多くのブックマークを得るコンテンツフォーマットは？
wiki/index.mdを読んでいます... 47のTLDRをスキャン
wiki/content-performance.mdを読んでいます
wiki/bookmark-analysis-march.mdを読んでいます
wiki/thread-vs-single-tweet.mdを読んでいます
答え：
番号付きリストのスレッドはあなたのデータで単独ツイートより3.2倍多くのブックマークを獲得します。
ビジュアル分解（ターミナルスクリーンショット、フローチャート）はテキストのみの312に対して平均847ブックマーク。
最もブックマークされた上位5投稿は全てステップバイステップガイドかツール比較でした。
ソース：[[content-performance]]、[[bookmark-analysis-march]]、[[thread-vs-single-tweet]]
→ wiki/bookmark-formats-query.mdとして保存
```
**ステップ5：グラフを開く**
Obsidianのグラフビューを開きます。アイデア、フォローしている人、使っているツール、関心を持つコンセプトが視覚的なネットワークでリンクされています。/wiki-queryでクエリし始めます。
## 今すべきこと
毎朝/wiki-ingestを実行するスケジュールトリガー（Claude DispatchまたはCron）をセットアップします。
毎週か2週間に一度/wiki-lintを実行して、ページ間の矛盾、古いコンテンツ、誰もリンクしていない孤立したページ、異なる名前の重複コンセプトをキャッチします。
300以上のページに達したら、BM25 + ベクター取得とLLM再ランキングを持つローカルハイブリッド検索のためにqmd（Tobi Lutkeによる）をインストールします。
ナレッジレイヤーを他のエージェントに接続し始めます。それから読み込むライターエージェント。それに投入するリサーチャー。それをクエリするコンテンツストラテジスト。ナレッジレイヤーはそれら全てを有用にする共有ブレインです。
## ウィンドウ
karpathyの投稿は99,000以上のブックマークを獲得しました。graphifyは48時間で出荷されてさらに27,000以上。複数の実装が同じ週にバイラルになりました。需要は明らかです。
ほとんどの人はこれをブックマークして、「面白いね」と思って、絶対にセットアップしません。
今日20分を費やす人は来月、どの検索エンジンもどの汎用AIプロンプトも複製できない複利のナレッジベースを持つでしょう。あなたのボイス、データ、パターン、好みを知っています。
待つ毎週は、取り戻せない複利の1週間です。
リポジトリ：github.com/shannhk/llm-wikid
agent-opsharness-designai-thinking
AIエージェントを賢くする知識レイヤー設計
♥ 81↻ 3
原文を表示 / Show original
this article gives you a two-layer system that makes every AI agent you run smarter. 20 minute setup, gets better every day, fully open source.
karpathy recently talked about shifting most of his token spend from code to knowledge management.
the post resonated because it named a problem everyone feels: your agents don't know you. every conversation starts from zero. you re-explain your business, your voice, your goals, your context, and the output is generic because the input has no memory.
I took his pattern, tested multiple approaches over two weeks, simplified it down to the one that works, and loaded it with my own data. notes, ideas, tweets, articles, bookmarks. the agent compiled 230+ structured wiki pages from that, cross-linked with concepts, entities, and sources I can query anytime.
this article covers what the knowledge layer is, how to build one for content creation, for a company, and for your personal life. the framework is open source and the setup takes 20 minutes.
Andrej Karpathy
@karpathy
·
Apr 3
LLM Knowledge Bases
Something I'm finding very useful recently: using LLMs to build personal knowledge bases for various topics of research interest. In this way, a large fraction of my recent token throughput is going less into manipulating code, and more into manipulating
Show more
2.7K
8.6K
56K
19M
what is the AI knowledge layer
the AI knowledge layer is the infrastructure that sits between you and your agents. it's what they read before they do anything. without it, they guess. with it, they know.
it has two parts:
the knowledge base layer (KBL) is dynamic. you dump raw sources into a folder: tweets, articles, bookmarks, PDFs, notes, voice memos. an AI agent reads all of it, classifies each source by type, builds structured wiki pages with cross-references, and maintains a master index with one-line summaries for fast scanning. every question you ask gets filed back as a new page. the wiki gets richer over time.
the brand foundation (BF) is static. this is the layer only you edit. your voice rules, your visual style, your positioning, your audience definition, the words you never use. agents read it before producing anything, but they never rewrite it. it's the anchor that keeps everything sounding like you even when agents do the work.
here's how the two layers sit in the system:
+-------------------------------------------------------+
| YOUR AGENTS |
| (writer, researcher, strategist, analyst) |
+---------------------------+---------------------------+
| reads from | reads from
v v
+------------------+ +-------------------+
| KNOWLEDGE BASE | | BRAND FOUNDATION |
| LAYER (KBL) | | (BF) |
| | | |
| dynamic | | static |
| agent-maintained| | human-edited |
| grows over time | | your voice, your |
| wiki pages, | | rules, your |
| sources, index | | positioning |
+--------+---------+ +-------------------+
|
compiles from
|
+--------+---------+
| raw/ inbox |
| tweets, articles |
| bookmarks, PDFs |
| notes, ideas |
+-------------------+
why not RAG?
RAG re-derives answers at query time by chunking documents and searching. the knowledge layer compiles once, cross-references, and keeps current. at around 100 articles, karpathy found the compiled approach outperforms RAG for Q&A. graphify measured 71.5x fewer tokens per query compared to searching raw files.
the evolution went in three phases:
one-shot RAG (2020-2023)
agentic RAG with multi-hop retrieval (2023-2024)
and now context engineering where the agent builds its own context from multiple sources (2025+). the knowledge layer is the infrastructure for that third phase.
why most people won't build one
the same reason most people won't meal prep on Sunday. it takes an hour of upfront work to save ten hours over the week. most people would rather complain about bad AI output than spend 20 minutes setting up the system that fixes it.
90% of people using AI are doing the same thing right now: prompting, accepting, shipping. with no judgment and no taste.
the knowledge layer is how you leave that 90%. it encodes your taste, your data, your patterns so agents produce output that sounds like you wrote it instead of something that could be on any AI slop.
the friction is real though, you need to curate what goes in. if something doesn't feel 80%+ relevant to what you're working on, skip it.
high-signal inputs make the output better. fill it with noise and you get noise back.
for content creators and personal brands
this is where I started. I run an AI marketing content account and an agency, and I needed my agents to know what I've written, what performed, and what my voice sounds like.
I built a framework called LLM Wikid and open sourced it (learn how to implement it further down). here's what happened when I loaded my own data:
I started by sitting down and writing out everything on my mind: notes on projects I'm running, half-formed product ideas, observations about what's working in my niche, thoughts on where AI marketing is headed. raw thinking, no focus on structure.
then I dumped my X archive (87 tweets from 6 weeks), three published articles, and all my bookmarks. the agent processed everything and turned it into 15 themed source pages, 14 concept pages, 11 entity pages, with 100+ cross-links between them.
I then pulled 197 bookmarks via the X API, the agent downloaded 81 images and transcribed 49 videos from those bookmarks, analyzed the visual content, and wove it all into the wiki. my notes, my ideas, my tweets, my bookmarks, my articles, all connected and searchable.
image of my Obsidian graph
the two layers in practice
the KBL (knowledge base layer) holds everything that grows: sources classified by type (transcript, article, tweet, paper), cross-referenced with wikilinks, indexed with TLDRs.
when I need to write about a topic, I run /wiki-query and get a cited answer from my own data. that answer gets filed back as a new page, so the next query is richer.
the folder structure looks like this:
markdown
my-wiki/
raw/
clippings/ # obsidian web clipper drops here
ideas/ # notes, brainstorms, half-formed thoughts
bookmarks/ # saved tweets, threads, tools
articles/ # your own published content
papers/ # PDFs, research
x-archive/ # your X/Twitter export
assets/images/ # downloaded media from sources
wiki/
index.md # master index with TLDRs
log.md # append-only changelog
concepts/ # ideas, frameworks, topics
ai-marketing.md
distribution-moat.md
entities/ # people, companies, tools
karpathy.md
claude-superpowers.md
sources/ # one summary per raw source
graphify-2026.md
outputs/ # filed answers to queries
sops/ # repeatable processes
syntheses/ # cross-cutting analysis
templates/ # page type starters
CLAUDE.md # the schema that controls everything
notice the clippings/ folder at the top of raw/. that's where Obsidian Web Clipper drops everything.
you install the browser extension, and whenever you're browsing X, reading an article, checking a GitHub repo, or scrolling Reddit, you clip it with one click. it saves to raw/clippings/ with the source URL in the frontmatter.
GIF
next time you run /wiki-ingest, the agent reads the URL, detects what type of source it is (tweet, article, PDF, video), sorts it to the right subfolder, fetches the full content, downloads any images, and compiles it into the wiki.
you clip during the day, ingest processes it overnight, you wake up to a richer knowledge base.
the BF (brand foundation) holds what stays constant: my AI tells document (a list of every banned word, phrase, and structure that flags as AI), my visual content style guide (terminal screenshots over beautiful backgrounds, color-coded flowcharts), and my voice profile. every agent reads these before producing anything.
how agents plug into this
a writer agent reads the brand foundation for voice, queries the wiki for topic research, and checks content performance data to pick the right format.
a researcher agent monitors X, Reddit, YouTube for signals, feeds new sources into the raw folder, and expands wiki topics. a content strategist cross-references what's performing in the niche against existing coverage and identifies gaps.
each agent is only as good as the knowledge layer it reads from.
the same agent with a thin knowledge base produces slop. the same agent reading 200+ structured wiki pages with your voice, your data, and your performance history produces work that sounds like you.
I tested this directly. Helena, an AI marketing tool, can analyze a brand from a URL alone and produces accurate brand voice profiles. but the content it generates from that analysis was, in my experience, "a whole month of marketing slop in a minute." brand analysis alone isn't enough. you need the knowledge layer on top of it.
Shann³
@shannholmberg
·
Mar 31
honest first impression of Helena, the "autonomous AI marketer"
you start by giving it your website URL and it fetches your brand, analyzes competitors, and generates a full brand knowledge base. the brand read was accurate
it generates all of this from your URL alone:
> brand
Show more
0:00 / 0:54
Quote
Seijin Jung
@SeijinJung
·
Mar 30
1:33
Introducing Helena: the world's first autonomous AI marketer.
Businesses spend 4,000 hours on marketing…before their first $1M in revenue.
We built Helena to solve this. Helena can:
➤ Track competitor ads & create TikTok slideshows, UGC, static ads - all while you sleep
➤
64
23
480
107K
how this maps to the 5 levels of ai
this connects to the 5 levels of AI marketing I wrote about earlier:
level 1: custom prompts (no knowledge layer)
level 2: manual skills (thin knowledge layer)
level 3: skills + brand foundation (BF layer added)
level 4: agents with skills reading from compiled knowledge (KBL + BF working together)
level 5: autonomous agent teams with full compounding knowledge layer
most people sit at level 1 or 2. the knowledge layer is what gets you to 4 and 5.
Shann³
@shannholmberg
·
Mar 17
Article
5 levels of AI marketing (and how to master each one)
karpathy scored 342 US jobs AI exposure. marketing scored a 9 out of 10.
That means everyone in marketing are cooked, but only IF they don´t take action now.
and yet, most people using AI for...
24
60
671
356K
the distribution angle
vibe coding solved building. everyone can ship an app in 48 hours. distribution is still hard.
the knowledge layer is how you compound distribution intelligence. every content insight you capture, every bookmark you analyze, every performance metric you track makes the next piece of content better-targeted.
a scheduled trigger runs ingest every morning on whatever you clipped the day before. your distribution gets smarter while you sleep.
there's also a service angle. setting up someone's knowledge layer is a $1,500-3,000 service with a $300-500 monthly retainer.
ten clients is $56,800 in year one. if you're a content creator or agency owner, this is a productizable skill.
for companies and projects
the same architecture works at company scale.
the difference is that multiple people's agents read from and write to the same knowledge layer, and the layer holds operational knowledge, not just content knowledge.
we run this at @EspressioAI and at @LunarStrategy. at Espressio, the knowledge base holds client delivery patterns, agent architecture templates, and internal SOPs.
at Lunar Strategy, it holds campaign playbooks, client research, and content frameworks. new team members point their agent at the knowledge base and they're productive from day one instead of spending weeks learning the undocumented way things work.
Eric Osiu rolled out something similar across his entire company. every employee has a role-tuned AI agent connected to a shared central brain. his framing:
"a personal assistant has a ceiling. the unlock is role-tuned agents sharing context through a central brain."
when sales closes a deal, the account manager's agent already has the handoff. when content performs, the sales agent adjusts outreach angles automatically.
screenshot from Erics article, credits to him.
no information falls through cracks because the knowledge layer catches everything.
ericosiu
@ericosiu
·
Apr 9
Article
I gave every employee an AI agent. They share one brain. Here's the full system.
I rolled out AI agents across my entire company. Not one assistant. A fleet. Every employee has an AI operating layer tuned to their role, connected to our systems, and coordinated by a shared brain....
7
25
143
21K
how it scales
one person (personal wiki) to small team (5-10 people sharing one knowledge base) to organization (50+ people with role-tuned agents reading from compiled intelligence). the pattern is the same at every level:
raw sources go in
agents compile structured pages
cross-references build automatically
humans validate through exploration gates (every page starts as unreviewed, only a human marks it as confirmed)
git syncs everything so the knowledge is version-controlled and reversible
Cody Schneider built a 10-capability GTM agent swarm for local service businesses.
Cody Schneider
@codyschneider
·
Apr 11
AI agents for marketing are here and it's gonna totally change how you're gonna grow your business
and I'm going to show you how to build your first marketing agent with Hermes in the next 10 minutes
These basically fully functioning employees that you can delegate work to
Show more
10
12
154
18K
the foundation of his system is a data warehouse holding all business data. his words:
"without it, agents can't make good decisions."
he calls it a data warehouse.
Eric Osiu calls it a shared brain. karpathy calls it an LLM wiki.
the name doesn't matter. agents need compiled, structured knowledge to do useful work.
the extreme version of this is what Greg Isenberg calls "ambient businesses," companies that run primarily on agents where the owner checks in every few days.
Medvi is the proof: $1.8 billion revenue run rate, 2 employees, zero VC. AI handles code, creative, voice, customer service. the knowledge layer is the prerequisite. without it, agents need constant human direction. with it, they operate from compiled organizational intelligence.
Jon Oringer
@jonoringer
·
Apr 3
The NYT just profiled a $1.8B revenue company with 2 employees.
Medvi is a telehealth GLP-1 provider built by Matthew Gallagher, 41, from his house in LA. He launched in September 2024 with $20,000. Here are the numbers:
Month 1: 300 customers
Month 2: 1,300 customers
2025 full
Show more
How A.I. Helped One Man (and His Brother) Build a $1.8 Billion Company
From nytimes.com
82
214
1.7K
510K
for your personal life
the most underrated use. the same system that tracks your content performance can track your thinking.
journal entries, book notes, podcast highlights, health metrics, goal reviews, random ideas at 2am.
all of it goes into raw/. the agent compiles it into structured pages.
when you ask "what patterns do I see in my energy levels" or "what did I learn about productivity last quarter," you get a cited answer from your own data. that answer gets filed back, so the next question is smarter.
the compound loop: every question you ask makes the system richer. every source you add creates new connections. your curiosity feeds back into the quality of answers you get.
quality controls matter here more than anywhere because this is where blind trust in AI is most dangerous:
bias checks force counter-arguments and data gaps on every page. if you dump in 10 articles that all say the same thing, the wiki will note it but also flag what's missing from the picture.
the validation gate means every AI-generated page starts with explored: false. only you can mark something as reviewed. you always know what's been human-verified and what hasn't.
confidence levels tag every page as high, medium, low, or uncertain. the agent has to be honest about how well-supported its knowledge is.
the 80/20 rule from my three moats article applies directly here: let AI do 80% of the organization, compilation, and cross-referencing. apply your taste to the last 20%, the curation, the validation, the connections only you can see. the knowledge layer is how you encode your taste so the 80% gets better over time.
the 20-minute setup guide
this is not theoretical. the framework is open source and the setup is fast.
step 1: clone the repo (2 minutes)
markdown
git clone https://github.com/shannhk/llm-wikid.git my-wiki
cd my-wiki
open the folder as an Obsidian vault.
step 2: run your agent (3 minutes)
open Claude Code (or any agent that reads markdown and runs bash) in the folder. it reads CLAUDE.md, which is the schema that controls everything:
markdown
# CLAUDE.md (simplified)
## Directory Structure
- raw/ → messy inbox, dump anything here
- wiki/ → compiled pages, flat structure
- wiki/index.md → master index with TLDRs
## Operations
- /wiki-ingest → process raw/ into wiki pages
- /wiki-query → ask questions, get cited answers
- /wiki-explore → browse and validate pages
- /wiki-lint → catch contradictions, stale content
the agent reads this file, understands the full schema, and scaffolds the wiki structure automatically.
step 3: fill it up (10 minutes)
request your X archive from settings.
grab the Obsidian Web Clipper extension and start clipping tweets, articles, threads worth keeping.
sit down and write out everything on your mind for 10 minutes. dump your bookmarks in. anything that feels 80%+ relevant goes into raw/.
step 4: run ingest (5 minutes)
markdown
> /wiki-ingest
the agent sorts your clippings, fetches full content from URLs, downloads and analyzes images, classifies each source by type, builds wiki pages with cross-references, adds counter-arguments and data gaps on every page, and updates the master index.
here's what a /wiki-query looks like in practice:
markdown
> /wiki-query what content formats get the most bookmarks?
Reading wiki/index.md... scanning 47 TLDRs
Reading wiki/content-performance.md
Reading wiki/bookmark-analysis-march.md
Reading wiki/thread-vs-single-tweet.md
Answer:
Threads with numbered lists get 3.2x more bookmarks than
single tweets in your data. visual breakdowns (terminal
screenshots, flowcharts) averaged 847 bookmarks vs 312 for
text-only. the top 5 bookmarked posts were all either
step-by-step guides or tool comparisons.
Sources: [[content-performance]], [[bookmark-analysis-march]],
[[thread-vs-single-tweet]]
→ Filed as wiki/bookmark-formats-query.md
every answer gets filed back. the next query about content performance will also pull from this one.
step 5: open the graph
open Obsidian's graph view. your ideas, the people you follow, the tools you use, and the concepts you care about are now linked together in a visual network. start querying with /wiki-query.
once the initial ingest is done, try these:
"what content topics have I bookmarked the most in the last month?" shows your signal patterns.
"what are the counter-arguments to [my main thesis]?" forces you to stress-test your thinking against what the wiki has compiled.
"summarize everything I know about [competitor/tool/topic]" pulls from every source that mentions it and synthesizes a briefing.
"what concepts in my wiki have the fewest sources?" shows where your knowledge is thin and where to research next.
each answer gets filed back. the wiki grows.
what to do now?
set up a scheduled trigger (Claude Dispatch or cron) that runs /wiki-ingest every morning.
you clip things during the day, they get processed overnight, you wake up to a richer knowledge base.
run /wiki-lint every week or two to catch contradictions between pages, stale content, orphan pages nobody links to, and duplicate concepts under different names.
the agent fixes what it can and flags what needs your judgment.
when you hit 300+ pages, install qmd (by Tobi Lutke) for local hybrid search with BM25 + vector retrieval and LLM re-ranking. it has an MCP server so your agent can search the wiki as a native tool.
start connecting the knowledge layer to other agents. a writer agent that reads from it. a researcher that feeds into it. a content strategist that queries it. the knowledge layer is the shared brain that makes all of them useful.
the window
karpathy's post hit 99,000+ bookmarks. graphify shipped in 48 hours and got 27,000+ more. multiple implementations went viral the same week. the demand is obvious.
most people will bookmark this, think "that's cool," and never set it up.
the ones who spend 20 minutes today will have a compounding knowledge base by next month that no search engine and no generic AI prompt can replicate. it will know your voice, your data, your patterns, and your taste.
every week you wait is a week of compounding you don't get back.
repo: github.com/shannhk/llm-wikid
Shann³
@shannholmberg
·
Apr 14
how marketing AI knowledge layer works
every marketing team has data scattered across 15-30 tools and none of it talks to each other
your CRM doesnt know what your SEO agent found yesterday. your ad platform doesnt know what your sales team heard on calls this week. your
Show more
12
5
78
5.6K