I read constantly and remembered almost none of it. Newsletters, podcasts, and long articles each felt important in the moment and then evaporated. Highlights piled up in apps I never reopened. And the obvious fix, “just have an AI summarize it,” made things worse: a wall of confident, ungrounded summary with no way to know which source said what, whether two things agreed, or whether the same model would even say it again tomorrow.
The problem, precisely
The failure wasn’t a lack of summaries; it was the absence of everything that makes a summary trustworthy. Where did this claim come from? How many independent sources actually said it? What model produced this note, with which prompt — and can I regenerate it? Without provenance, corroboration, and reproducibility, a knowledge base is just a nicer-looking pile of forgetting. A note you can’t trace is a note you learn to ignore.
The approach
I built Mimir around a small set of non-negotiable invariants and made everything else swappable. Every artifact — including my own notes — lands in a content-addressed raw store before anything touches it. Every derived note carries a full provenance manifest in its frontmatter. Derivation is stateless and idempotent: the same raw source, prompt version, and model always reproduce the same note. The vault is a git repo, so deltas are just commits. And endorsement stays human-only — the pipeline records who said what and computes corroboration, but it never decides for me what’s true.
A note you can’t trace is a note you learn to ignore. Provenance isn’t a feature — it’s the whole point.
What we built
ingest derivation chain (per source) vault (git repo)
┌────────┐ ┌────────────┬───────────────┬────────┬──────────┐ ┌──────────────┐
│ paste │──▶│ source_note│ extract_claims│ dedup │ entities │─▶│ corpus/… │
│ email │ │ (no LLM) │ (LLM producer)│(embed +│ (link or │ │ personal/… │
│ …later │ │ │ │ LLM) │ create) │ │ hubs/… │
└────────┘ └────────────┴───────────────┴────────┴──────────┘ └──────────────┘
every stage = a job row in SQLite; workers claim → run → advance.
the control plane (pause / hold / throttle / step) gates every claim.
Two ideas do most of the work:
- The generating key —
(provider, model, params, prompt_version, input_hash)is stamped into every note and used to name each stage’s intermediate output. Any note is reproducible; running two models over the same source produces two keyed outputs instead of clobbering one. - Produce ≠ commit — producer stages only write a keyed intermediate; committer stages write the vault. That one separation is what makes eval-compare (run a stage under several models, approve the winner), offline import, and promote-to-cloud clean to add rather than bolted on.
Underneath sits a provider-agnostic LLM layer: a single OpenAI-compatible adapter serves OpenAI, OpenRouter, and local Ollama, and each stage independently picks its provider, model, and params. Every call logs tokens, cost, and latency to the same SQLite ledger — which doubles as the substrate for per-stage evals. The whole thing runs on one docker compose up, or entirely local and free against Ollama.
Where it stands
The derivation chain is real end-to-end — no stubs left. A pasted or ingested source becomes a source note, gets its claims extracted, deduplicated against the existing corpus by embedding similarity plus a cheap-model confirm, and resolved against known entities. Claims and entities that recur across sources collapse into a single note carrying multiple attestations and mentions — corroboration you can see. I validated the local path on fifteen real Substack newsletters, and every generated note carries the exact key that produced it.
What’s next is the part that makes it a habit rather than a demo: email and RSS ingestion so my actual reading flows in without pasting, the audio chain for podcasts, an interactive dashboard to drive the control plane, and a promote workflow that ships validated local notes to the cloud with zero recompute. The invariants are already paid for — each new source type is now mostly plumbing into a chain that was built, from the first commit, to remember why.