Say you have an AI gather your notes and the things you read into pages, one per subject. Pointing an AI at a folder of Markdown notes and letting it keep the pages up to date is one way people do this. For the first few rounds you remember which sentence came from which note. But as the page is revised every time you hand over a new note, you can no longer tell where a given sentence came from. You can ask the AI afterwards, "where did this sentence come from?" But what comes back is a note that looks right. Whether it is the note the AI actually read when it wrote that sentence, there is no way to check.
A page the AI builds in Graphium looks like the one below. It is part of a page called "Sourdough bread hydration", built from the sample that ships with Graphium (notes from baking the same loaf again and again).
Sourdough bread hydration
At 65% hydration with bread flour, the loaf had a fine, tight crumb (Trial plan and log)
Increasing hydration to 75% gave the most open crumb of the trials (Trial plan and log)
At 75% hydration with an all‑purpose flour containing 11 % protein, the dough never tightened during four sets of folds, remained sticky and never became glossy (Trial 7 - 75% hydration, lower-protein flour)
If hydration is pushed too far, the gluten network cannot support the water, the dough slackens, the loaf bakes flat, and the crumb becomes tighter rather than more open (Reading notes - hydration and crumb structure)
The text in parentheses is the title of the note the sentence came from. On screen it is a link to that note. This page was gathered from 8 notes, and the References section at the end lists those 8.
Graphium calls this page a "topic". Having an AI grow pages this way follows the "LLM Wiki" idea proposed by Andrej Karpathy, where an AI keeps writing and updating the pages of a wiki. What I cared about on top of that is where each sentence comes from.
Press Add to Knowledge in the note header and the AI reads the note and routes its content into topics, one per subject. If a related topic already exists, the AI revises that page. When it does, the AI is asked to attach the source note to every sentence that states a fact.
I think a sentence written by an AI is hard to use unless you can see what it came from. You could have an AI look for the source afterwards. But what that finds is a note that looks right. Even for a sentence that has no source at all, a nearby note turns up, so the sentence looks supported. Attached at the time of writing, the source is a record and not a guess. Open that day's note from the link at the end of the sentence and you can check what kind of trial the flat loaf actually came from.
I also tried to keep it from becoming something you leave entirely to the AI. Adding a note to knowledge is always something you start yourself. How a page was revised over time stays in that page's history. When similar topics appear Graphium points them out, but it never merges them silently.
You can open this "Sourdough bread hydration" page yourself in the sample notes. Looking at the sample needs no AI connection. Pick Topics under the Knowledge tab in the sidebar.
https://kumagallium.github.io/Graphium/app/?demo=bread-en
Building topics from your own notes needs an AI. You register at least one model in the desktop app first, and the browser version does not show the contents of your own Knowledge. Topics about the same subject can also end up split in two, for instance because of spelling variants, and whether to merge them is your decision. And a sentence carrying a source does not mean the source really says so. That is checked by a separate feature, the source check.
The kinds of topics and how to keep them tidy are covered in the "Knowledge layer" page of the manual. The flow that takes key points out of notes and keeps them linked to their sources was completed in v0.7.0 (2026-05-21), and gathering them into one topic per subject came in v0.75.0 (2026-09-16).
https://kumagallium.github.io/Graphium/manual/knowledge-layer
The LLM Wiki idea is described by Karpathy on this page.
https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f
Graphium is open source on GitHub.

