There is undeniable value in voice, but it has limits. You can’t use it everywhere — even whispering in a café, you don’t speak the way you would alone — and it can’t ingest a long article, an image, or a video. Sometimes writing by hand simply produces a higher-quality flow of information, slower though it is.

Ingestion also can’t be confined to the app. I want to capture and retrieve from anywhere — a voice note from my phone on a bike ride, or pulling the right context straight into a chat with ChatGPT. Scribe only becomes magical once a lot is in it, so the cost of getting things in has to be as close to zero as possible.

The work the librarian was doing was undeniably valuable — I found myself dropping Notion and Apple Notes in favour of a tool that knew my whole base, filed what I gave it, and retrieved the latest version when I asked. So Scribe exposes that through an MCP server: ingest and retrieve from any agent. Point ChatGPT at your base and ask “what are the top three things I recently added to my task list?”

In this day and age, context is power. The gap between idea and execution is collapsing, which drives up the value of a good idea — so retain it, and put it to use.

You write and talk; it files. The agent runs on every compile and can also be invoked directly when you want it to reorganize a corner of the vault.

Everything starts as capture. A voice memo on a walk, a web page clipped mid-read, a paragraph typed into the composer, a note pushed in by an external agent over MCP — all of it lands in a single inbox, untouched and unstructured. Nothing is filed automatically; capture is deliberately cheap and lossless so the cost of writing something down never exceeds the value of having written it.

The inbox is a holding pen, not the wiki. Items sit there until you compile them, which means a bad capture never pollutes the base and a half-formed thought can wait until it has company. In practice most people compile in small batches — a handful of related captures at once — which gives the agent enough context to place each one well.

Compiling is where raw capture becomes knowledge. The librarian agent reads the new material, retrieves the pages it might touch, and works out a plan: which existing pages to edit, what to merge, where a new page is warranted, and which links to install. It then drafts the changes and hands them back as proposals rather than writing them straight to disk.

Crucially, the loop is iterative. The agent can open a page, realize the change implies a second edit elsewhere, and follow that thread — the same way a careful human editor would. Each step is a tool call against the vault, so the whole compile is legible after the fact: you can see exactly what it read and why it proposed what it did.

A knowledge base, it turns out, is a lot like a codebase — so Scribe borrows from Git. Large or destructive changes pass through a review gate, every update carries a full diff, and version history lets you revert.

The analogy runs deeper than diffs. Pages have something like a dependency graph through their links; a rename can ripple; a merge can orphan a reference. Treating those as first-class operations — rather than blind text edits — is what lets the agent be aggressive about keeping things tidy without quietly breaking the connections you rely on.

The review gate is the trust model. Anything large, destructive, or cross-cutting stops here as a proposal, attributed and reversible, until you accept it. Small, page-local, in-context edits can stream straight to the page you're looking at; a four-page compile that splits a page and rewires its links earns a proper report.

This is the difference between an assistant you supervise and one you trust. Because nothing is final until you say so, the agent is free to propose the bold reorganization rather than the timid one — and you stay the editor-in-chief without having to do the filing yourself.

Every accepted change is a commit. The history is yours to walk: see how a page reached its current shape, diff any two points in time, and revert cleanly if a compile took a wrong turn. Reverting a change also unwinds the links it installed, so the graph never drifts out of sync with the prose.

Once it’s in, knowledge is reachable three ways: ask in chat, jump through search, or let any agent read it over MCP. The same channel works in reverse, so you can hand the right context to whatever tool will do the work.

Retrieval is the whole point — a base you can't get back out of is just a tidy graveyard. So Scribe treats the wiki as something to be read constantly: by you, by the chat, and by external agents that already have your context the moment they connect.

The vault is plain files on your disk. No lock-in, no server round-trip to read your own notes, and full function offline. Sync, when you want it, is layered on top rather than baked in — the source of truth is local, which is what makes the whole thing feel like yours.

