Designing a personal AI that reads hundreds of sources a week, so I don't have to.

The field moves faster than reading speed.

In a quiet week, 100 or more relevant sources arrive. The spring peak came close to 500. Nobody reads a meaningful fraction of that, and skimming loses the part that matters most: the connections and contradictions between sources, and the topics nobody has covered yet.

Capture tools do not fix this. They make piles, and piles rot. You cannot see what has gone stale, what contradicts what, or what is missing. My positioning depends on staying current in AI, so a rotting pile is a professional risk.

The system reads everything, so the handful I read closely is chosen rather than whatever happened to surface.

A note on method. I am the only person who can write to the system, so the evidence here comes from instrumentation rather than from users. Every number comes from the project's own dated records: commit history, migrations, eval reports, and the product's analytics, shown as captured.

It started as a Telegram bot that saved links.

First commit on February 23, in production on Railway by day two. Send it a URL and it saves instantly, then a background pipeline extracts, summarizes, scores, and embeds the source before messaging back the graded save.

Ingestion turned out to be the easy part, solved in the first week. The trust, agents, retrieval, and branching work in this study is what the next four months built on top of it. The capture layer is still that same bot.

Every source carries a priority score you can interrogate.

Each source row shows one value score from 0 to 100. It blends the model's priority rating with novelty against its own Space and the source's rank within its topic. The written reason sits one hover away, in the interface where you read rather than in a log.

A failed extraction is never dropped. The row saves and flags itself, with recovery one click away in the app or a /retry from Telegram.

A gap-analysis agent reads the corpus and reports what is missing.

Every source carries a decay state of active, aging, or stale. Aging trips automatically as newer saves supersede older ones. Stale requires a model review that docks the score.

The gap-analysis agent runs on demand, reading the whole corpus and reporting where coverage is thin against what the scoring says matters. Its first run, 5 weeks in at 627 sources, caught a blind spot. Five security subtopics were scoring at the corpus maximum with 8 saved links between them. The scoring had flagged the area as important and my reading had not kept up.

When a gap is confirmed, the research agent is the only sanctioned path to the open internet. It proposes topics, runs capped searches, sends every new source through the same scored pipeline, and supports per-run rollback. Against that security gap it pulled 45 sources.

Twelve specialist agents compose into behavior none of them has alone.

The corpus feeds 12 specialist agents, including connection discovery, contradiction detection, gap analysis, synthesis, research, and a reading-queue prioritizer that never calls a model at all.

Each one is simple in isolation. What makes them useful is composition. Agents write signals, which are machine observations reviewed like proposals and never applied automatically. By mid-April, at about 1,000 sources, they had written about 960 signals, roughly one per source.

All 12 started on weekly crons. At about $8 a week in model spend for a single user, I turned scheduling off. Every agent now runs on demand, and the only cron left is a 10-cent digest.

Chat answers only from the corpus, and says when the corpus falls short.

The daily interface is a conversation with the corpus.

A question gets embedded, and the system over-fetches 20 to 40 candidates from the vector store, since recall is cheap and the reranker judges relevance better than raw distance does. The top 10 go to the model under one standing rule. Every claim cites a named saved source, and when the corpus does not cover a question, the model says so.

That architecture was not there on day one. Chat shipped in week 4 as plain cosine top-k, and the over-fetch and rerank came three months later, after daily use showed a single similarity score could not carry retrieval alone.

Nothing in a conversation is ever overwritten. The first version truncated the thread on edit, and a reload could interleave stale and new messages. A conversation graph replaced it, with sibling branches, a version pager, and branch-from-here on any message. An outline rail with AI topic labels, bookmarks, and an auto-sort that only proposes (preview, approve, undo) keeps 100-message chats navigable.

Extractor routing lives in a database table, so tools swap without a deploy.

Extraction is adversarial. Platforms wall off content, public APIs add challenge screens, and managed builders drop system dependencies without warning. When a tool fails, the save still lands, flagged and incomplete, and every platform's extractor chain ends at the same universal fallback.

That routing table is why each swap was a single row change. Over five months a YouTube bot wall, a Turnstile challenge on the public cobalt API, and two managed builders dropping yt-dlp and ffmpeg from the deploy each forced a replacement. Almost none of the pipeline's tools are the ones it started with, and every tool call is logged with its duration and cost.

Two failures in June, both caught by measurement rather than by noticing.

An audit caught a schema change that had silently broken chat retrieval. For a stretch of time, every question drew zero context from the corpus. The grounding rule is why nobody got a wrong answer: with no sources to cite, the system said the corpus did not cover the question instead of improvising.

The same month, measurement caught the scorer burying good design work. A study I would rate a 9 sat at 0.30 on the 0-to-1 value scale, and only 5% of design links ever reached HIGH against a 20% target. The fix started with an eval harness rather than a prompt edit. A 50-link gold set, then a rubric rewrite, then re-measurement. Design links now clear 40%, and the floor moved up with the ceiling.

Both failures ran for weeks without being visible in normal use. The instrumentation is what surfaced them.

In production since day two, still compounding five months later.

Knowledge Hub is live: 865 commits and 249 merged PRs between February 23 and early July, a corpus measured at 4,339 sources in late July and still growing, cited chat on top, and 12 agents on call.

What changed for me is the part I did not build a metric for. Before, I bookmarked things and forgot them. Now I review far more than I did, I can retrieve something weeks after saving it, and the chat is where I start when I take on a new project or an unfamiliar topic. The system reads everything so the things I read closely are chosen rather than whatever surfaced that day.

There is a guest view. Friends, coworkers, and anyone else can read the corpus and browse example chats, without writing to it or running agents. Designing a read-only surface for people who did not build the system was its own problem, and it is the reason the interface had to make sense to someone other than me.

Every AI product I design follows the same rule: ground the answer or say you cannot. Knowledge Hub is where I hold myself to it, on a system where I am the only person it can fail.