Station
A most bodacious second brain. Be excellent to each other.
Station is my personal "second brain" — a self-hosted web app that
catches half-thoughts, asks the right follow-up questions, remembers
what matters about me and the world I live in, and turns ideas into
plans I actually finish.
It’s named after the character Station from Bill and Ted’s Bogus Journey for a few reasons:
- The two creatures together form a superintelligent being
- Station builds robot versions of Bill & Ted, that:
- Work autonomously
- Can be controlled by them
It runs on a small box in my house and is designed to be the place
my brain offloads to, instead of leaving notes scattered across a
dozen apps that all want my data.
⚠️ Station is a showcase, not a release. The source isn’t
public (yet). If you want to know more, get in touch.
Like the graphic above? Check out the other AI generated overviews of Station, including one that’ll give you a good chuckle.
TL;DR
Station is my self-hosted second brain. I dump a half-formed thought
into one box, a local AI challenges it into something real, and the
survivors become plans I actually finish — with tasks and a calendar
attached. No cloud, no data harvesting, running on a small box in my house.
- 🧠 Capture anything — ideas, bookmarks, notes, tasks, plans, voice memos, documents — through one composer.
- 🤺 Get challenged, not just stored — a local LLM asks the sharp follow-up questions a good co-worker would.
- 🗂️ Triage → plan → do — promote the good ideas into plans whose steps flow straight into tasks and a calendar.
- 🪞 It actually remembers — structured facts about me, a corpus of what I’ve written, and a live map of my homelab.
- 🔍 Find anything — hybrid search and a semantic graph stitched across all of it.
- ✍️ Write in my voice — Draft Studio grounds a brief in my own posts and video transcripts, then drafts content that actually sounds like me.
- 🤖 Agents that do — scheduled autonomous agents that take real action: backups, diagnostics, update-watching, housekeeping.
- 📞 It runs my day — it triages my inbox, captures the commitments I make in meetings, and calls me every evening — in my own voice — to debrief the day.
- 🔌 Open to other agents — an MCP server so tools like Claude Desktop and Open WebUI can use the same brain, and a native mobile app in my pocket.
🚀 Want more than the highlights? There are deeper dives:
- 🗺️ The grand tour — every screen, what it’s for, and why it earns its place.
- ✍️ Capturing things — the eight capture modes, the shortcuts, and the challenge levels.
- 🎯 From idea to done — plans, tasks, and the calendar, all one source of truth.
- 📞 The daily rhythm — inbox triage, meeting capture, the evening debrief call, and the follow-up loop.
The three-minute version
Rather watch than read? Here’s the whole thing. (Stick around for the
part about the evening phone call — there’s a twist.)
What problem is it solving?
I have a lot of ideas. Most of them are bad. The ones that aren’t bad
usually die because I never wrote them down properly, or I wrote them
down in a place I never looked at again.
Existing tools either:
- Capture, but don’t think with you (Notes, Obsidian, plain
Markdown) — you have to do all the work of pulling threads. - Are great at one thing only (Todoist for tasks, Notion for
docs, ChatGPT for brainstorming) — none of them know what the
others know. - Want my data, badly (you know the ones) — and decide what AI
features I’m allowed to use.
Station is what happens when you build the tool you actually wanted,
on hardware you control, with a local LLM that doesn’t phone home.
The core loop: capture → challenge → plan → do
Every idea takes the same path through Station, and the app does
most of the boring bits for me.
1. Capture it before it evaporates
Type a half-thought into the box — or paste a URL, prefix with / for a
task, or pick one of eight modes (idea, bookmark, note, task, plan,
document, voice recording, wiki page). Then choose how hard I want to be
pushed: Park (don’t bug me), Triage (one sharp question), or
Dig (up to three).
There’s a lot packed into capture — modes, shortcuts, voice, email, challenge levels. The full breakdown is in Capturing things →.
2. The model challenges me
A local LLM reads the idea, pulls in related context from my memory and
past ideas, and asks the follow-up questions a good co-worker would —
"is this a real requirement, or just frustration with your current
setup?" I answer in plain text, right on the idea’s page; Station tracks
a completeness score and stops nagging once I’ve genuinely thought it
through.
3. Triage what’s still fuzzy
The Triage queue surfaces the unsorted stuff and makes me decide what each
one wants to become — keep & challenge, promote to a plan, just
file it, or bin it. It’s keyboard-driven, so a backlog clears fast.
4. Promote to a plan
When an idea is solid, one click turns it into a Plan with steps —
statuses, due dates, dependencies, and a timeline view so I can see every
arc I’m on at once.
5. Do the work
Plan steps with due dates show up in Tasks and on the Calendar
automatically — same row in the database, just a different view. The
Work page pulls today, this week, and active plans into a single
command center. There’s no second to-do app to keep in sync.
Promoting ideas, attaching and detaching tasks, the timeline, the calendar — the whole back half has its own guide: From idea to done →.
It runs my day
The newest big shift: Station stopped being a place I go and started
being something that shows up. Over the last few months it has quietly
taken over the daily rhythm:
- 📥 Inbox triage — it watches my mailbox, classifies what lands with
a locally-trained few-shot classifier, and handles each category the way
I’ve taught it to. The newsletter noise dies before I see it; the things
that need me become tasks. - 🎙️ Meeting capture — meeting audio goes through Whisper, and Station
extracts only the commitments I actually made — "I’ll send you
that report" — for a quick confirm/reject that also trains it. (There’s
also a swear jar. I’m not proud. It has tallies.) - 📞 The evening debrief — on weekday evenings my phone rings with a
full-screen call from Station, speaking in my own cloned voice. It
interviews me about the day, writes the journal, and captures the tasks
I did but never tracked — after I approve them out loud. - 🔁 The follow-up loop — every shipped feature gets registered with a
test plan and checked in on at 2, 7, 14, and 30 days, grounded in real
usage telemetry. Nothing I build gets to quietly rot unused — including
the features of Station itself.
The whole daily pipeline — inbox, meetings, the debrief call, journals,
and the follow-up loop — has its own page: The daily rhythm →.
Write in my voice — Draft Studio
Draft Studio turns Station into a ghost-writer that actually sounds
like me.
I give it a topic and a brain-dump of links and half-thoughts. Station
grounds a brief in my own writing — past blog posts, plus the
transcripts of my own talks and videos — and a
claude-runner drafts the piece in my
voice, into a private station-drafts repo where every revision is a
commit on its own branch.
What makes it more than "ask an AI to write a blog post":
- It’s grounded in me, not the internet — the brief is built from my
actual posts and video transcripts, so the structure, vocabulary and
opinions are mine. A humanizer pass strips the generic-AI tells, but my
own voice always wins where they conflict. - Teach the voice — when a draft gets something wrong, I record a rule
("I use The Problem / The Challenge / The Solution as headings") and it
becomes a hard constraint on every future draft, not just this one. - Revise, don’t restart — feedback and extra material refine the same
piece; the history of every generation and revision is kept. - Copy out clean — one click for Markdown (→ WordPress) or rich text
(→ Word). - Reconcile with reality — once I publish, I link the live URL; when
Station next ingests it, it diffs the draft against what I actually
published. The edits I made by hand are the strongest possible signal of
my real voice, fed straight back in.
Agents that do the work
The roadmap used to list "agents that do, not just think" as a someday.
It’s here now. Station runs a set of scheduled autonomous agents that
take real action and report back — a Docker image-update monitor, a
homelab Groundskeeper that keeps things tidy, a Station Backup
agent, a Diagnostician & Remediator, and more. Each one shows when it
last ran, what it found, and what it did.
What else is inside
Station has grown well beyond the core loop. Here’s the rest, grouped —
expand any section for the highlights, or jump to
the full tour for every screen.
🧠 Capture & think — ideas, triage, topics
- Ideas — browse the whole corpus, filtered by mode and state (new, triaging, challenged, researching, paused).
- Idea detail — the reading view: follow-ups, a completeness breakdown, extracted entities, related items, and one-click research / promote to plan / promote to task.
- Topics — lightweight threads I pin across ideas; the model also uses them as a retrieval signal, and a volume chart shows what I’ve been chewing on lately.
✅ Plan & do — work, plans, tasks, calendar
- Work — today’s tasks, this week, and active plans in one place.
- Plans — every plan on a timeline, each with a live progress bar.
- Plan detail — the roadmap of steps, related ideas, stats, and a running log.
- Tasks — standalone or attached to a plan, grouped by horizon (today / this week / later), and freely moved between plans.
- Calendar — a week/day view of all dated work.
🗂️ Workspaces — a container per arena
Chat, journals, tasks, and local items scoped to an arena of life —
one workspace per client engagement, one for the homelab, one for
publications. Each has its own journal (written nightly by the debrief),
its own chat grounded in its own context, and a clean end-of-life when the
engagement wraps.
💬 Chat — talk to the brain
A grounded conversation with everything Station knows — my ideas, memory,
knowledge, and homelab — with real web tools when it needs them, voice
in and out, and a feedback loop on its answers. Chat threads can live
inside a workspace, so a client conversation stays grounded in that
client’s context.
📚 Knowledge — bookmarks, documents, notes, sources, research, wiki
- Bookmarks — saved URLs with a note on why I kept them.
- Documents — uploaded files, chunked and indexed for retrieval.
- Notes — raw observations, deliberately with no LLM passes.
- Sources — the canonical things I cite, with a confidence meter and what links to them.
- My own voice — my talks and YouTube videos are transcribed off-box and ingested as a first-class source (paste a URL and Station does the rest), building a living corpus of how I actually write and speak. It feeds search — and it’s the raw material Draft Studio writes from.
- Research — long-running deep-dive jobs (via GPT Researcher) I can kick off and come back to.
- Wiki — Station’s own living docs, editable in-app and fed back into the knowledge index.
🕸️ Browse & connect — graph, inventory, search
- Graph — a semantic map linking ideas, knowledge, memory facts, plans, topics, entities, and homelab nodes. The thing I half-remember is usually two hops away.
- Inventory — a live picture of my homelab: every host, stack, service, and container, each with an auto-generated synopsis, seeded straight from the real environment.
- Search — hybrid recall (keyword + vector) across everything at once, with matches highlighted and grouped by type.
🪞 What Station knows about me — memory, progress
- Memory — short, structured facts about me, my projects, and my people, extracted automatically and re-checked by a daily consolidator. Every fact carries a confidence and a temporal validity — it can be forgotten or superseded without being deleted, so there’s a real history of what Station once believed, not just what it believes now. Low-confidence facts sort to the top for a quick human yes/no.
- Progress — the in-app roadmap, changelog, and the health of every background job, so I can see how Station has grown over time.
🧹 Housekeeping — feedback, recycle bin, jobs, settings
- Feedback — I suggest improvements to Station inside Station, tagged by area with an open / parked / addressed status.
- Recycle bin — everything user-created is soft-deleted for 30 days; restore or purge from one page. The "I just deleted the thing I needed" trapdoor is closed.
- Background jobs — every scheduled job (mailbox ingest, memory consolidation, graph rebuild, daily digest…) with its last run, duration, and a health sparkline.
- Settings — instance config: identity, LLM provider, Microsoft Graph, notifications, and the challenge-engine toggles.
The screenshots above are only a taste. The grand tour → has all of it, screen by screen.
Use it from your other tools
Station exposes an MCP server
(Model Context Protocol) over both
transports the spec defines (SSE and Streamable HTTP), so other clients —
Claude Desktop, Open WebUI, LibreChat — can also search my ideas, look
up memory facts, query my homelab inventory, and (with a write token)
leave research findings.
Station isn’t a chat box bolted onto a database. It’s a knowledge
surface any agent can use — and increasingly, a memory any agent can
write back to.
And it’s in my pocket: a native mobile app (Kotlin + Jetpack Compose)
with its own screens for today’s work, triage, inbox, capture (including
voice), search, a daily top-3 focus picker, and a grounded chat with my
own brain. Push notifications deep-link straight back into the thing that
needs me — and the evening debrief arrives as a full-screen incoming call.
Deliberately LAN/VPN-only: no cloud push relay, because the whole
point is that my data doesn’t leave the house.
Roadmap — what’s next
Station is built in phases, and the live roadmap and changelog live inside
the app on the Progress page. The foundation — capture, challenge,
knowledge graph, research, planning, MCP — shipped long ago, and the last
round of "what’s next" items (Draft Studio, autonomous agents, the voice
corpus, the mobile app, auto-categorisation, MCP as a generic memory
server) are all live now too. So is the daily rhythm: inbox triage,
meeting capture, the debrief call, and the follow-up loop. What I’m
reaching for next:
- 🌙 Overnight thinking — a separate, sandboxed agent that reads Station’s brain while I sleep and greets me with genuinely useful syntheses and suggestions (suggest-only; it can look, not touch).
- 🧑🤝🧑 Delegation — hand plan steps to non-human assignees and let them run.
- 🔬 Deeper research — long-running, evaluative research agents triggered straight from triage.
- 🕸️ A real graph database — a Neo4j backend for richer traversal of the knowledge graph.
Status
Station is in very active development, running daily on my own
hardware. The roadmap and changelog live inside the app (on the
Progress page) and drive everything above.
Why I built it
I wanted a tool that:
- Knows me without any company owning that knowledge.
- Asks me good questions instead of waiting passively.
- Doesn’t fragment what I think across a dozen apps.
- Plays well with other agents instead of being a walled garden.
- Runs on my own hardware with a local LLM.
If that resonates with you, hi 👋 — get in touch and let’s talk.
🔧 Under the hood (for the curious — this is a functionality showcase, so the tech lives down here)
Is it RAG? Sort of, but that’s not what it is. Station has the
RAG-shaped pieces (vector store, embeddings on capture, retrieval grounded
in real entities) — but the source of truth is a structured Postgres
schema, the memory subsystem has a temporal validity nobody calls "RAG",
and the LLM is a participant in a workflow (asking questions, proposing
plans, extracting facts) rather than a chatbot answering one-shot queries
over a corpus. RAG is a feature of Station, not its identity.
The stack:
- Backend: Python 3.12, FastAPI, SQLAlchemy 2.x async, APScheduler
- Storage: PostgreSQL (source of truth) + Qdrant (vectors)
- Frontend: server-rendered Jinja + HTMX + Tailwind — no SPA, no build step, no JavaScript framework
- LLM: local-first via LocalAI
- Speech: Whisper for transcription (meetings, voice capture); a locally-hosted clone of my own voice for the debrief call
- Research: GPT Researcher over MCP, locally
- Voice corpus: off-box video/talk transcription, ingested as JSON and chunk-embedded
- Content generation: Draft Studio via a claude-runner, grounded in my own writing
- Inventory: pulled from the real homelab and enriched with generated synopses
- Agent surface: MCP server (SSE + Streamable HTTP), bearer + per-write-token auth
- Mobile: a native Kotlin + Jetpack Compose app over a versioned JSON API with device pairing + LAN-only push
- Deployment: Docker Compose on a single home server
One codebase, one app, one database. No microservices.