Because it's local-first, nothing leaves your machine unless you connect an agent that reads it. The MCP server is scoped to the vaults you choose, and writes always land in the review queue rather than the live wiki — so even a connected agent can propose, but only you can commit.

The hard part isn't capture or retrieval; it's judgment — knowing when two notes are really the same idea, when a page should split, when a contradiction is a correction versus a nuance. The agent is good and getting better, but the review gate exists precisely because that judgment isn't perfect yet. The next frontier is making review itself faster: better summaries, tighter diffs, and surfaces like this one that let you move through a big change without losing the thread.

That gate is the whole trust model: the agent is free to be aggressive about keeping the vault clean precisely because nothing it does is final until you approve it.

Scribe is built for the information you can’t Google: personal thoughts, private conversations, and the niche things you found once and will never find again. It isn’t a public wiki or a second brain you have to tend — it’s the base that tends itself.

The agent does the work; Scribe makes it trivial to hand over the right pages.

The server runs locally and is scoped to the vaults you choose. Nothing leaves your machine unless an agent you’ve connected reads it, and every write lands in the review queue rather than the live wiki.

Flat vector search finds pages that look like your query. Agentic retrieval goes further: the librarian holds a map of the vault — taxonomy, backlinks, page summaries — and uses it to decide which pages to open, in what order, and when to follow a link to a related note.

The value compounds with size. Once there’s a lot in the base, the connections between notes carry as much signal as the notes themselves. See GraphRAG.

The agent uses the same machinery you do, just with more context — it can read any page, search across everything, and follow links while it compiles.

Tauri shell, React + TipTap editor, Claude driving the compile loop, and an MCP server exposing read and capture.

A flat index treats every note as an island and ranks them by similarity. A graph treats the links between notes as first-class — so a query about one idea can surface the chain of notes it connects to, not just its nearest neighbours.

The librarian’s map of the vault is the graph; Agentic retrieval is what walks it.

All five now resolve to the same destination, so the concept reads consistently across the vault. These links exist only if the new page does — they ride on change 1.

Backlinks keep the graph honest — every mention is a real edge the retriever can follow. Depends on change 3.

It’s a cognitive prosthesis: capture thought from voice, typed notes, web pages, and anything pushed in over MCP, and compile it into durable, interlinked knowledge.

It’s most valuable for the information you can’t Google — personal thoughts, private conversations, and the niche things you found once and will never find again.

Push-to-talk for a quick thought, tap-toggle for a longer one, the text editor when your hands are better than your voice, and MCP for anything an external agent pushes in.

Two pages collapse to one, but check nothing unique was dropped — the merge can’t tell a duplicate from a deliberate distinction.

Nothing is filed automatically — capture stays cheap and lossless, and the librarian only acts once you compile.

This edit only makes sense if the merge above is accepted; on its own it’s editing a page that doesn’t exist yet.

Building Scribe · Roadmap · Capture · MCP · Development · Privacy — all six now read “Personal knowledge base”.

The count is the easy part to trust; whether each backlink still reads well with the longer title is the part only you can judge.

Voice was first, but it was never going to be the whole story — text, clips, and MCP all land in the same inbox now, so the roadmap should stop treating it as the headline.

Next up: tighter Agentic retrieval and a faster review surface for big compiles.

When a compile or a retrieval regresses, the failing case becomes a fixture. The suite grows from real misses, so the agent gets harder to fool over time.

It’s the clearest sign the librarian isn’t a static prompt but a system that measures and corrects itself — worth its own page.

That habit — letting the tool maintain its own memory — is the whole product, generalized beyond code. It’s good context for the case study, though it may belong there rather than here.

Ask ChatGPT for “the top three things I added to my task list,” or kick off a Claude session that already has your context.

Cap concurrent agents at what one person can meaningfully review in a day; treat everything past that as queued, not parallel.

Each seed graduates to its own page once there’s enough to say. Until then it lives here, linked to the notes that feed it.