Building Kaname

I read a lot. AI, geopolitics, compliance, technology futures. The problem is not finding information, it is that the good stuff is scattered across arXiv, the Federal Register, SEC filings, GitHub, and a dozen RSS feeds, and no commercial product monitors all of it the way I want. So I built my own: a daily research brief that reads like a newspaper front page, cites every claim, and runs entirely on hardware I own.

The app is called Kaname. Here is how it came together, and why the process mattered more than the code.

Start with architecture, not a repo

The first real work was not programming. It was a long design session that produced two documents: an architecture doc that captures every decision and the reasoning behind it, and a handoff brief written for an AI coding agent to execute. That split turned out to be the most important structural choice of the whole project. The architecture doc answers “why,” the handoff answers “what to build, in what order, and how to know it is done.”

The core concept is a daily research loop. You add topics from your phone. Every morning, a scheduler wakes up, queries a curated whitelist of open sources first (arXiv, OpenAlex, Semantic Scholar, Crossref, PubMed, Federal Register, SEC EDGAR, USPTO, GitHub, Hacker News, GDELT, plain RSS), then falls back to broader web search. An LLM synthesizes the findings into a cited brief with a strict output schema: headline, summary, why it matters, a glossary for unfamiliar terms, and sources. The synthesis voice is codified as a hard requirement, not a preference. Smart layman, no jargon without a gloss, every claim traceable.

The stack is TypeScript end to end: Next.js 15 as a PWA, Postgres 16 with pgvector, Prisma, pg-boss for scheduling, Auth.js v5 with passkeys, Serwist for the service worker, and Dexie over IndexedDB so briefs stay readable offline. The LLM layer is provider agnostic by design. Anthropic handles synthesis today, but the gateway means any model can slot in tomorrow. Embeddings run locally through Ollama on my own GPU.

The pivot that got reverted

Midway through, I asked for a Railway cloud deployment plan. We drafted the whole thing: hosted embeddings to replace local Ollama, pg-boss cron replacing systemd timers, a reconciliation table so the coding agent would not follow stale local-first instructions.

Then I scrapped it. Kaname is a personal tool holding my reading patterns and research interests, and I already own a Windows machine with a decent GPU sitting idle most of the day. Local-first won on cost, privacy, and the simple fact that the data is mine. The lesson was not that cloud is wrong. The lesson is that writing out the full cloud plan made the tradeoff concrete enough to reject with confidence, and nothing about it gets relitigated later because the reasoning is on paper.

The final deployment is a Windows home machine running the Linux stack inside WSL2. That required four non-obvious adjustments that are now documented as setup steps: enabling systemd inside WSL2, a Task Scheduler boot task plus a never-sleep power plan so the daily loop actually fires, and putting Ollama and Tailscale on the Windows host rather than inside the distro. Ollama gets native GPU access that way, and Tailscale Serve hands my phone a real HTTPS URL on the tailnet, which the PWA service worker requires. No ports exposed to the internet, no monthly bill.

Naming is harder than architecture

The branding phase surprised me with how much rigor it demanded. We ran roughly seventeen name candidates through knockouts across English, Latin, Japanese, Italian, and Sanskrit. The finding that killed most of them: every real word in the signal, knowledge, and clarity semantic fields is already claimed by some data or AI company. Dispatch, Mirador, Cerno, all crowded.

The winner was Kaname, written 要 in Japanese. It is the brass rivet at the base of a folding fan, the single point where every rib converges. Figuratively it means the crux, the essential thing everything turns on. That is exactly what a daily brief should be, and the metaphor handed us a logo for free. The mark, which we call the Sabre, is a K built from concave blade shapes where the letter’s junction is the rivet itself. The palette is warm paper text on cool near-black with brass as the single accent. Type pairs Newsreader for headlines with IBM Plex Sans and Mono for body and data. It looks like a newspaper that respects your eyes at night.

Handing off to an AI agent

Both major phases ended the same way: a handoff package for Claude Code. Not a vague prompt, a structured brief with phased steps, explicit done-when criteria per phase, scope guardrails, a behavior spec, and a verification checklist. The nav handoff even opens with a mandatory discovery phase, forcing the agent to read the actual repo conventions before writing anything, because guessing is where agents go wrong.

This is the workflow insight I would give anyone building with AI agents right now. The leverage is not in the coding session. It is in the design conversation that precedes it, captured in documents precise enough that the agent cannot drift. Decisions get made once, with reasoning attached, and the build becomes execution rather than exploration.

What I would tell you

Kaname exists because I refused to start with code. The architecture doc, the deployment reversal, the naming knockouts, the phased handoffs, all of it happened in conversation before the repo grew. The result is a tool that costs nothing monthly, keeps my data on my desk, and greets me every morning with a front page built for an audience of one.

The name is still technically a placeholder pending a trademark screen. The rivet is holding just fine.