How I Built a Second Brain That Builds Itself

A real autopilot doesn’t fly the plane.

It holds the course you set. It adjusts for turbulence. It reads instruments faster than you can. And it frees you to think about where you’re actually going, instead of white-knuckling the controls every second.

That’s the metaphor I keep coming back to as I build what I now call the AFCS. Automatic Flight Control System. Not because it replaces me, but because it does for business operations what autopilot does for pilots. It keeps the plane steady while I decide the destination.

This started when Andrej Karpathy, the former head of AI at Tesla, shared something that stopped me mid-scroll. He wasn’t talking about a new model or AGI. He was talking about folders.

The Karpathy insight

Karpathy described a system where he dumps raw research into a directory, lets an AI organise it into a wiki of markdown files, asks questions against that wiki, and files the answers back in. Every question makes the wiki smarter. The whole thing compounds.

His exact words: “I think there is room here for an incredible new product instead of a hacky collection of scripts.”

The architecture is five steps. Collect sources. Let the AI organise them into structured articles. The wiki becomes the brain. Ask complex questions against it. File the answers back in.

The magic is in that last step. Most people stop at the question. They get an answer and move on. Karpathy’s insight is that the answer itself is knowledge. File it back into the wiki and the next question starts from a richer base. Every answer makes the wiki smarter.

That’s a compound loop. And compound loops are the most powerful force in business.

Why this matters beyond research

Karpathy built his system for academic research. One person, one AI, one topic at a time. Lex Fridman chimed in with something similar, noting he generates “dynamic html with js” for interactive exploration and even creates mini knowledge bases for voice-mode conversations on long runs.

Interesting, but I’m not a researcher. I run four businesses. And the problem I face every day isn’t academic. It’s operational.

Context is everywhere and nowhere. Notes from a call sit in one app. A decision I made last week lives in a chat thread. A market signal I spotted is in a bookmark I’ll never revisit. An insight from a meeting transcript is buried in a 40-minute recording.

Every time I sit down to work, I start from scratch. Every time I brief an AI tool, I re-explain everything. Every time I make a decision, I’m working from whatever I can remember, not everything I know.

This isn’t a technology problem. It’s an information architecture problem. And it gets worse the more you build.

So I took Karpathy’s pattern and asked: what if this wasn’t just a personal wiki? What if it was the flight computer for an entire operation?

The autopilot analogy

In aviation, an Automatic Flight Control System has four components. Sensors that read the environment. A flight computer that processes the data. Actuators that take physical action. And a feedback loop that course-corrects.

The pilot doesn’t manually adjust every control surface. They set the heading, the altitude, the speed. The AFCS holds the course. When turbulence hits, the system adjusts before the pilot even feels it.

This maps directly onto how I now run things.

Sensors are everything that feeds information into the system. Meeting transcripts. Email replies to outreach. LinkedIn engagement signals. Market research. Saved links. And, critically, me. I’m a sensor too. When I have a conversation, notice a trend, or make a decision, that’s data entering the system. Humans are the highest-fidelity sensor. We notice things that automated scans miss.

The Flight Computer is a folder on my computer. Just markdown files. No database, no SaaS platform, no proprietary tool. Inside it lives the context (my goals, rules, projects, people), the memory (decisions, daily distillations, entity facts), and the wiki, which is the compiled knowledge brain. This is the Karpathy layer.

Actuators are the AI agents and automated tasks that take action. This is where it gets interesting, because I don’t use one AI. I use several.

Course correction is the compound loop. Everything the actuators produce flows back into the flight computer. The system gets smarter every cycle.

The “which AI do I use?” problem

If you’ve started using AI tools seriously, you’ve probably hit this wall. Claude is great for strategy and writing. ChatGPT has different strengths. There are coding tools, automation tools, research tools. Each one has its own context window, its own memory, its own limitations.

The common advice is “pick one and go deep.” I tried that. It doesn’t work when you’re running multiple businesses with different needs.

The AFCS model solves this differently. Instead of picking one AI, you make them all actuators driven by the same flight computer.

Every agent reads from the same canonical context. My goals, my rules, my people, my projects. They all read the same constitution. And every agent writes back to the same memory layer. What one agent learns becomes available to every other agent.

The AI tool becomes interchangeable. The flight computer is what matters.

I currently have six actuator slots. Some are AI assistants I interact with directly. Some are fully automated. One is a future placeholder for communications automation. The point isn’t which specific tools I use. The point is that they all read from and write to the same source of truth. If I swapped one tool for another tomorrow, the flight computer wouldn’t care. The knowledge persists regardless of which actuator produced it.

This is freeing. You stop worrying about which AI is “best” and start thinking about what each one is best at. They’re instruments, not identities.

The compound loop in practice

Here’s what a single day actually looks like.

I save a link to an article about AI adoption in law firms. I clip it from my browser into an inbox folder.

Overnight, a scanner reads that article, classifies it as market intelligence for my legal vertical, and files it into the wiki as raw material.

At 6am, a compiler reads all the raw material from the last 24 hours. That article, plus meeting notes from yesterday, outputs from other agents, and memory distillations. It synthesises everything into structured wiki articles. That law firm article gets woven into an existing article called “Legal Sector AI Demand” alongside data from three other sources.

