Discord channels as project lanes
The interface is now a private Discord server with Alfred as the only bot. It started out on Telegram topics, and the idea is the same: instead of one endless chat where vendor emails, iOS bugs, work ideas, and travel plans all smear together, Alfred gets separate lanes with separate session context. Discord just has more of that structure built in.
Channels are lanes, threads are tasks. Each recurring area of life gets a channel. With Hermes’s auto_thread on, every new top-level message in a channel opens its own thread, and each thread is its own session. Hermes renames the thread from the conversation after the first exchange, so the channel turns into a tidy index of past tasks instead of one long scroll. Channels that should be a single running conversation, like #general or a status feed, go in no_thread_channels.
Categories are privacy boundaries. The server has three: one only I can see, one shared with my wife, and one that is hers alone. Discord permissions decide who reads what, so a shared trip-planning lane and my private finance lane can sit side by side without leaking into each other. She talks to the same Alfred, with the same brain, in her own space.
Every channel carries its own instructions. Two config blocks do the heavy lifting. channel_skill_bindings auto-loads skills in a channel, and channel_prompts gives it a standing brief: which wiki page is canonical, what Alfred may do without asking, and lane-specific rules. Threads inherit both from their parent channel. My favourite rule lives in the shared holiday channel: both of us read it, so gift ideas for either of us never go there.
discord:
require_mention: false # no @ needed, it's my server
auto_thread: true # new message = new thread = new session
thread_require_mention: false
history_backfill: true # read recent scrollback when woken
no_thread_channels: <general>,<status channels>
channel_skill_bindings:
- id: <#finance>
skills: [personal-finance-workflows]
- id: <#hermes-ops>
skills: [hermes-agent]
channel_prompts:
<#cooking>: "Private cooking lane. Grams by default.
Saved recipes live in wiki/recipes/ ..."
Forum channels are the other unlock. For a search with lots of options (apartments, venues, products), each option gets its own post with tags, Alfred can open new posts itself, and a pinned strategy post holds the big picture. Cron jobs can deliver straight into a specific post, so a watcher for one option reports in that option’s thread.
Why this matters: I am extremely jumpy in what I talk about. Lanes let Alfred keep context tight without losing the shared brain. A vendor email should not pollute an iOS debugging session. Astonishingly, computers work better when we stop treating them like soup.
Auto-created threads archive after 24 hours idle, and that is hard-coded. Replying in an archived thread revives it with its full history. Config changes need a gateway restart. If you ever add a second bot, turn on thread_require_mention or they will both answer everything.
GBrain is the real memory
The biggest architecture change since the original guide: Alfred’s long-term memory is now GBrain, my wiki-backed markdown brain. Hermes still has memory, but the canonical project state lives in files I can read, edit, commit, sync, and hand to other agents.
This replaced the old MEMORY.md-plus-QMD mental model. The GBrain pages are the source of truth: project briefs, travel notes, financial models, household plans, Cubby decisions, research pages, and the connective tissue between them.
Under the hood, GBrain gives me the things I liked about QMD without making QMD a separate guide section: keyword search, semantic/vector search, hybrid retrieval, reranking, graph traversal, embeddings/backfill, sync, watch, and import pipelines. The important part is simpler: the wiki is the memory; the indexes are derived from it.
- —Markdown as source of truth — durable, reviewable, portable files instead of invisible model memory.
- —Channel-bound skills — each Discord lane loads the skill that points Alfred to the right GBrain page.
- —Manual review — I can inspect what Alfred wrote, fix it, and commit the wiki separately.
- —Multi-agent access — Alfred, Codex, and other agents can all read the same project brain.
If you want an agent to remember something, write it somewhere boring and inspectable. Memory that only exists as vibes inside a chatbot is not memory. It is decorative fog.
LCM-X: never fully forget
Long-running agent conversations create a nasty problem: eventually the context window fills up. Traditional compaction squashes the conversation into a summary and detail evaporates. You keep “discussed DJ options” and lose the actual decision.
Alfred uses LCM-X, a Hermes plugin for Lossless Context Management. It builds a DAG of raw messages and summaries, so the model can see a compact view while the original detail remains recoverable underneath.
When detail is needed, Alfred can call tools like lcm_expand or lcm_expand_query to drill back into the source messages. Compaction becomes a two-way door: compress for working memory, expand when precision matters.
plugin: hermes-lcm-x
version: 0.28.0
preset: codex_gpt_long_context (8K leaves)
context threshold: 75%
summaries: GPT-6 Luna, Sol as fallback
raw messages: preserved in lcm.db
If you install one plugin, make it this one. Long-lived lanes are the whole point of this setup, and without LCM-X they eventually forget their own history.
How to think about it: GBrain is durable long-term project memory. LCM is session continuity. One remembers what matters across months; the other keeps a live conversation from getting lobotomized when it gets long.
Heartbeat + cron: the night shift
The primary productivity layer is now a heartbeat, a newer Hermes feature. Think of it as a cron job that keeps one consistent session: every hour it wakes up inside the same session, with the same history, instead of starting from zero each run. It remembers what it already told me, what I said back, and what is still open.
Mine lives in #general, which works as the front desk, and that is the core idea of the whole setup: #general is the triage desk. It sees everything coming in, decides what matters, and hands each item to the channel that owns it (#finance, #travel, #career) using the walkie-talkie below. The specialist lanes do the deep work; the front desk keeps the queue moving. The checklist it follows is a plain markdown file it rereads every run, with a section at the top where it logs my pushback (“stop pinging me about X”) so the same mistake does not come back.
Point your heartbeat at the surfaces that run your day: check new email, check every calendar, look at what is coming up, and suggest the next useful move. Most runs should end in silence. The good ones stage the work, like a drafted reply or a reminder, so I only have to say yes. Write your own checklist; the value is in teaching it what matters to you.
Around that, I still use explicit cron jobs: small scheduled agents or scripts that check one specific surface, usually stay quiet, and only notify me when something is worth my attention.
Some jobs are LLM-driven. Some are deterministic script watchers with no agent at all. They can deliver into a specific Discord channel or forum post, save locally, or notify only on meaningful changes. Ops jobs report to #hermes-ops, finance watchers to #finance, health check-ins to #health, so each report lands next to the context that can act on it.
- —Travel sentinel — check-ins, packing lists, trip readiness, and day-of reminders.
- —Open Loop Radar — reviews recent sessions every few days for unresolved threads and implicit commitments.
- —GBrain/wiki ops — bookmark ingestion, weekly maintenance, nightly wiki commit/push, and update watching.
- —Follow-up/accountability — iMessage follow-up triage and other small social loose ends.
- —Creative serendipity — random musings and occasional wiki artifacts, because not every useful thing has to look like a Jira ticket.
- —Watchers and one-shots — Hermes issue watchers, ticket drops, reservation windows, account-fee windows, and reminders.
Rule of thumb: use the heartbeat for judgment across your whole day, where continuity matters. Use cron for narrow, well-defined checks with their own schedule and delivery target.
Walkie-talkie: lanes that talk to each other
This is what makes the front desk triage model work. Lanes keep context clean, but work usually arrives in one lane and belongs in another. A bank alert shows up in the #general heartbeat; it should be handled in #finance. A coordinator thread decides a build needs checking; that belongs in the app’s channel.
So I built walkie-talkie, a Hermes plugin that lets one session message another existing session. The target channel wakes up with its full history, handles the message as a normal turn, and replies in its own chat. You see two messages back to back: a 📻 Sent from … line with the request, then the target’s answer.
- —Email routing — the heartbeat forwards money stuff to #finance, trips to #travel, recruiters to #career, and keeps the rest.
- —Handoffs — “tell #wiki to file this” from anywhere, including cron jobs.
- —Fire-and-forget — the sender does not wait. If you reply in the target channel, the conversation stays there.
- —Guardrails — off until you opt in, visible label on every handoff, one hop only so lanes cannot loop.
Why it matters: it turns a pile of separate chats into a team. Each lane keeps its own memory, and work still finds its way to the right one.
Skills: reusable protocols
Whenever I want Alfred to follow a specific protocol — like how to plan a blind restaurant date, triage a consulting request, or manage a project lane — I put that protocol in a skill. It is a markdown document that loads when the context is relevant.
Skills are how Alfred improves without retraining. If a workflow changes, I update the skill file. Every future session gets the new procedure.
The current setup also uses skills as routing glue. A Discord channel can load a skill; that skill tells Alfred which GBrain page to treat as canonical for that lane. The channel provides conversational isolation, the skill provides procedure, and GBrain provides durable state.
I still use skills.sh because portability matters. The same skills can be available to Alfred, Codex, Claude Code, and IDE agents. One procedure library, many workers.
Use skills for things you repeat, things you correct often, and things that require judgment. If you have to explain a workflow twice, it probably wants to become a skill.
Coding: two modes
There are two ways Alfred writes code, and knowing which one to use is a major quality-of-life improvement.
Mode 1: direct coding. Alfred reads files, edits, runs commands, checks results, and deploys inline from chat. This is perfect for small pages, scripts, config fixes, quick repo edits, and anything I can describe in a sentence or two.
Mode 2: the Codex app. For larger builds, I remote into the Mac mini and use Codex directly. It gets the deep IDE-like work: substantial app features, bigger refactors, and long coding sessions that should not block my main Alfred chat.
Skills still bridge the two worlds. Alfred and Codex can share the same playbooks, taste, and project conventions. The handoff is less “new assistant, who dis?” and more “same workshop, bigger bench.”
Documents and tracking
Two patterns come up constantly. For documents, draft in markdown or the wiki first, then export or move to Google Docs when something needs to be shared. For tracking, use a spreadsheet when the data actually wants rows, dates, owners, and formulas.
Hermes has Google Workspace access, and Alfred uses the gws CLI for Gmail, Calendar, Drive, Docs, and Sheets. Vendor comparisons, household budgets, pricing research, calendar lookups, email scans — all the boring office plumbing becomes agent-reachable.
GitHub + Vercel: ship instantly
One of the most useful patterns is giving Alfred a fast path from idea to URL. GitHub plus Vercel means a small page, prototype, guide, tracker, or interactive toy can become a shareable link in minutes.
“Build me a page comparing these venues” becomes a URL I can send to my wife. “Make a quick guide for this setup” becomes a real page instead of a lost chat transcript. Everything lives as subdirectories in one repo: clean URLs, fast deploys, low ceremony.
Tools and integrations
The real power of an always-on agent comes from what it can reach. The exact list changes, but these are the integrations that matter most in my current setup:
- —Google Workspace via
gws— Gmail, Calendar, Drive, Docs, and Sheets. - —GBrain/wiki tools — durable project memory, research pages, and syncable state.
- —iMessage follow-up scan — find loose conversational threads and draft the next nudge.
- —Printing Press CLIs — custom domain tools for annoying workflows: Fandango, Monarch Money, Splitwise, and table reservations across OpenTable, Tock, and Resy.
- —1Password
Clawvault — credential handoff without pasting secrets into chat. - —Gemini Maps grounding — even with effectively unlimited OpenAI tokens, Gemini’s place data is unmatched. For restaurant recommendations or place advice, Alfred diverts to Gemini.
Credential management: Alfred has access to a dedicated 1Password vault called Claw. If a workflow needs credentials, I share them there and Alfred reads them with the op CLI where possible. Much better than dropping passwords into chat like a Victorian sending bank details by postcard.
Image generation through OpenAI
The old setup used a separate Gemini/Nano Banana path. I do not bother with that anymore. Image generation now goes through GPT/OpenAI inside Hermes using the existing OAuth-backed plan.
The practical effect is simple: Alfred can generate illustrations, quick assets, page art, and visual drafts without another API key or side setup. It is part of the same agent workflow instead of a separate toy bolted to the side.
Maintenance: let Alfred watch the stack
I do not want to manually track every moving part in the stack. Alfred watches the parts that matter: Hermes issues I am waiting on, targeted bugs, GBrain/wiki health, scheduled maintenance, and update checks that are actually relevant to my setup.
The point is not “auto-update everything blindly.” It is that the agent can keep an eye on its own operating environment and tell me when something is worth attention.
The personality upgrade
Hermes reads a SOUL.md file that shapes how your agent talks and what it cares about. Early on, I asked Alfred to rewrite its own: British, dry, sharp, warm underneath. Yes, I gave my AI agent a butler accent. Yes, I know. That is the bit, and the bit works: it makes every exchange a little more fun, which means I actually use it.
Mine has changed several times since as I figured out what I actually wanted from Alfred, and each version made it more useful. The voice is the fun part; the real payload is the working style: how blunt it is, when it pushes back, when it just does the thing.
Find the voice that makes you want to text it, and the working style that makes you more productive. This matters more than you would think. The default AI assistant voice is polished but generic. A well-crafted personality makes every interaction feel less like using a tool and more like talking to someone. You text it more, trust it more, and actually enjoy the interactions.
The trick: Do not write the personality file yourself. Describe the vibe you want and let the AI write it. It will capture nuances you would not think to specify, and it will follow instructions it wrote for itself more naturally.
Just use the best model
Alfred currently runs on Claude Opus through my Claude subscription, using a Hermes provider plugin that drives the Claude Agent SDK. No API keys, no per-token bill. The exact best model will change; the principle will not.
It is not one model for everything. The main chat, cron jobs and channel lanes run on Opus. Context compression (the LCM summaries) runs on GPT-6 Luna with GPT-6 Sol as fallback, through my OpenAI/Codex subscription. Summaries are a high-volume, background job, so they go to a strong model on a plan I am already paying for instead of eating into Opus.
Switching is cheap. When a lane misbehaves on one model, I flip that lane to the other for a day and keep going. Two flat-rate subscriptions beat one metered API.
Do not over-optimize away quality. The difference between the smartest available model and a cheaper “good enough” model compounds across thousands of small autonomous decisions: every email triage, cron judgment, code edit, memory update, route recommendation, and social draft.
I treat this like paying for a sharp operator. If the agent is going to touch real parts of my life, I would rather it be slightly overpowered than constantly almost right.
Hot take: Token thrift is often fake savings. The time you spend debugging cheap-model mistakes can cost more than just using the model that gets it right.
Remote access: Tailscale is non-negotiable
An always-on agent lives on a box you are not sitting in front of. Tailscale puts the Mac mini on a private network with my phone and laptop, so I can reach it from anywhere without opening ports to the internet. I use it constantly: SSH, screen sharing, local dashboards, and reaching services that only listen on the home machine.
For actual fixes on the go, Codex mobile connected to the Mac mini rides on top of that. If something breaks while I am away, I open Codex, remote into the box, and patch it without doing terminal origami on a phone.
Voice transcription: local and free
I send Alfred a lot of voice notes from my phone. Hermes transcribes them locally on the Mac mini using faster-whisper. The current config uses the local provider with the large-v3 model, so there is no separate transcription bill and no network round trip for normal voice input.
Parakeet MLX is still installed on the machine from an older experiment, but it is not the active path anymore. The boring built-in Hermes local STT path won, which is frankly rude but convenient.
stt:
enabled: true
provider: local
local:
model: large-v3
language: ''
The stack
Putting it all together:
- —Mac mini as the always-on home base.
- —Hermes Agent for the runtime, gateway, tools, and scheduled work.
- —Private Discord server as the personal UI: channels for lanes, threads for tasks, categories for privacy.
- —Claude Opus via Claude subscription as the main model, with GPT-6 Luna/Sol via Codex OAuth for context summaries.
- —GBrain/wiki as canonical long-term memory and project state.
- —LCM-X for session continuity and lossless context.
- —Skills + skills.sh for reusable procedures across agents.
- —Heartbeat as the hourly productivity layer, plus cron jobs for narrow checks, watchers, and reminders.
- —Walkie-talkie so lanes can hand work to each other.
- —Google Workspace +
gwsfor email, calendar, docs, and sheets. - —1Password
Clawvault for credential handoff. - —GitHub + Vercel for the fast coding and deploy loop.
- —Tailscale for private remote access to the Mac mini.
- —Codex app/mobile for larger builds and remote rescue.
- —Gemini Maps grounding for restaurants and place intelligence.
- —Printing Press CLIs for custom tools like Fandango, Monarch, Splitwise, and reservations.