How to Build a Second Brain with Fable 5 (Translation)

How to make AI truly understand your business, your tone, your historical judgments, and your knowledge assets?

This article goes beyond just the concept of a “second brain” — it breaks it down into an executable system: use Obsidian to store raw materials, structure with raw / entities / concepts / INDEX.md, use an agent to continuously compile, update, and clean, then integrate this knowledge base into your workflow.

I especially like the judgment it emphasizes: model capability is of course important, but often, the real gap isn’t the model itself — it’s what the model reads. A strong model without context may only produce generic content; a model plugged into your long-term accumulated knowledge base has the chance to become an assistant that truly understands you, your business, and your work.

So this article is worth reading, not because it introduces some new tool, but because it offers a new paradigm for using AI: don’t treat AI as a one-shot Q&A tool; instead, connect it to your continuously growing knowledge system, making every input and output part of future output quality.

Original: https://x.com/EXM7777/status/2073045719020343705

Author: Machina

I’ll show you step by step how to turn Fable 5 into a machine that truly understands your business. The final output it delivers will be on a completely different level from what others get.

This tool is a second brain built inside Obsidian. A small group of people are already running the same system: same model, but vastly different outputs.

Why do the smartest models on the market produce mediocre content day in and day out? Simple: it doesn’t know you at all.

It doesn’t know your business, your audience, or the decisions you’ve made in the past. So it has to guess. And things guessed are, of course, mediocre.

Plug it into your own knowledge base, and the same model becomes a different machine.

Code will follow your architecture, content will sound like you, articles will build on your own research accumulation. From day one, you’ll see the difference.

This holds true for any workflow: coding, marketing, content, sales, research.

Running an AI agent without a second brain is a waste of time. And the gap will only widen, because every file this brain ingests makes every subsequent run smarter.

I use this system every day. Every article, every guide, every product I produce is backed by it.

Here’s the complete system: what a second brain actually is; the folder structure an agent can read on its own; how to fill it with goals; how to keep it updated with cycles; how to run a real research machine on top of it; how to read it without burning money; and how to connect it to everything you’re building.

Same Model, Different Level

Let’s look at the data.

In an accounting scenario, a model that doesn’t know the client’s history has about 70% accuracy.

Give it the client’s transaction history, and the starting point jumps to 85%, eventually climbing above 90%.

The model itself hasn’t changed — what changed is the knowledge.

Writing is the same.

A mid-tier model, paired with a decent voice profile, will produce text that sounds more like you than a bare Fable 5.

Often, the deciding factor isn’t the model tier, but which files it reads.

And this particular model benefits more from this approach than any previous model.

In Anthropic’s own tests, when Fable used file-based memory to play an entire card-building game, its improvement was over three times that of the previous flagship model.

It’s just a game, an internal test not yet replicated. But the action behind that number costs nothing more than creating a markdown folder, so it’s worth doing regardless.

Before we start building, I have to make one thing clear: the model won’t magically surface every detail from your notes.

What it actually does is call upon knowledge outside the conversation and indicate where each piece of information came from.

The memory belongs to you. It’s on your hard drive, plain text you can open and read.

After a few weeks, the agent will start referencing old decisions you’d forgotten.

First question: where should this memory live?

The answer is free, and you probably already have it installed.

Obsidian in One Minute

Obsidian is a free app. Essentially, it provides an interface for an entire markdown folder on your computer.

No database, no lock-in to some cloud service. Your notes are plain text files you own; Obsidian is just a nice window into them.

You only need two of its features:

wikilinks: wrap any note name in double square brackets to connect two notes.

graph view: Obsidian draws each note as a dot, each link as a line — you can see your knowledge network directly.

It’s also great for agents, because a vault is essentially a folder. Fable can manipulate it directly via Claude Code, the terminal app the model runs on your computer.

No plugins, no connectors, no special setup needed. The agent reads and writes markdown files; Obsidian shows you the changes.

You use the app, the agent uses the folder. You’re both looking at the same brain.

Before you start worrying this will be a huge project, let me say upfront: a starter version of what’s described in this article takes about an hour. Once read rules are set, running it costs very little. I’ll cover costs separately.

What truly distinguishes a “brain” from a “pile of files” is structure. And structure is what most people get wrong.

Structure: Four Parts, That’s It

This idea comes from Karpathy’s llm-wiki: treat your knowledge base like a codebase.

