How To Build a Second Brain That Runs Itself With Obsidian (Full Course)

You read maybe two hundred articles this year. A few dozen papers. Hundreds of threads.

Save this

Every second-brain method ever sold to you, Zettelkasten, PARA, the graph view, the daily note, quietly assumes one unpaid employee doing all the filing, linking, fact-checking, and reviewing forever. That employee is you. And you are tired, busy, and inconsistent, which is why your vault has forty notes in it and a folder called “to-sort” that you will never sort.

The method was never the problem. The labor was. Knowledge work does not scale on one person’s spare evenings, and no amount of discipline fixes that.

So stop trying to be the librarian.

Hire three hundred of them.

This is the full build for a second brain staffed by a 300-agent swarm that runs on your own machine. You dump raw, messy thoughts and half-read articles into one folder. Overnight, while you sleep, a coordinated workforce of sub-agents pulls your sources, breaks them into atomic ideas, files each one, wires it into everything related, checks it against what you already believe, flags the contradictions, and leaves a briefing on your desk for the morning.

Local-first. Plain markdown on your own disk. No vector database, no RAG pipeline, no cloud lock-in. Every design decision is explained. Every skill file is here in full. By the end you will have a knowledge system that gets measurably smarter every single night, with almost none of that effort coming from you.

This is the complete course. Let’s build it.

Reframe: Your Brain Needs a Night Shift

Here is the mental model that makes everything else click.

Think of your second brain not as an app, but as a small intelligence agency that works the night shift. You are the only person who works the day shift. During the day you do the one thing humans are still better at than machines: you have ideas, notice things, react, capture. You throw raw material over the wall.

At night, a department takes over. They process everything you threw over the wall during the day, turn it into organized intelligence, and have a briefing ready before your first coffee.

The reason this was impossible until a few months ago is that the night shift did not exist. The best you could do was an on-demand assistant that only worked when you sat there telling it what to do, which is just you doing the work with extra steps. A real second brain needs workers who run on a schedule, in parallel, without supervision.

Meet the Night Shift

A swarm of three hundred agents is not three hundred copies of the same worker doing the same thing. The power comes from giving them roles, exactly like a real research department. Five roles run the whole operation.

→ Scouts go out into the world. They drive your browser to the articles, papers, and pages on your reading list and bring the full text back into the building. They are your field researchers.

→ Catalogers take each piece of raw material and break it into atomic notes, one idea per file. A single article might become eight atomic notes. They are your archivists, and this is where most of the parallelism lives: one cataloger per source, all working at once.

→ Cartographers maintain the map. Every time a new atomic note lands, they connect it to the existing notes it relates to, growing the link graph that turns a pile of files into a web of thinking. They are your map-makers.

→ Critics are the most valuable hires. They read each new note against everything already in the vault and look for friction: claims that contradict your existing notes, assertions with no source, ideas that quietly undermine a belief you wrote down last month. They raise flags. They never paper over a conflict. They are your fact-checkers and your skeptics.

→ Editors do the synthesis. They take clusters of related atomic notes and weave them into longer synthesis documents, and they write your morning briefing. They are the ones who turn raw knowledge into something you can actually think with.

This is why the number matters. On a quiet night, processing five captures, the swarm uses a handful of agents. On a heavy night, fifty articles backed up over a busy week, it fans out: one scout and one cataloger per source, all working at once, cartographers stitching, critics cross-checking, editors assembling. What would take a single agent hours, one file at a time, the swarm finishes in minutes by splitting the work and merging the results.

You are not running a chatbot. You are running a department.

See One Shift, End to End

Theory is cheap. Here is one real cycle, so you can see exactly what lands on your desk.

During the day, you read something and drop a raw, unedited capture into your 0-raw/ folder. No structure, no effort:

markdownsodium-ion battery packs just hit $56/kWh in a chinese EV, undercutting the cheapest lithium iron phosphate. if this holds, the whole “lithium is the bottleneck” thesis for EV adoption might be wrong. check against what i saved on battery cost curves earlier.

You close the laptop. You sleep.