At 6:30am, a quality gate reviews the updated article. More on this in a moment, because this is the critical piece.

At 7am, briefings get generated. My sales briefing now includes the updated legal intelligence. My content briefing flags it as a potential angle for next week’s LinkedIn post.

When I sit down at 8am, I don’t need to remember that article. The system already absorbed it, cross-referenced it, validated it, and surfaced the actionable parts. The autopilot held the course overnight.

Each cycle compounds the brain. The wiki today is smarter than the wiki yesterday. Not because I wrote anything, but because the system processed what it encountered and filed the good parts back in.

In aviation terms: the sensors fed data in. The flight computer processed it. The actuators will act on it. And the whole system is now better calibrated for the next cycle.

The quality gate: credit where it’s due

After Karpathy’s post went viral, JUMPERZ on X took the pattern and wired it into a 10-agent swarm. Their key insight changed how I think about the whole system.

Raw data is dangerous when it compounds. One hallucinated connection enters the brain and every agent downstream builds on it.

JUMPERZ’s solution: put an independent reviewer between drafts and the permanent knowledge base. They used Hermes, a model specifically trained for structured evaluation. The reviewer has no context about how an article was produced. It doesn’t know which agent wrote it or what task spawned it. It reads the article cold and asks: is this accurate? Should this enter the permanent brain?

This is the difference between a knowledge base that compounds value and one that compounds noise. The gate is what makes the loop safe to run autonomously.

I implemented the same pattern. Every morning, after the compiler organises raw material into draft articles, an independent review process scores each one on accuracy, knowledge value, structural quality, and potential for harm. Articles that pass get promoted to the permanent brain. Articles that don’t get sent back for revision or rejected entirely.

Nothing enters the permanent brain without review. That’s the rule that makes the whole system trustworthy.

JUMPERZ put it well: “agents that own their own knowledge layer do not need infinite context windows. They need good file organisation and the ability to read their own indexes. Way cheaper, way more scalable, and way more inspectable than stuffing everything into one giant prompt.”

The briefing layer: agents that wake up informed

The final piece is briefings. In the original Karpathy pattern, you ask questions against the wiki when you need answers. That’s reactive. You have to know what to ask.

In a multi-agent system, you need something proactive. Agents need to start each session already knowing what the swarm has learned.

Every morning, after the quality gate has done its work, a briefing generator reads the approved wiki and produces four filtered documents. A content briefing for writing and publishing tasks. A sales briefing for pipeline and outreach work. An operations briefing for business management. And a general briefing that covers everything at a strategic level.

Each briefing is filtered by relevance. The content briefing doesn’t include pipeline details. The sales briefing doesn’t include content performance data. Each agent gets exactly the context it needs and nothing more.

This means when I open a session to work on content, the AI already knows that my newsletter is overdue, that the legal sector article got strong engagement, and that three new content angles emerged from this week’s meetings. I didn’t brief it. The system did.

In autopilot terms: the instruments are already reading correctly before the pilot touches anything.

You don’t need my setup to start

I’ve described a system with 24 automated tasks, six AI agents, and a multi-layered architecture. It sounds complex. But I built it incrementally, over weeks, and it started with something much simpler.

Here’s what you can do this weekend:

Set the heading. Create a folder. Inside it, create a file called goals.md. Write down what you’re trying to achieve. This is your flight computer. It doesn’t need to be perfect. It needs to exist.

Add sensors. Create a subfolder called inbox. When you find something useful, save it there. A link, a note from a call, an idea. Just get it out of your head and into the system.

Let the AI compile. Once a week, give your AI tool the contents of your inbox and goals file. Ask it to organise what you’ve collected into a few summary articles. Save those articles in a wiki folder.

Ask questions. Give the AI your wiki folder as context and ask whatever you need. “What do I know about this client?” “What patterns am I seeing?” “What should I focus on this week?”

File the answers back. This is the step most people skip. Save the answer as a new file in the wiki. That’s what makes it compound.

Five steps. One folder. No special tools. That’s the entire Karpathy pattern, and it works.

Everything else I’ve built, the quality gate, the briefings, the automated pipeline, those are just automation layered on top of this loop. The loop is what matters.

Where this is going

I’m a month into this. The wiki has 235 files and 188,000 words. Nine articles just went through the first quality gate review. Four briefings generate every morning before I wake up. 24 tasks run overnight, every night.

The system is still young. But I can already feel the difference. When I prepare for a client call, the briefing has already assembled what I need. When I write content, the wiki surfaces patterns I’d forgotten I noticed. When a new opportunity comes in, the system can cross-reference it against everything I know about that sector in seconds.

The autopilot holds the course. I decide where we’re going.

Karpathy said the natural extrapolation is a team of LLMs that iteratively construct an entire wiki, lint it, loop a few times, and write a full report.

I think the extrapolation for operators is different. It’s a system where your knowledge compounds whether you’re working or not. Where every meeting, every link, every conversation adds to the base. Where you wake up to a system that’s already smarter than it was yesterday.

That’s not science fiction. It’s a folder of markdown files, a few automated tasks, and a quality gate that keeps the noise out.

The brain builds itself. You just steer.