Obsidian is the editor, the model is the programmer, the wiki is the code.

I looked at many public setups, code repos, viral templates, and failed attempts. What kept recurring were only four parts:

raw - everything you capture stays exactly as is: articles, transcripts, meeting notes, competitor pages. Read-only history, the agent never rewrites it.

entities - one page per concrete thing: a client, a competitor, a tool, a person.

concepts - one page per idea: a strategy, a pattern, a lesson.

INDEX.md - entry point: every page listed here with a one-line description. This way the agent knows what’s in the library without opening every file.

The agent’s job is compilation: read new material in raw/, update entity and concept pages, and link them appropriately.

The writing rules are simple enough to fit in four lines:

One lesson per file, one-line summary at the top.

Update existing pages, don’t create duplicates.

Delete incorrect notes.

Always keep raw sources separate from compiled pages.

Why must raw/ stay untouched? Because when the same agent reads and rewrites the same notes over and over, details slowly blur, errors layer on top of errors.

Raw/ is your original evidence. The wiki is the knowledge layer that grows smarter on top of that evidence.

And pages are only half the value. The real advantage lies in the links between them.

Knowledge Graph: Why It Grows Stronger Over Time

Every link the agent writes is a connection between two pages in the graph.

This is the difference between a vault and a pile of notes: a search-based knowledge base gets noisier as it grows. More files = more noise in every search.

A linked wiki, on the other hand, gets stronger as it grows. Every new page plugs into the network and makes surrounding pages more useful.

When the agent needs to answer a question, it doesn’t scan all files. It follows links.

From a client page to a campaign strategy, to a competitor page. It moves along connections, just like you follow your own train of thought.

Karpathy’s own vault has about 100 articles and 400,000 words, all compiled by the model, all interconnected.

After running this for two weeks, open the graph view — you’ll see your business as a living map. That single image will change how you understand your knowledge assets.

So how do you fill it without spending a month copy-pasting?

Fill It with Goals

Step one is backfilling. Fable’s goal system is perfect for this kind of work.

/goal in Claude Code lets you write an end state, and the model will work continuously towards it. Meanwhile, a smaller model acts as a judge, reading along and determining if the end state has been reached.

The key: the judge can only see the conversation content. So the goal must require the agent to provide evidence it can read:

Before you run it, dump everything you already have into raw/: old chat logs, saved threads, note app exports, client folders, past research.

Then you can walk away. When you return, you’ll have a compiled second brain.

Two rules keep backfilling honest:

Every change must be delivered as a diff — precise before/after line changes, not just a verbal claim. If the agent says it updated a page, the diff must prove it.

Any page without a source link back to raw/ should be flagged first, not trusted immediately.

Backfilling gives you a compiled brain. But keeping it alive is another matter — and the step most people skip.

Keep It Alive with Cycles

A second brain that only grows when you remember to feed it will be dead in three weeks.

So maintenance relies on schedule, not memory:

After each session: a hook — a small script that triggers automatically when a session ends — digs out what just happened: decisions made, errors found, patterns confirmed, and writes them as date-stamped notes into the vault. Work you’ve already done becomes memory without manual archiving.

Every night: run a compile pass with a cheap model, read the day’s new raw material, update wiki pages. Routine work, routine tier.

Weekly: run a lint pass to find contradictions, duplicate pages, and dead links. This cycle keeps the graph clean, because an unmaintained wiki will rot.

Weekly: run a synthesis pass with a large model, read the entire vault laterally, write down what changed this week, what started drifting, what’s worth attention.

This last item is the only one truly worth assigning to a high-end model.

Everything else should run on cheap tiers, because updating notes is routine work. Pushing routine work to a full Fable is how many people burn money.

Maintenance keeps the vault clean. But where does valuable material actually come from?

The Research Workflow that Feeds It

From here, the vault stops being just a storage tool and starts becoming your advantage. And this is also where garbage gets in easiest.

Default AI research: throw a prompt at a chatbot, answer buried in chat history.

Worse, it’s often built on outdated knowledge. Especially in AI, advice from six months ago may be completely wrong. Real frontline practice — what people are running now, what breaks, what actually works — is usually on social platforms, not in official docs.

So a research machine should work like this:

Input a question, then break it into 3-5 sub-questions.

Parallel agents go out searching, each responsible for different channels: social platforms for frontline practice, web for docs and pricing, scraper pulls full text of anything worth reading.