At 3am, the night shift runs. By 6am, this is sitting in your 2-atoms/ folder, created without you touching anything:

markdown— id: 2026-0611-sodium-ion-cost-parity type: atom certainty: tentative sources: [sources/2026-06-11-sodium-ion-ev-pack.md] links: [“[[battery-cost-curves]]”, “[[lithium-supply-bottleneck-thesis]]”, “[[lfp-chemistry]]”]

Claim

A production EV is shipping sodium-ion packs at roughly $56/kWh, below the cheapest current LFP packs.

Why It Matters

If durable, it weakens the argument that lithium supply is the binding constraint on EV adoption.

[FRICTION] Raised by review

[[lithium-supply-bottleneck-thesis]] (written 3 weeks ago) treats lithium cost as the primary adoption ceiling. This note directly pressures that. Both cannot be fully right. Flagged for your judgment, not auto-resolved.

Open Threads

• Is $56/kWh a one-off subsidized figure or a real production cost?
• Does sodium-ion’s lower energy density cancel the cost win in practice?

And in your briefings/ folder, a one-paragraph note tells you that last night’s processing surfaced one contradiction worth your attention, links straight to it, and asks you to make the call.

Read what happened. You dropped a sloppy fragment. You got back a clean atomic note, filed, linked into three related ideas, and your own three-week-old belief got challenged by your own new input, with the conflict surfaced instead of buried. The department did not just store your thought. It thought about your thought, and pushed back.

That is the entire product. Everything below is how it is built.

The Architecture: A Refinery, Not a Drawer

The biggest mistake people make is organizing a vault by topic, like a drawer with labeled compartments. Topics are a terrible primary structure, because real knowledge does not sit still in one category, and an agent dropping things into topic folders just recreates the filing problem at a larger scale.

Organize by refinement stage instead. Raw material flows in one end and comes out the other as connected knowledge. The folder structure is the pipeline.

markdownbrain/ ├── 0-raw/ <- Everything you dump, untouched. The intake. ├── 1-desk/ <- The night shift’s working area. Transient. ├── 2-atoms/ <- Atomic notes. One idea per file. The permanent core. ├── 3-threads/ <- Synthesis. Living documents that weave atoms together. ├── sources/ <- Original articles and PDFs. Read-only archive. ├── briefings/ <- What the night shift writes back to you. ├── playbooks/ <- The job descriptions. One skill file per shift. └── house-rules.md <- The operating charter. Every agent reads it first.

Four decisions in this layout carry the entire system.

0-raw/ and sources/ are sacred and never edited. Raw captures and original source files are the ground truth. Agents read them, ingest them, and derive from them, but they never modify them. This kills the single failure that quietly destroys every AI knowledge base: derived notes citing other derived notes, the original meaning drifting a little further with each regeneration, until the vault is confidently repeating things it invented two weeks ago. The source never moves, so the truth never drifts.

2-atoms/ holds atomic notes, not articles. One idea per file. This is the principle behind the Zettelkasten method, and it is what makes the link graph powerful instead of decorative. When knowledge is broken into single ideas, those ideas can be connected to many others, recombined, and contradicted precisely. A vault of long article-dumps cannot do this. A vault of atoms becomes a thinking machine.

3-threads/ is where understanding actually lives. Atoms are raw material. Threads are synthesis: living documents that pull a dozen related atoms into an argument or a map of a topic. The editors maintain these. A thread on “battery cost curves” automatically grows as new atoms about batteries land. This is the layer a flat wiki never has, and it is the difference between a knowledge base and an understanding.

1-desk/ is scratch space. The swarm needs somewhere to leave half-finished work mid-shift without polluting your permanent notes. The desk gets cleared at the end of every run. Permanent folders stay clean.

The Charter: house-rules.md

This single file governs the entire workforce. Every agent reads it before doing anything, which is what keeps three hundred autonomous workers from turning your brain into confident noise. Keep it short, blunt, and absolute.

markdown# House Rules — read this before any action

The Pipeline

