The Daily Loop: Where the Second Brain Earns Its Keep

At 6:30 most mornings, a Mac Mini in the corner of my office starts reading. Yesterday's meeting transcripts. The email threads I flagged. The half-formed thought I texted my chief of staff at 9pm. By the time I pick up my phone, all of it has been distilled, filed, and cross-linked, and a brief is waiting on Telegram.

A few weeks ago I wrote about the memory layer underneath all this: a folder of markdown files that acts as the shared memory for every agent I run (start there if you haven't). This post is the operating loop that runs on top, because I learned the hard way that a memory nobody feeds and nobody queries is a very organized junk drawer.

Here's a full day, beat by beat.

Before I'm up: the ingest

3 routines fire before I'm awake. Meeting transcripts get distilled into clean notes of what everyone else said; anything I said worth keeping gets pulled out word for word into separate notes. Distill others, verbatim me (I covered why in the last post). Then the email threads I've labeled in Gmail, then the voice memos and texts I sent Howard the day before.

Every note wires into an entity graph: a page per person, company, deal, and concept. The page structure is the part I'd defend in a fight. Facts are append-only, each linked back to the meeting it came from, so I can audit any claim the system makes about someone. The "working context" section is replaceable and hard-capped at 5 bullets. The cap forces the routine to decide what still matters, which is most of the job.

The morning brief and the 4 buttons

Before I'm up (I'll keep the exact time to myself, it's embarrassing either way), Howard sends the brief to my phone. Calendar, follow-ups, and the part that actually changed my behavior: triage cards.

Every action item any routine surfaces goes into one ledger, a markdown table: ID, date added, item, status. That's the entire data model. The brief renders every open row as a card with 4 buttons:

1. Done. I already handled it. The row closes.
2. Task. One tap sends it to my task manager with the context attached.
3. Ignore. The row is dead. It never comes back and never gets re-added.
4. Howard. He executes the item himself and reports back.

A row I don't answer comes back tomorrow, a day older and higher up the list.

The forced disposition is the whole design. My earlier version had routines flagging things into whatever note they were working on, and the flags rotted. I skimmed past the same "follow up with the lender" line for 3 weeks. Flagging twice isn't progress.

3 rules fixed it. One ledger, so there's exactly one place an open item can live. Dedup on append, so a routine checks the existing rows before adding one (ignored rows included). And visible aging, so row 014 sitting at 9 days old nags me in a way a buried note never did.

I thumb through the cards while the coffee's still hot. Most days that's my entire admin workload.

Mid-day: recall on demand

Last week I blanked on a name mid-call. Someone I'd talked to months ago, gone. I texted Howard under the table and had the name back, with the context of our last conversation attached, before I had to admit anything out loud.

That save comes from a 2-path memory design worth stealing.

The hot path is a single file, about 500 words, that every agent reads first: who I am, current priorities, live threads, recent decisions. A daily pass keeps it fresh.

The cold path is a local search index over the entire vault, keyword search stacked with vector search, running fully offline on the same Mac Mini. When I ask "who was the SBA lender Chris mentioned, and what was the holdup," the index finds the meeting semantically, wikilinks pull in the person's page, and the answer's back in seconds.

Why 2 paths: everything in the hot file and it'd be 40 pages nobody reads; everything behind a search and agents start every session ignorant.

While I sleep: the patrol

Nights and weekends, the maintenance stack runs. Each layer reads the layer below it, never the raw chatter.

1. Monday, a weekly review reads the 7 dailies; the 1st of the month, a monthly review reads the 4 weeklies and never touches the raw dailies.
2. Sunday, a connection patrol adds the links the week's notes should have had: a book note that quietly backs a product decision, a person who shows up in both a meeting and a deal.
3. The 15th, a recall probe asks a cold agent 10 questions about me, answerable only from the vault, and grades the misses. That turns "is my second brain any good" into a number I can watch move.

The promotion rule under all of it: nothing moves up a layer until it has appeared twice. One weird Tuesday shouldn't rewrite what the system believes about me.

And the component I trust most is the dumbest one. A deterministic Python script (no LLM anywhere in it) checks every routine's heartbeat each morning and messages me only when something's overdue, plus one "all green" per week so silence is never ambiguous. Agents watching agents sounds clever until you ask who watches the last agent; that answer should be something too boring to fail.

The starter loop you can set up today

The full build is around 15 scheduled routines as of this writing. The starter version is 3 files and 1 prompt, plus any agent that can read files and message you (a scheduled Claude Code task works; so does a cron job wired to a Telegram bot).

File 1: a daily note. One per day, named by date (2026-07-15.md):

# 2026-07-15

## Focus
-

## Notes
-

## Open loops
-

## Breadcrumbs
-

Anything you'd otherwise carry around in your head goes under Open loops. Breadcrumbs is where you (or your tools) drop one-liners about what actually happened today.

File 2: a triage ledger, saved as TRIAGE.md. One table, forever:

# Triage

| ID  | Added      | Item                                     | Status |
| --- | ---------- | ---------------------------------------- | ------ |
| 001 | 2026-07-12 | Reply to the lender about the rate lock  | OPEN   |
| 002 | 2026-07-14 | Renew the registered agent, due 8/1      | OPEN   |

File 3 is the prompt, scheduled for whenever you want the brief:

Read TRIAGE.md and the last 2 daily notes.

1. Any line under "Open loops" that has no triage row: add a row for it
   (next ID, today's date, status OPEN). Check existing rows first,
   including closed and ignored ones. Never add a duplicate.
2. Send me a morning brief listing every OPEN row, oldest first,
   with its age in days.
3. For each row, ask me to reply with one word: done, task, ignore,
   or handle.
   - done: set the row's status to CLOSED with today's date.
   - task: add it to my task list, then close the row.
   - ignore: set status to IGNORED. Never surface or re-add it.
   - handle: do the item yourself if you can, then report back.
4. Anything left OPEN comes back tomorrow, one day older.

Plain-word replies work fine to start; the buttons, the entity graph, and the Mac Mini in the corner can all come later. Run it for 2 weeks and I suspect you'll find what I did: the value is the forced decision. Every open loop gets exactly one home, a visible age, and a disposition it can't wriggle out of.

Follow-up is the product

The memory layer was chapter 1. But a memory only compounds if something feeds it every morning, queries it mid-call, and patrols it while you sleep. That's the loop's whole job, and the parts are ordinary: a table, a schedule, and an agent that never gets bored of checking.

I left corporate to buy my time back, and the time leaked out in small pieces: follow-ups I dropped, names I blanked on, open loops I kept re-remembering at 11pm. The loop plugs the leaks.

(If you'd rather compress this build into a weekend: I'm running a small hands-on retreat in South Lake Tahoe, August 28 to 30, 8 seats. Each person builds their own version of this, the ingest, the brief, the triage cards, on a Mac Mini they carry home Sunday. Details at joshuathacker.com/retreat. And if solo is more your speed, the starter above is honestly where mine began.)