Everything you do throws off knowledge: conversations, mail, meetings, messages, what you read. Right now it is scattered across a dozen apps and most of it is gone in a week.
Picture a pipe of water. In the meeting, the pipe is full. A year later you remember two things from that project and the rest never happened. Meeting notes are thin. People leave with what they know. Your best reasoning happens in a chat with an AI and vanishes when the tab closes. That is the leak, and everyone has it.
A knowledge factory catches all of it, files it, and keeps one current page for every area of your life or business and every person in it. Machines do the filing at night. You never file anything again.
It is a factory, not a vault, because knowledge is only half of it. Your automations, skills and agents live in here too, on top of the knowledge. Each one is its own little machine that gets better from its own runs and your feedback. The knowledge compounds, and so do the things that work on it. A knowledge base is a warehouse: things go in and nothing happens to them. A factory takes raw experience in one door and sends knowledge out the other, and the factory itself is the asset.
Why this is the highest-leverage thing you can do right now: the models are already capable, and they are only going to get better. Given the right context and guidelines they can do about anything. What they are missing is you. Every AI tool is only as good as the context you give it, so you keep re-explaining yourself to every tool, and every new agent starts from zero.
You can invest $1000s in automation and agents right now. That stuff is likely to look completely different in six months. What is not going to look different is all of your knowledge. A knowledge factory builds the foundation to make sure that you don't fall back to 0 every time you need to update or rebuild.
Two more reasons. Own the knowledge and the systems, and rent the intelligence: the frontier is a back-and-forth race, and the factory sits underneath Claude, Codex, Cursor, ChatGPT or whatever comes next, so you move between them and lose nothing, automations included. And for a company, this is the value nobody else has: the knowledge, the automations, the agents, the skills and the processes, accumulated in one place, so the value of the company stops depending on the humans in it.
I. Where it comes from
Raw evidence, maintained knowledge, replaceable intelligence.
The shape builds on Andrej Karpathy’s LLM wiki: keep your raw sources untouched, let a model compile and maintain a layer of pages on top, and write the rules down so another model can continue. The tedious part of a knowledge base is the bookkeeping. Give that work to the machines.
The bet is simple: context plus the right guidelines lets capable models do useful work. The foundation is a structure they can keep current, and evidence that remains available as the models improve.
Build only what earns its place. A custom interface, a second task system or a routine that only checks another routine can become more work than it saves. Improvement includes deleting.
This guide comes with one setup file. Your assistant uses it to build the factory in Notion, personalize it and connect the runners that can do the work.
II. The ideas behind it
Eight. Everything in the factory follows from them.
Keep the raw sources, and never edit them
Whatever comes in stays exactly as it arrived, and every page written from it links back. Keep the raw because the models are going to get much better. A summary written today is the ceiling on what a future model can learn from today; the raw is not. The question is not how to build the perfect structure. It is how to collect the information so you have it when GPT-15 comes out. You will not get the structure perfect, because things change too fast. A structure that gives value now and can be split into a new one later is the whole game. It also makes correction cheap: you never have to trust a conclusion, because the thing it came from is still there.
Every arrow works backwards too. From any page you can walk to the exact message it came from.
One current page per thing
Every area and every person has one page that says what is true right now. When something changes, the sentence is replaced. The old reading survives in the log. A page you have to read top to bottom in date order is a page nobody reads. Catching up is a read of the page, not a search.
Structure serves the searcher
The reader here is an agent with a context window, and it should never have to load the whole factory to answer one question. So the factory is split into areas, each with a short map of what is inside, and an agent working on your company goes straight there and ignores the rest. Context is everything, but only the context you need. Heavier machinery gets added only when walking the tree demonstrably fails. It has not yet.
Judgment over rules
These are smart models. Give them goals, context and real boundaries. The core databases and their relationships provide a stable structure; methods, models and tools can improve around it. Identifying a person takes context and judgment, not just a matching phone number. Keep technical examples as help, not as limits on what an agent may figure out.
Every fact lives in one place
A fact lives in one area and everywhere else links to it. A rule written in two places will drift. Shared guidance lives on the root, each routine owns its definition, and reusable methods live in Skills. Every runner reads the current pages through a short pointer. Construction history stays in a setup record, outside everyday context.
Connection is the value, not storage
The value is connection: a walk, a podcast, an old decision and a client’s mail become useful together. Preserving a capture, reviewing it and incorporating what it means are separate steps. The nightly pass keeps current understanding accurate; the weekly pass connects ideas across areas. A folder full of originals, or an empty filtered inbox, proves neither.
Own the knowledge and the systems. Rent the intelligence.
Own the knowledge and the definitions; choose the intelligence that serves you. Notion holds the evidence, working instructions, routines, skills and their supporting code. Notion agents, Claude, Codex or another runner supply execution, tools and scheduling. Temporary execution files are fine; required knowledge or instructions hidden on one computer are not. Changing assistants should mean reconnecting to the same factory.
Machines that leave receipts and improve weekly
Each machine has a goal, live instructions, a concise receipt and your feedback in your exact words. The goal keeps the work pointed at what you wanted. A reviewer improves the instructions from actual results without changing the goal or expanding permissions. A receipt shows what happened; useful downstream knowledge shows whether it worked. A correction may justify removing a rule, not adding one.
III. What is inside
One page in your Notion. Under it, a store and a few pages about you.
Areas. Three to six parts of your life or work you actually act in. Everyone gets a personal one; the rest are one per business, venture or major role. The test: if it has its own money, its own people or its own slot in your week, it is an area. If you only think about it, it is a topic inside one. Areas are born when your life changes, never because a subject grew large. Keep them few.
Knowledge pages. One page per subject, titled by the subject: Pricing, not “Pricing call with the board, March.” The page changes as understanding improves and splits when it no longer fits one subject. Decisions are the exception: a later one supersedes an earlier one and both stay, with their reasons and evidence.
People. One page per person or group you deal with, kept current every night. People show up across every area of your life, and filing them under one loses the rest.
Your pages. Two are yours alone: who you are and what you are aiming at, and how you want an AI to work with you. Every assistant reads the second one before it does anything, and it travels with you to every tool. The other two the machines keep current: what is running now, and what they are watching for you.
The record. Meaningful changes, concise run receipts and your feedback. One task authority for outcomes and decisions; use an existing one if it already works. Routine progress belongs in receipts, not your task list.
Skills. Notion’s native Skills library holds reusable methods. Agents read a skill when the work calls for it; they do not install a copy and let it drift. Short code can live inline, larger helpers on linked code pages. A skill inherits the caller’s permissions. The skill for creating routines belongs in development work, not in every nightly run.
IV. The machines
Three that matter, the feeders that supply them, and a door.
The loop has three moves: get the information in, structure it, and surface it when it helps. The machines serve those outcomes.
The filer runs when something new lands and sweeps up the rest each morning. It reads what your areas hold, decides where this belongs, writes what the capture says, updates the knowledge pages, links the people, and leaves a receipt.
The keeper folds new evidence into the areas and people it touches. Independent passes can run in parallel with clear ownership; shared synthesis needs an integration owner. It replaces outdated understanding instead of growing an endless timeline.
The reviewer connects ideas across areas, resolves duplication and improves instructions from results and feedback. It also removes machinery that stopped earning its place. Changes to goals or authority remain your decisions.
The feeders are thin jobs that each do one thing: bring one kind of material in, as it is, and leave a receipt. Mail, calendar, your conversations with AI tools, voice memos, messages, what you bookmark. Meeting capture is the simplest example: when a meeting note finishes, it copies the transcript in with a link back and never summarizes. You keep working wherever you work; it gets pulled in behind you, and the pages you want kept current can be pushed back out nightly. No feeder sends, replies, forwards or deletes anything.
The morning brief is an easy, useful add-on, not a core piece: a few lines at the top of your Now page each morning with what matters today.
The door is whatever assistant you already talk to, connected to your Notion. Claude, Codex, Cursor, ChatGPT, Notion's own chat. There is no chat agent of the factory's own, because the knowledge is the asset and assistants are replaceable. Ask what you know about something and it reads the page. Say remember this and your words go to the intake. Say you got that wrong and they go to feedback.
V. Living with it
Read and correct. That is the whole job.
A thought arrives on a walk. You say it into your phone and keep walking. It lands beside the things you already thought about, ready to become useful context for the next conversation.
A friend texts about meeting up. By morning it is on the calendar, a task exists, and the message sits on his page.
You have a call this afternoon about something you have not touched in weeks. You open its page and read. One read, instead of a search across four apps. Same move for a person.
You ask the door what you decided about a supplier last month. It answers and names the page it read. It is wrong about one detail, so you type a sentence saying so. Sunday, the reviewer reads it in your words and fixes the gap.
Ten minutes a week is your whole share: read what changed, type over any wrong line, clear the tasks that need you.
How to think about it
Keep areas few and let useful topics grow. Start with today’s flow; if you already have a brain, bring its history over after the base works. Use a capable economical model and stronger judgment where the work warrants it. Long jobs checkpoint and resume within their allowance, instead of burning usage on polling or losing their place.
VI. Push its limits
Once the foundation is laid, the fun starts.
Useful extensions join the same loop: give them a goal, let them leave evidence, and correct them when they are wrong. The best ones come from the work you actually do.
A company memory. The same structure, owned by a company. Every call, thread and meeting with a client folds into one page about that client. Anyone walking into a call reads it and knows what the company knows. The value stops leaving with whoever leaves.
One area per property. A property manager gives each property its own area. Guest messages, contractor mail and turnover notes fold into it every night, and by morning the page says which guest issues still need attention and what was already promised, without reconstructing it from five threads.
A weekly update. A machine reads the week's pages and drafts your investor or team update by Friday. It never sends it. Your edits are the feedback that makes next week's closer.
Onboarding, done for you. A new tool asks your factory who you are instead of asking you. Onboarding should be as light as possible and end in something personal, and the system with the most context about you is the one that should do it. The assistant is just the orchestrator.
A family's memory. A house shared by six branches of a family. The stories the grandparents tell. The history that decays a little more each year as memories fade. One factory for the house, fed by whoever remembers.
A new feeder. Anything you can read through an API or a logged-in browser can become one: your bank, your product analytics, a support inbox, your sales calls. It writes captures and a receipt, and nothing else changes.
Set it up, learn from it, set it up again. The first time it runs on its own and comes back with something you did not tell it, you will know whether this is for you.
VII. Getting one
One file, a useful base, then the sources you choose.
What you need. A Notion workspace, an assistant that can read and write it, and a capable runner for the routines you want. Your assistant checks current plan requirements, integrations and costs before recommending the setup.
The setup. Give the file to your assistant. It builds the core structure, personalizes your areas and proves a small real loop before enabling recurring work. You make the meaningful choices and complete purchases; the assistant does the work it can. Optional sources and historical imports can follow.
What it costs. Cost depends on the runners, models and volume you choose. Check current prices and allowances during setup, agree on limits, and measure real runs before expanding. Start with a few useful sources rather than paying to process everything at once.
The limits. A runner needs access to its sources and time to execute. Device-bound sources may need a machine available. Usage limits and missing connections should leave a clear checkpoint and an honest limitation, so work can continue when access returns.
Build the knowledge first and the agents second. The knowledge keeps its value while everything else gets replaced. Take the file. Build yours today.