• 0-raw/ : Intake. READ ONLY. Never edit a raw capture.
• 1-desk/ : Your scratch space. Clear it at end of shift.
• 2-atoms/ : Permanent atomic notes. One idea per file.
• 3-threads/: Synthesis docs. Update the relevant thread; don’t duplicate.
• sources/ : Originals. READ ONLY. Never modify.
• briefings/: Where you write back to the human.

The Prime Directive

Every atomic note must trace to a real source in sources/ or 0-raw/. No source, no note. You may not write a claim that is not in the material. You do not fill gaps with plausible-sounding information. Ever.

Working Rules

1. One idea per atom. If a source has eight ideas, make eight atoms.
2. Before creating an atom, search 2-atoms/ for an existing one to extend.
3. Every atom links to at least two related atoms.
4. When a new atom contradicts an existing one, add a [FRICTION] block to the new note pointing at the old. Never silently overwrite a belief.
5. Never delete. Mark superseded notes [RETIRED] and move to 2-atoms/archive/.
6. End every shift by updating the relevant thread and writing a briefing.

Authority

• You may write only to 1-desk/, 2-atoms/, 3-threads/, and briefings/.
• Anything destructive or ambiguous: stop and ask the human. Do not guess.

The Prime Directive is the line that protects everything. Without it, the swarm fills the silence between facts with confident invention that looks exactly like your real thinking, and within a month you can no longer tell which beliefs are yours and which the machine made up. “No source, no note” is the rule that keeps the brain yours.

The Engine: A Local Agent That Works Nights

Now the part that did not exist until weeks ago, and the reason this is buildable today.

The night shift runs on Kimi Work, Moonshot’s local desktop agent, launched in June 2026 for macOS and Windows and built on the open-weight Kimi K2.6 model. It rolled out in stages, so depending on when you read this, some capabilities may still be gating in. It is not a chat window. As Moonshot puts it, it is closer to a system-level digital employee: it mounts your local folders, drives your real browser through the WebBridge extension, runs code in the background, and executes tasks on a schedule.

The specs that make the night shift possible:

→ Agent Swarm scales to 300 parallel sub-agents across up to 4,000 coordinated steps. This is the literal workforce. One source per agent, all at once, then merged.

→ A built-in cron engine runs jobs on a daily, hourly, or conditional schedule, triggering agent calls and Python or shell scripts. A “Keep Computer Awake” toggle keeps overnight jobs from stalling, which is the whole point of a night shift.

→ WebBridge drives your real, logged-in browser session, inheriting your existing cookies and logins, so the scouts can reach the same paywalled or authenticated sources you can.

→ A 256K-token context window, so an agent can hold huge swaths of your vault in working memory and reason across it, rather than squinting at fragments.

→ A built-in safeguard: with auto-run mode off, Kimi Work asks before it modifies, overwrites, or runs anything in your directories. Nothing happens to your files without your explicit approval.

And because K2.6 ships as open weights under a Modified MIT license, the model underneath is self-hostable through Ollama, vLLM, or SGLang if you want the entire department running fully offline at zero API cost. Local-first, all the way down to the weights.

The difference between an on-demand assistant and this is the difference between a temp you have to brief every morning and a department that just works.

The Playbooks: Four Shifts, One Night

Kimi Work uses Skills: markdown files that define a repeatable workflow. A skill is a job description. The cron schedule is the clock that calls people in. You write the skill once and the schedule fires it forever.

The clever part of this build is staging the work across the night so each shift hands off to the next, instead of cramming everything into one job. Four playbooks run the department.

Playbook 1: The Scout Run — fires at 11:00 PM

markdown# Scout Run

Job

Use WebBridge to visit each URL in 0-raw/reading-list.md. For each one:

1. Open the page in the real browser and extract the full article text.
2. Save it verbatim to sources/YYYY-MM-DD-{slug}.md with frontmatter: url, captured date, word count.
3. Drop a one-line pointer into 0-raw/ so the Refinery picks it up at 3am.

Rules

• Preserve full text. Do NOT summarize; that is the Refinery’s job.
• If a page fails or is blocked, log it as [UNREACHABLE] and move on.
• Never modify reading-list.md.