Top comments (14)
Attaching the source at the moment of writing is what makes the link a record, and the revision after it is where that record gets tested. Say a later trial contradicts the 65% sentence. The AI can keep the old sentence with its old link, rewrite it and cite both notes, or drop it, so that only the page history remembers what the earlier note said. Each of those tells a reader something different about what is still true. Which one does Graphium do today, and when a sentence is dropped, does its note leave the References list as well?
Good question, and checking it showed me a gap. When a later source contradicts the 65% sentence, Graphium keeps both: the old sentence with its old citation, and the new figure as a separate sentence with its own. It lists the disagreement under “Disagreements & open questions” and doesn’t decide which one is true. A sentence is rewritten or dropped only when the same note is re-read and no longer says it.
The gap was that “keep both” lived only in the instructions to the model. Nothing checked it. Now Graphium compares the citations before and after each revision. If every sentence citing a note it didn’t re-read has disappeared, it asks the model once more to keep them.
On References: until now a note stayed in the list even when no sentence cited it any more, so the list looked like it backed more than the text did. The note still stays, because it was read and the provenance should say so. But it now moves to the end, marked “read, but not cited in the current text”. The page history keeps what the earlier version said. In the next release, each sentence will also carry the passage of the note it was written from, so you can see exactly what the earlier note said.
Moving an uncited note to the end with that label is a good call: the list stops overstating the text, and nothing that was read disappears. One thing the Disagreements section could carry cheaply is the date of each note next to its figure. Without it, a reader sees 65% and the newer figure side by side and cannot tell which came later, and order in time is often the first question a reader asks, even though it settles nothing about which figure is right. Will the per-sentence passage in the next release stay as it was when the note itself is edited later?
Both are in now. Under “Disagreements & open questions”, each figure’s citation is followed by its source’s date: the note’s creation date, or the paper’s year when Graphium knows it. As you say, it doesn’t settle which figure is right, but it answers the first question a reader asks.
On edits: the passage stays as it was until the note is read again. When it is, every passage is checked against the note’s current full text. If the note no longer says it, the passage isn’t removed. It stays with a mark, and the sentence shows “the passage the AI copied isn’t in the source”, so the page records what it was written from and that the note has changed since. The note’s own history keeps the earlier wording. If a later version says it again, the mark goes away.
Keeping the mark instead of removing the passage is the right default, and the note history makes it recoverable. One gap I would check is the time between an edit and the next read. If a note can change without being read again, for example when it is edited in another app, the page keeps showing its sentences as supported until someone triggers a read, and for a note nobody reopens that can be weeks. Storing a hash of the note text with each passage would let the page compare on open and show that the source changed since it was written, before the full passage check runs.
Thank you, this is a real gap. Even when a note is edited inside Graphium, the page isn't rewritten until that note is read again. Your hash idea helped me think it through, and I ended up with a small variation. I worried that a hash of the whole note would change on every edit, even a fixed typo, and that a warning showing up that often would soon be ignored. So when a page is opened, Graphium now looks at the notes that changed since the page last read them. It checks whether the passages the page copied from each note are still there, using the same string match as when the page was written. If a copied passage is gone, the top of the page says so, lists the note, the sentence and the passage, and offers to re-read that note. No model is involved, and nothing new is stored. For now it covers notes only, and it can't catch an edit that keeps the passage but changes what the surrounding text means. It's in v0.137.3.
Checking the copied passage instead of the whole note is the better trade, since a fixed typo no longer raises a warning that people learn to ignore. For the case you left open, an edit that keeps the passage but changes what it means, one cheap step would be to include the sentence before and after the passage in the same string match. A rewritten context would then show up even when the quote itself survives. It would still miss a change made further away in the note, but it covers the most common way the meaning shifts.
Thank you, that’s a simple step and it covers the case I left open. I’ve added it. When a topic is written from a note, it now also keeps the sentence just before and just after each passage it copied. When the page is opened and the note has changed since, Graphium compares the sentence now next to the passage with the one it kept. If a number changed, or the wording changed by more than a couple of characters, a separate and softer line says so and shows the sentence as it was and as it is now. One detail I had to get right: at first I treated a sentence inserted between them as harmless, but that skipped exactly the case you described, a caveat added right after a figure. Now that counts too. Two things still don’t: a fixed typo, and text added at the end of a note after a passage that used to end it, since appending to a note is the most common unrelated edit. As you said, changes further away in the note are still missed. Pages written earlier start keeping these sentences the next time their note is read. It’s in v0.137.4.
Attaching the source link during synthesis instead of running a post-hoc search fixes the nastiest failure mode in LLM wikis. Once a topic page goes through three or four revisions, a backward attribution pass almost always matches a plausible neighboring note rather than the file the model actually read.
One boundary worth watching if you ever extend Graphium beyond plain Markdown notes into PDFs or research papers is chunk-level provenance before synthesis. When a note comes from a multi-page PDF, page-level links alone get painful to audit if you have to hunt through a 30-page paper to check one number. Carrying section headings and table captions down into the extracted Markdown blocks lets the sentence link point to a specific heading or page anchor, and keeps your separate source-check feature from flagging numbers that simply lost their table headers during extraction.
The explicit merge prompt for split topics is a smart guardrail too. Silent auto-merging between near-duplicate subjects like spelling variants tends to corrupt long-running knowledge bases faster than leaving two separate pages around for a human to reconcile.
Thank you, and yes, that matches what I saw: after a few revisions, the “nearest” note is usually the one a backward search finds.
Graphium already takes PDFs, Word files and web pages as sources, not just notes. Your point about where inside the source holds, though. When you run the source check on a page, it tries to show where each quote sits in a PDF, such as “Page 12”. It only does this when the model’s quote appears word for word in the extracted text, and it leaves the line out when the same wording appears on more than one page. I haven’t yet measured how often it lands on the right page with real papers, where two-column layouts and headers make extraction messy. The sentence link in a topic, on the other hand, still points to the whole document. Carrying the page or heading down to the sentence itself would make checking much easier, and I’ll keep your note about table captions in mind for that.
A string match between each sentence and the note it cites catches most invented links before a second model has to judge them. It's cheap, and it's deterministic, so a failure can be reproduced.
Thanks, this pushed me to build it. One snag in Graphium: the sentences in a topic are paraphrased, so matching a sentence directly against its note rarely hits. So I moved the string match one step earlier. When the model writes a sentence, it now also copies, inside the citation, the passage of the source it is restating, word for word. Before the page is saved, Graphium searches the source text for that passage. No second model, and the same result every time. If the passage isn’t there, it is dropped, and that sentence goes to the source check like any other. In a first measurement with an open model, 99% of the passages were found in the source. The one that wasn’t had a word “corrected” by the model. A side effect I like: the citation can now open a PDF at that exact passage instead of at page 1. It ships in the next release.
@kumagallium thanks, glad it pushed you to build it. Checking the passage at write time is the right place for it: a verbatim substring test gives the same answer on every run, so a failure can be reproduced. I would keep the 1% miss visible rather than fix it quietly. A word the model corrected is exactly what a reader should see, so that sentence should fall to the source check.
Agreed, and it’s in now. A passage that isn’t found in the source is no longer removed. It stays on the page with a mark, and the sentence shows “the passage the AI copied isn’t in the source” right after its citation. The source check details show the passage the model actually wrote, next to the verdict, so you can see which word it changed. Passages are also checked against the whole source now, not just the window the model read. That catches a second case quietly fixing would have hidden: a note edited after the page was written.