Ten thousand notes in practice: drop the vector database, let plain markdown make your knowledge reusable by agents
Turn 10,994 Notes Into Memory - Paul Iusztin, Decoding AI & Louis-François Bouchard, Towards AI · Paul Iusztin
40 min total·Actually worth watching closely: ~15 min·3 must-watch clips
- 0:00 – 7:01Listen
Why you need another layer between the assistant and your notes
The two speakers open with an embarrassment everyone shares: ten thousand saved items and never going back to them. They argue that between terminal assistants like Claude Code and note sources like Obsidian and Readwise, a layer is missing that connects the two.
The problem isn't too few notes — it's that nothing you've saved has any mechanism for being pulled back out.
It's the two of them talking the whole way with nothing to look at on screen; listening while commuting or doing something else loses nothing.▶ Jump to 0:00Speaker · Paul Iusztin、Louis-François Bouchard - 7:01 – 14:07Listen
Context goes to zero when you stop, plus the project repo
Explains that for an assistant the context window doubles as database, filesystem, memory and reasoning space all at once, and it all disappears when the conversation ends: every new session means pasting the material in again, and whatever scripts it wrote on the fly go with it. Then introduces the open source project itself.
What's missing isn't a bigger context window — it's memory and context management, so information survives between sessions.
This stretch is pure argument; the screen stays on the talking view with nothing substantive changing, so the points alone are enough.▶ Jump to 7:01Speaker · Paul Iusztin - 14:07 – 21:12Skim
Three versions: from aiming at the public web to aiming at yourself
A retrospective of the three revisions. The earliest targeted the public web, ran on hand-picked golden links, and output one static document; the second turned the same deep research loop around to point at their own note vault; the third added a wiki layer because a static document can't absorb follow-up questions.
The real turning point was realizing research is inherently iterative — with a static artifact, every follow-up means rerunning the whole thing at absurd cost.
Most of it is the evolution argument over version diagrams, so you can scroll through fast; around 20:48 the screen cuts to a real index file — slow down there.▶ Jump to 14:07Speaker · Paul Iusztin - 21:12 – 28:13Watch
The three file layers and the tiered fallback query
Breaks down what the wiki is made of: an immutable raw layer, a derivatives layer holding model-written concept pages, entity pages, comparisons and questions it couldn't answer yet, and the index as the entry point. A query reads the index summaries first, the source pages if that isn't enough, and only then the raw text.
The summary is computed exactly once, at ingestion; every query afterwards eats that finished result — a one-time cost traded for long-term token efficiency.
The screen shows the real files open and the links between them, and around 22:42 there's a demo of how concepts connect visually. This structure is abstract in words alone — you need the screen to map it.▶ Jump to 21:12Speaker · Paul Iusztin - 28:13 – 32:07Watch
Demo one: a deep research run and the traces it leaves
Kicks off a deep research run against his own wiki live, shows that the number of rounds and the cost are adjustable across light, fast and deep, and explains that every question leaves new pages and records behind in the wiki.
The wiki is alive — it doesn't only grow when you ingest material, it grows with every question you ask, ending up a true reflection of what you haven't understood yet. Light or fast is enough day to day; deep takes ten to twenty minutes a run.
What matters is the run itself and the files that appear once it finishes; audio alone misses the key evidence — what changed in the wiki after the question.▶ Jump to 28:13Speaker · Paul Iusztin - 32:07 – 35:14Watch
Demos two and three: ingesting code repos and a single link
Skips the research stage and hands three open source terminal-assistant repositories straight to the system with the topics to explore, producing per-repo architecture notes and a cross-repo comparison; then demos the simplest form — drop in a few links and it runs.
A codebase can be a first-class research object, and the whole path has no external dependencies: install the plugin, throw in links.
The value is in how the prompt is written, the automatic cloning and generation, and the comparison files that come out at the end — all of which only exist on screen.▶ Jump to 32:07Speaker · Paul Iusztin - 35:14 – 39:32Listen
Owning the gaps, and what this project is for
States plainly that the project's first purpose is teaching memory and context management rather than shipping a product, which is why it deliberately stays in the terminal workflow and only wires up the sources they actually use. Also admits the biggest open problem: it can't judge how current or how trustworthy a source is.
Source provenance and trust tracking is an open problem for the whole personal knowledge system space — don't expect an off-the-shelf answer.
The close is spoken trade-offs and next directions with the screen back on the talking view; listening is enough.▶ Jump to 35:14Speaker · Paul Iusztin