Playbook 2: The Refinery Run — fires at 3:00 AM, the heavy shift

markdown# Refinery Run

Job

Process every unhandled item in 0-raw/. Use Agent Swarm: assign one sub-agent per item and run them in parallel, then merge.

For each item, the assigned agent:

1. Reads the raw capture and any linked source in sources/.
2. Splits it into atomic notes: one idea per file in 2-atoms/.
3. For each atom, searches 2-atoms/ for an existing note to extend before creating a new one.
4. Links each atom to at least two related atoms (Cartographer step).
5. Checks each atom against existing notes. On contradiction, adds a [FRICTION] block pointing at the conflicting note (Critic step).
6. Moves the handled raw capture to 0-raw/archive/YYYY-MM/.

Hard Rules

• Obey the Prime Directive in house-rules.md. No source, no claim.
• Do not touch sources/ or 0-raw originals beyond reading them.
• Leave any genuinely ambiguous merge for the human. Flag, do not force.

Playbook 3: The Editor Run — fires at 6:00 AM, so the briefing is ready when you wake

markdown# Editor Run

Job

1. Look at every atom created or changed in the last 24 hours.
2. For each cluster of related new atoms, update the matching thread in 3-threads/ (or create one if a real new topic has formed).
3. Write today’s briefing to briefings/YYYY-MM-DD.md.

Briefing Format

What Came In (counts: sources pulled, atoms made)

Contradictions You Should Resolve (every [FRICTION] raised last night, linked)

Threads That Grew

One Thing Worth Your Attention Today

Playbook 4: The Audit Run — fires Sunday at 10:00 PM, the integrity sweep

markdown# Audit Run

Job

Run a health pass over the whole vault and write to briefings/audit-YYYY-MM-DD.md:

1. Orphan atoms with no incoming or outgoing links.
2. Atoms marked certainty: tentative not reviewed in 14+ days.
3. [FRICTION] blocks left unresolved for 7+ days.
4. Atoms in 2-atoms/ with no entry in their sources field (Prime Directive breach).
5. Threads not updated in 30+ days that may be going stale.

Rule

Report only. Fix nothing automatically. This run exists to tell the human exactly where the vault needs a decision.

The schedule that runs the department:

markdown0 23 * * * -> 11:00 PM daily Scout Run 0 3 * * * -> 3:00 AM daily Refinery Run (the swarm) 0 6 * * * -> 6:00 AM daily Editor Run 0 22 * * 0 -> 10:00 PM Sunday Audit Run

Read the flow. Scouts gather material late evening. The swarm refines it in the dead of night when nothing else needs your machine. Editors assemble the briefing just before you wake. And once a week, the auditors tell you exactly where the system needs a human. Each shift hands clean work to the next.

Capture Without Friction

The night shift handles anything already in 0-raw/. The only job left for you is getting thoughts in there in the few seconds before they evaporate.

The simplest capture is the best: 0-raw/ is just a folder on your disk. Any thought, any quote, any link, saved as a plain text file into that folder, is in the system. Drag a PDF in. Paste a quote. Type a half-formed idea and save it. The next Refinery Run picks it up.

Because Kimi Work runs as a desktop agent that mounts your folders, you can also just tell it, in plain language, to file a thought into 0-raw/, and with its ask-before-acting safeguard it confirms before writing. You can query the vault the same way: ask what you have written about battery cost trends, and it reads your actual atoms and answers from your own thinking, not its training data. The distance between a thought and a filed, future-processed note collapses to seconds.

One Brain, Every Tool

Here is what turns a personal vault into infrastructure.

Kimi’s developer CLI speaks MCP, the Model Context Protocol, which means you can expose your vault as a server that any MCP-compatible agent can read. Configure it once, and Kimi Work, a coding agent, your editor’s AI, and any other tool you use all read from and write to the same brain. No more separate, half-remembered knowledge silos in five different apps.

The setup is a single registration of a notes MCP server pointed at your vault directory, after which any agent session can call into it:

markdown> what have I concluded about sodium-ion vs lithium in the last 90 days?

