Home — the morning command center

The first thing I see: a greeting, a count of what wants my attention, the
capture box front-and-center, a row of running totals (captured, in
triage, active plans, challenges), and two columns for what came in
recently and what’s currently in flight.

Capture — one box for everything

The full capture surface. Pick one of eight modes — idea, bookmark,
note, task, plan, document, voice recording, wiki page — write in
Markdown, tag it, and choose how hard to be challenged (Park,
Triage, or Dig). Capture never blocks: it saves first and thinks
afterwards.

Capture has enough depth to warrant its own page — modes, shortcuts,
voice, email ingestion, challenge levels. See Capturing things →.

Inbox — triaged before I get there

Station polls my mailbox, classifies each message with a locally-trained
few-shot classifier, and proposes an action — delete, decline, flag for
reply, research, or turn into a task. High-confidence calls it executes;
everything else is one click, with a "tell Station why" feedback loop
when it gets one wrong.

Meetings — commitments, captured

Meeting audio → Whisper → just the first-person commitments I made,
each waiting for a confirm/reject that trains the extractor. Transcript
corrections and a custom vocabulary teach it my jargon. (And yes — the
swear jar lives here.)

Debriefs — the evening call

Every weekday evening Station calls my phone and interviews me about
the day — in a clone of my own voice. Journal entries get written per
workspace, and the work I did but never tracked becomes tasks, created
and closed in one motion after I approve them out loud.

Follow-ups — features that have to earn their keep

Every shipped feature is registered with a test plan and checked in on at
2, 7, 14 and 30 days — grounded in real usage telemetry, drip-fed one a
day, parkable without guilt. "Shipped but never used" gets caught in
days, not months.

The whole daily pipeline has its own page: The daily rhythm →.

Ideas — the whole corpus

Every idea in one place, filterable by mode and by state (new, triaging,
challenged, researching, paused). The most interesting ones are surfaced
first.

Triage — decide what each thing becomes

The daily decision queue. For each unsorted item I choose, with a single
keypress: keep & challenge, promote to a plan, just file
it, or bin it. Reason chips (no tags, possible duplicate, high challenge-score) tell me why each one surfaced.

Idea detail — read it, see how it pushed back

One idea in full: the body, the follow-up questions and my answers, a
completeness breakdown, extracted entities, related items, and
one-click actions to research, promote to a plan, or promote to
a task.

This whole area — promoting ideas into work, plans, tasks, and the
calendar — has a dedicated walkthrough in From idea to done →.
The screens below are the quick gallery version.

Work — today, this week, and active plans

The single "what to do, in what order" command center: today’s checklist,
the next seven days, and every active plan, side by side.

Plans — every arc you’re on

Every plan on a timeline with a live progress bar, derived from its open
tasks. Easy to see at a glance what’s in flight, planning, paused, or
shipped.

Plan detail — the roadmap for one plan

A plan’s steps with their statuses and due dates, the ideas that fed it,
some quick stats (days active, velocity, risk), and a running notes &
log panel.

Tasks — grouped by horizon

Everything actionable, grouped into today, this week, and
later. These are the same rows as the plan steps — just a focused
view.

Calendar — all dated work in one place

A week/day calendar of everything with a due date or a time, so scheduled
work and focus blocks live next to each other.

Workspaces — one container per arena

Chat, journal, tasks, and local items scoped to an arena of life — a
client engagement, the homelab, publications. Each workspace gets its own
nightly journal from the debrief, its own grounded chat, and a clean
end-of-life when the engagement wraps.

Bookmarks — saved URLs, with the why

Saved links with a note on why I kept them, filterable by read/unread and
by tag.

Documents — ingested and indexed files

Uploaded files in a tidy table — type, size, kind, tags, last updated —
each one chunked and embedded so it shows up in retrieval and search.

Notes — raw observations

Plain notes, deliberately with no LLM passes. Sometimes I just want to
write something down without being interrogated about it.

Sources — the things you cite

Canonical references with an author, a generated summary, highlights, a
confidence meter, and a count of what links back to them.

Research — long-running deep dives

Kick off a research question (powered by GPT Researcher running locally),
walk away, and come back to a structured report I can pin to an idea or a
plan. Each session shows its status, findings, and sources.

Wiki — Station’s own living docs

The codebase’s architecture notes, ADRs, roadmap, and changelog — rendered
and editable in-app. Edits land on disk, get picked up by git, and
feed back into the knowledge index so the model knows how Station itself
works.

Draft Studio — write in my voice

Give it a topic and a brain-dump; Station grounds a brief in my own
writing — past posts plus the transcripts of my talks and videos — and a
claude-runner drafts the piece into a private repo, one branch per draft,
each revision a commit. Only the topic is required; everything else just
sharpens the voice and intent.

A draft, end to end

The reading view for one draft: the rendered piece, copy out as
Markdown or rich text, revise with feedback and extra material,
teach the voice a rule that binds every future draft, and — once it’s
published — reconcile the draft against the live version so the edits I
made by hand feed back in as voice signal.

Agents — autonomous work that reports back

The scheduled agents that do, not just think: a Docker image-update
monitor, a homelab Groundskeeper, a Station Backup agent, a Diagnostician &
Remediator, and more. Each shows when it last ran, what it found, and what
it actually did.

Chat — talk to the brain

A grounded conversation with everything Station knows, with web tools
when it needs them, voice in and out, and feedback on its answers. Chat
threads can live inside a workspace, so a client conversation stays
grounded in that client’s context.

Graph — how everything connects

A semantic graph linking ideas, knowledge items, memory facts, plans,
topics, entities, and homelab nodes. Solid edges are structural; dotted
edges are "these are similar in meaning." The thing I half-remember is
usually two hops from wherever I’m looking.

Inventory — a live map of the homelab

Every host, stack, service, and container in my homelab — seeded straight
from the real environment and enriched with an auto-generated synopsis for
each one. Because it’s just more nodes in the graph, I can ask "which of
my ideas relate to this service?" and get a real answer.

Search — hybrid recall across everything

One search box over the whole system. It blends keyword (BM25) and vector
similarity, highlights the matched terms, and groups results by type —
ideas, documents, inventory, memory, wiki, and more — all at once.

Memory — what it believes about me, and how sure it is

Short, structured facts about me, my projects, and my people — extracted
automatically and re-checked by a daily consolidator. Each fact has 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. The least-confident facts sort to the top, ready
for a quick human yes/no.

Topics — the recurring threads

Topics as a weighted tag cloud — bigger and brighter the more they come up
— plus a volume chart of what I’ve been thinking about over the last
several weeks.

Progress — how Station has grown

The in-app roadmap and changelog, plus the health of every
background job: next run, last run, duration, and a sparkline history. The
engine room, made visible.

Feedback — improve Station from inside Station

I file suggestions and bugs without leaving the app, tagged by area
(praise, gripe, idea, bug) and tracked through open → parked → addressed.

Recycle bin — a closed trapdoor

Everything user-created is soft-deleted for 30 days. One page to
restore or permanently purge, with a visible "expires in N days" countdown
on each item.

Background jobs — the scheduler, in the open

Every scheduled job — mailbox ingest, knowledge polling, memory
consolidation, graph rebuild, daily digest, recycle-bin purge — with its
schedule, last result, duration, and a "run now" button.

Settings — instance configuration

Identity, LLM provider (local-first, with a live connection check),
Microsoft Graph, notifications, capture defaults, and the
challenge-engine toggles (auto-challenge, devil’s advocate, parrot mode).