Every finding becomes a receipt: conclusion, source link, date.

Then the real gate: a skeptic agent attacks each conclusion, trying to refute it. Single-source hype gets flagged, contradictory claims are laid out on the table. Only content that survives the attack passes through.

Validated findings land as pages in the vault. Each page has a date and link, each page carries an expiration date. So when knowledge goes stale, it reminds you on its own.

My specific tech stack:

last30days powered by ScrapeCreators (scrapecreators.com): a skill that scans past 30 days of frontline discussion on reddit, X, youtube, instagram, and tiktok for any topic.

Official X MCP (api.x.com/mcp): real-time posts, threads, and bookmarks directly from the source.

yt-dlp for youtube transcripts (github.com/yt-dlp/yt-dlp): any walkthrough or tutorial becomes text an agent can mine.

Instagram and tiktok content via ScrapeCreators, because short video platforms are often where new workflows appear first.

Perplexity deep research (perplexity.ai): one round of full-length web research with citations.

Firecrawl (firecrawl.dev): pull the full text of every page worth saving, convert to clean markdown.

The skeptic is what separates research from rumor collection: a checker coming in with fresh context is usually more reliable than a model reviewing its own work. So the attack always comes from an agent that didn’t participate in the earlier research.

Run this weekly on your niche, and the vault will accumulate validated, dated, sourced intelligence. That’s exactly what your competitors are missing.

But if reading the vault costs more than it returns, everything is meaningless.

Read It Without Burning Money

For a vault to run long-term, reading costs must be low enough. And this is where almost all setups leak money.

Think of it this way: context window is an expensive room. Everything carried into the room is paid for by token. Tokens are the text chunks counted in your AI bill.

Your CLAUDE.md — the instruction file the agent reads at the start of every session — loads automatically, every time. That’s the tax you always pay. Keep it under 200 lines, make it point to the vault, don’t stuff the vault itself inside.

Everything else is pay-per-read: agent checks INDEX.md, follows links, greps for keywords, only opens pages the trail leads to. Scanning entire folders should never happen.

For big questions, dispatch a worker: let a subagent read 50 pages in its own independent context, then return just a paragraph of conclusions to your session. That expensive room should be filled with decisions, not a whole library.

Connect It to Everything You Build

A vault that only stores things is just file organizing hobby. The one described here feeds back into every project you’re working on.

Add three lines to any project’s CLAUDE.md to let it read:

knowledge

• before starting, read the relevant pages from ~/vault/entities/ and ~/vault/concepts/
• ground every claim about our business, clients or audience in a vault page

Output will change immediately:

marketing: campaign briefs are built on your real audience pages and competitor history, not generic personas.

content: drafts reference your past research and align with your voice profile.

coding: the agent maintains living architecture notes for each project, so every new session doesn’t start from scratch.

client work: every deliverable unfolds with the full history of client relationships.

Then there’s the other half: the vault itself becomes product.

Research pages become articles and guides. Concept pages become courses. Client pages become case studies. You no longer start from a blank page; you’re packaging what the machine has already validated.

One last warning that can save your vault: sync is often where vaults break.

Use only one sync system. If iCloud is syncing while an agent writes files, you’ll likely get a pile of conflict copies and scrambled folders.

Git — the programmer’s save-point system — can serve as a checkpoint layer. It only locks a version when you explicitly tell it to. That kind of setup can withstand the agent’s writes.

The Card

The entire build process, in order. Copy directly:

Create vault: raw/, entities/, concepts/, and an INDEX.md.

Write the four rules into your CLAUDE.md: one lesson per file; update don’t duplicate; delete wrong content; never touch raw/.

Dump everything you have into raw/: transcripts, bookmarks, notes, client folders.

Run /goal backfill, require it to paste evidence, and clearly write stopping conditions.

Schedule cycles: session hook, cheap nightly compile, weekly lint, one premium synthesis pass.

Run weekly research scan: search in parallel, skeptic attacks, validated content lands as dated pages.

Add the three knowledge lines to each project’s CLAUDE.md.

The model at the helm will keep changing. The vault will outlast every change, and the feedback written into it will make it smarter each week, regardless of who’s running it.

The minimum viable version takes one hour: one folder, ten files about your business, and a directive for the agent to read them first.

Your output will tell you the rest.