The agent searches your atoms, reads the relevant threads, and answers from your accumulated knowledge. Your vault stops being a place you visit and becomes the shared memory behind everything you do. Check the specific server’s documentation for the exact registration command, since the details vary by tool.

The Guardrails That Keep It From Rotting

You are handing an autonomous workforce read and write access to your knowledge and letting it run unattended overnight. That is enormous leverage and it demands a few non-negotiable guardrails. This is the part the demo videos skip, and it is what separates a system that compounds for a year from one that quietly corrupts itself in a month.

Keep ask-before-acting on while you learn the system. Kimi Work’s built-in safeguard prompts you before it changes or runs anything. Leave it on until you trust a given playbook completely. A local agent is more private than a cloud one, but private is not the same as safe; it is touching your real files and your logged-in browser, so treat it like a privileged employee, not a toy.

Put the vault under version control before you mount it anywhere. Initialize git in your brain/ directory and commit after every Refinery Run. If a shift ever makes a bad call, a merge that should not have happened, a note mangled, a single command rolls the entire vault back to last night. This is the seatbelt. Wear it from day one, not after the first accident.

Defend the Prime Directive. Once a week, when the Audit Run flags atoms with no source, deal with them immediately. The moment notes without traceable origins start accumulating, your brain stops being trustworthy, and an untrustworthy second brain is worse than none, because you will act on its fiction believing it was your own conclusion.

Spend twenty minutes a week on the friction list. The audit hands you every unresolved contradiction. Read each one and make the call: which belief wins, or do both stand with a caveat. This is the only real work left for you, and it is the good kind, the actual thinking, with all the filing and linking already done.

What Compounds, And What Nobody Expects

Three things happen as this runs, and only the first is the one people anticipate.

The obvious one: you stop maintaining anything. Within the first weeks, the filing, linking, and sorting that killed every previous vault simply stops being your job. The graph grows on its own. That alone is worth the build.

The surprising one: it starts arguing with you. Once the vault has real depth, the Critics begin catching contradictions you would never have noticed, because no human remembers what they concluded eleven weeks ago well enough to feel the friction with what they just read. The system does. It will hand you a contradiction between a belief you hold today and one you held in spring, and force you to reconcile them. You will learn things about your own thinking from the briefings. That is not a note-taking feature. That is a thinking partner.

The one nobody expects: the threads get smarter than your recall. Because the editors keep weaving atoms into synthesis documents, after a few months your threads hold a more complete, better-connected map of your field than you can keep in your head at once. You open a thread you have not touched in weeks and find it has quietly grown into the best summary of that topic you own, assembled from your own captured thinking while you were doing other things.

The system gets more valuable the longer it runs, with effort that trends toward zero, because the labor that normally decays over time is precisely the labor you handed to the night shift.

The Real Unlock

For years, “build a second brain” was a polite way of saying “take on a second unpaid job as your own librarian.” That is why the graveyards are everywhere. The labor never paid for itself, so discipline always lost.

The labor is now staffed. You capture in seconds during the day. A department of three hundred refines it overnight. You spend twenty minutes a week as editor-in-chief, making the judgment calls only you can make. And the thing compounds, getting sharper every night, for as long as you let it run.

You were never bad at building a second brain. You were just trying to run an entire research department by yourself.

Now you don’t have to.

Most people will read this, feel the spark, and go back to a vault with forty notes in it, because the labor still feels like theirs to carry. The ones who actually hire the night shift this weekend will wake up Monday to a brain that worked while they slept, and it will not stop.

I build systems that run themselves and break them down so you can build them too. Follow me for the rest, and bookmark this one. The playbooks alone are worth saving.

Tools used in this build:

→ Kimi Work (the local desktop agent and 300-agent swarm): kimi.com/products/kimi-wor

→ Kimi K2.6 open weights (for full offline self-hosting): huggingface.co/moonshotai

→ Obsidian (an optional graph view over your markdown vault): obsidian.md

→ Git (version control for your brain): git-scm.com

If you found this useful, follow me @eng_khairallah1 for more AI content like this. I post breakdowns, courses, and tools every week.

hope this was useful for you, Khairallah ❤️