Why

Every creator's library has the same bottleneck: ideas arrive faster than they get written. You read something worth a memo, you have thirty seconds, and a blank memo is friction — so the idea sits as a title and a link, and nothing more.

The Memo Drafting Loop closes that gap. You capture the idea as a thin stub — a title, maybe a link or a line of notes — and tag it. An hour later your agent has drafted it: researched, structured through the right template, written in your voice, sitting clean in your library. The thinking stays yours; the blank-page labor goes to the loop.

How It Works

The loop has three moving parts: a stub, a runbook, and a trigger.

A stub is a near-empty memo. Its title names the subject; its body holds whatever seed material you have — a URL, raw notes, a framing line, any per-memo steering you want the draft to follow. In its Notes # Tags field you add one marker tag — a tag like #person-memo-for-drafting-by-<yourbot> that names the template the loop should draft it through. The marker is verbose by design: it autocompletes from your tag library and tells you exactly what it does just by reading.

The runbook is a single memo in your library, built from the shared Loop Memo Template, that spells out step by step what one pass of the loop does. It is the loop's entire logic — and it also serves as your tag dictionary: every marker tag is permanently parked on the runbook in link syntax, which keeps the markers in MythOS's library for autocomplete even when no stub currently carries them. The trigger only points back at this memo, so you refine the loop by editing the memo — change a step, change the cheat sheet, and the next pass behaves differently. There is no code to touch.

The trigger is the /loop command running in a Claude Code session. Every interval it runs one pass: it scans for marker tags, finds the stubs carrying them (excluding the runbook itself, which carries every marker as a dictionary entry), drafts each through its named template, and removes the marker. The finished draft lands clean in your library with its real identity tags. Nothing is published without you — the body content is yours to review whenever.

What You Need

• A MythOS account with MCP access — the loop reads and writes your library through the 📝MythOS MCP server. Your API key is in MythOS at Settings → Developer.
• Claude Code — the loop runs as an interactive Claude Code session on your computer.
• The Loop Memo Template — the shared template your runbook is built from. You add it to your library in Step 1.

Setup

1. Add the Loop Memo Template

Open the Loop Memo Template and add it to your library. Your agent needs it to build your runbook.

2. Run the setup prompt

Open a new Claude Code session with the MythOS MCP connected, and paste the prompt below in full. It confirms your prerequisites, derives your bot identity for the marker tags, builds your runbook memo (which also serves as your tag dictionary), and installs the slash command.

Set up my Memo Drafting Loop in MythOS. This is a recurring /loop that finds the stub memos I have tagged with a marker tag, drafts each one through its template in my voice, and removes the marker once the draft is done. Work through the steps in order. Pause at Step 2.
STEP 1 — CONFIRM PREREQUISITES
- Call the MythOS `get_context` tool. If it errors, stop and tell me the MythOS MCP server isn't connected — I need to set that up first.
- Call `list_templates` and confirm a template named "Loop Memo Template" is in my library. If missing, stop and tell me to add it via the share link in the instruction memo this prompt came from.
STEP 2 — DERIVE MY BOT IDENTITY (pause here for my confirmation)
- This loop uses one marker tag per stub, in the pattern `#<template>-memo-for-drafting-by-<mybot>` where `<mybot>` is my AI-self identity. For reference, Brian Swichkow's augmentation memos establish "BrianBot," so his markers use `-by-brianbot` (e.g. `#person-memo-for-drafting-by-brianbot`).
- From `get_context`, find my AI-self identity — the name my augmentation memos give the agentic "me." If my memos establish one, propose its lowercased single-word form (e.g. `janebot`). If they don't, propose `bot` as a sensible default.
- Show me the proposal alongside the Brian example, ask me to confirm or override. Wait for my reply. Use the confirmed identity below as {{MYBOT}}.
STEP 3 — CREATE MY LOOP MEMO (runbook + tag dictionary)
- Call `read_template` for "Loop Memo Template".
- Create a memo in my library: title "Memo Drafting Loop"; templateId set to the Loop Memo Template's id; visibility `private` (pass it explicitly to override the template's public visibility).
- The body is the RUNBOOK block at the end of this prompt. Substitute every {{MYBOT}} with my confirmed identity. Leave the placeholder {{MEMO-ID}} in the Step 1 exclude line for now.
- Populate seoTitle and seoDescription. In the Notes, add a `# Notes` line recording that this loop was set up from the shared instruction memo, and a `# Tags` line with `#loop`.
- Run the Loop Memo Template's pre-submit checklist before saving.
- After the memo is created, note its id. Call `update_memo` once more to replace {{MEMO-ID}} in the body with that id — the runbook needs to know its own id so Step 1 can exclude it from the queue.
STEP 4 — INSTALL THE SLASH COMMAND
- Create the file `~/.claude/commands/memo-drafting-loop.md`. Its exact content is the FILE block below — replace {{MY-USERNAME}} with my MythOS username and {{MEMO-ID}} with the loop memo's id from Step 3.
FILE — ~/.claude/commands/memo-drafting-loop.md
---
description: Run one pass of my Memo Drafting Loop
---
Read the loop memo at /me/{{MY-USERNAME}}/{{MEMO-ID}} with the mythos read_memo tool, then follow its runbook exactly for one full pass. The memo is the single source of truth — re-read it every pass. End with the close-out receipt the runbook specifies. If the queue is empty, say so in one line and stop.
FILE-END
STEP 5 — REPORT
- Give me: the loop memo's URL, and the exact command to start the loop — `/loop 60m /memo-drafting-loop`.
- Tell me that when /loop asks whether to schedule it, I must choose "This session only" — interactive billing keeps the loop on my subscription, and a cloud schedule cannot reach my local MythOS MCP.
- Tell me how to queue a memo: create a thin memo (title = the subject; optional notes or links in the body), and in its Notes `# Tags` field add one marker tag from the runbook's cheat sheet (e.g. `#person-memo-for-drafting-by-{{MYBOT}}`). MythOS autocomplete will surface the markers because the runbook keeps them in the tag library.
- Tell me that any per-memo steering — angle, emphasis, my own take on the subject — goes in the body or `# Notes` prose, not in the marker tag.
=== RUNBOOK — this becomes the body of the loop memo ===
An hourly `/loop` that drains the queue: it picks up any memo carrying a `-memo-for-drafting-by-{{MYBOT}}` marker tag, executes the instruction that marker names — drafting through a template or running an operation — and removes the marker once the work is done. Status — schema v2.1; this runbook serves as the persistent tag dictionary (loop skips it by id; see Step 1).
## Purpose
This loop keeps my authoring queue moving without me drafting from a blank page. I capture an idea as a thin stub memo: a title naming the subject, optional seed material in the body (a URL, raw notes, a framing line), and any per-memo steering (the angle to take, what to emphasize, my own take) as prose in the body or `# Notes`. In the Notes `# Tags` field I tag it with one marker — a tag of the form `#<template>-memo-for-drafting-by-{{MYBOT}}` to draft through a template, or `#seo-memo-for-drafting-by-{{MYBOT}}` to run an SEO pass on an already-written memo. My agent runs this loop, drafts the memo through the named template in my voice (or runs the operation), removes the marker, and leaves a finished memo carrying its real identity tags.
## Prerequisites
- **The `/memo-drafting-loop` slash command** — installed at `~/.claude/commands/memo-drafting-loop.md`; the loop's entry point, which reads this memo and executes one pass.
- **MythOS MCP access** — the loop reads and writes my library through the `mythos` MCP server, available to interactive Claude Code.
- **A running loop** — `/loop 60m /memo-drafting-loop` active in an interactive terminal session. When `/loop` offers to schedule it in the cloud, decline — see Conventions.
## The Loop
### Step 1 — Load context and discover the queue
- Call `get_context` — required before any memo write; loads the style ruleset and the template catalog.
- Call `list_tags` and filter for tag names ending in `-memo-for-drafting-by-{{MYBOT}}` — those are the active marker tags in my library.
- For each matched marker, call `search_memos` with an empty query and that tag as the filter. Aggregate the results, deduplicating by memo id.
- Exclude this runbook (`/me/{{MY-USERNAME}}/{{MEMO-ID}}`) from the aggregated queue. It carries every marker tag as a dictionary entry so the tags persist in MythOS's library for autocomplete; it is itself never a stub to draft. See the Conventions callout on the tag dictionary.
- If nothing remains in the queue, stop here and report it — most passes end at this step and should stay cheap.
### Step 2 — Resolve each queued memo to an instruction
- For every queued memo, call `read_memo`. Inputs: the **title** is the subject; the **body** and `# Notes` are seed material — URLs, raw notes, framing, and any per-memo steering I wrote there; the **marker tag** is the routing signal.
- Resolve the marker tag against the Template Cheat Sheet below. Each row maps a marker to what to do (draft via a specific template, or run an operation) and the identity tag to apply on success.
- If a marker matched by `list_tags` has no cheat-sheet row, mark the memo UNRECOGNIZED in Step 5 and skip — never guess. I add a cheat-sheet row, the loop handles it next pass.
- If a memo carries more than one `-memo-for-drafting-by-{{MYBOT}}` marker, mark BLOCKED in Step 5 with the reason "multiple markers."
### Step 3 — Execute the resolved instruction
- For a drafting row, call `read_template` for the resolved template. Research the subject to the depth it asks for: web search for public facts, `search_memos` for existing memos to @mention. Draft through the template's structure, in my voice per the auto-loaded Mythos Style, building on the body notes and any steering I left there.
- For the SEO operation row (`#seo-memo-for-drafting-by-{{MYBOT}}`), the memo is already written — populate `seoTitle` and `seoDescription` via `update_memo_seo`, leave the body untouched.
- If the subject or a load-bearing detail cannot be verified, do not invent it — mark the memo BLOCKED in Step 5.
### Step 4 — Write and swap the marker
- For a draft, call `update_memo` with the drafted body, populated `seoTitle` and `seoDescription`, the body `# Contexts` filled with real identity tags, and the resolved template applied via `templateId` so visibility follows the template. Run the template's pre-submit checklist before treating the write as done.
- Rewrite the Notes `# Tags` field: remove the marker tag and add the identity tag the cheat sheet row specifies. The SEO operation removes the marker with no replacement (the memo already carries its real identity tags from its prior life).
- Do the marker swap only after a clean write or operation. A memo that errors mid-step keeps its marker and is retried next pass.
### Step 5 — Report
- Give a close-out receipt for the pass: each memo processed with its path, each BLOCKED with the reason, each UNRECOGNIZED with the unmapped marker, and whether the queue is now clear.
- Do not create a session-report memo per pass — the close-out receipt covers the run.
## Template Cheat Sheet
Maps each marker tag to its instruction. I edit this list directly; the loop reads it fresh every pass. Add a row whenever a new template or operation should be supported by the queue — and use the `-memo-for-drafting-by-{{MYBOT}}` suffix on the marker so the loop's `list_tags` scan discovers it automatically. Each marker is written in `[#marker](/tag/marker)` link syntax so MythOS registers it as a live tag on this runbook (the tag-dictionary pattern); identity tags use backticks because they must stay inert here.
- [#person-memo-for-drafting-by-{{MYBOT}}](/tag/person-memo-for-drafting-by-{{MYBOT}}) → draft via Person Reference Memo; on success, replace marker with `#person`.
- [#company-memo-for-drafting-by-{{MYBOT}}](/tag/company-memo-for-drafting-by-{{MYBOT}}) → draft via Company Reference Memo; on success, replace marker with `#company`.
- [#quick-reference-memo-for-drafting-by-{{MYBOT}}](/tag/quick-reference-memo-for-drafting-by-{{MYBOT}}) → draft via Quick Reference Memo; on success, replace marker with `#reference`.
- [#seo-memo-for-drafting-by-{{MYBOT}}](/tag/seo-memo-for-drafting-by-{{MYBOT}}) → run SEO operation: populate `seoTitle` and `seoDescription` via `update_memo_seo`; do not touch the body; remove the marker with no replacement.
## Conventions
:::callout{icon=📌,color=purple}
This runs as `/loop` inside an interactive terminal by deliberate choice, and two facts keep it there. Billing — interactive Claude Code stays on subscription, while headless `claude -p` and cloud routines bill to the metered Agent SDK credit pool as of June 15, 2026, and a cloud routine cannot reach the locally-configured `mythos` MCP. When `/loop` offers to schedule this in the cloud, always choose "This session only."
:::
:::callout{icon=📌,color=purple}
This runbook is the persistent tag dictionary. Every cheat-sheet marker is written in `[#marker](/tag/marker)` link syntax in the body, which makes MythOS register it as a live tag on this memo. That keeps the markers in the tag library so autocomplete works when I tag a new stub. Step 1's exclude-by-id drops this memo from the queue every pass so the loop never tries to draft over its own runbook. When I add a new cheat-sheet row, the new marker becomes a dictionary entry automatically — no separate registration step is needed.
:::
:::callout{icon=📌,color=purple}
Removing the marker tag is the only thing preventing a memo from being processed twice. Swap or remove it only after a successful write or operation. A memo that errors mid-step keeps its marker and is retried next pass. Never strip the marker on a partial or failed step.
:::
:::callout{icon=📌,color=purple}
Per-memo steering — the angle, the emphasis, my stance, contextual notes — lives in the body or `# Notes` prose, not in the marker tag. The loop reads body+notes as seed material. If a stub wants a specific take, write it as a Note bullet or a line in the body.
:::
:::callout{icon=📌,color=purple}
Never fabricate to fill a gap. An unverifiable subject or detail makes the memo BLOCKED: leave the marker tag in place, do not draft, and surface it in the close-out receipt.
:::
- Each pass drains the whole queue, not one memo.
- Discovery is by suffix: the loop's `list_tags` scan filters for `-memo-for-drafting-by-{{MYBOT}}`. Any future operation should follow the same suffix so it is discovered automatically; only the cheat sheet needs a new row.
- This memo is the loop's entire logic; editing it changes how the next pass behaves.
- To pause the loop, stop the `/loop`; to change cadence, restart it with a new interval.
# Contexts
* #agent-ops
=== END RUNBOOK ===

3. Start the loop

When the prompt finishes it gives you a command. Run it in an interactive Claude Code session:

/loop 60m /memo-drafting-loop

When /loop asks whether to schedule it, choose "This session only." That keeps the loop on your subscription billing and lets it reach your local MythOS MCP — a cloud schedule does neither.

Using It

To queue a memo — create a thin memo with a title naming the subject, any links or notes in the body (including any per-memo steering you want the draft to follow), and in its Notes # Tags field add one marker tag from your runbook's cheat sheet. Autocomplete surfaces the markers because the runbook keeps them in your tag library. The loop picks it up on the next pass.

To find what was just drafted — the loop's close-out receipt lists every memo it touched with its path. Drafted memos land in your library carrying their real identity tags (e.g. #person, #company) — no marker tag remains. There is no separate review-tag inbox; you review on your own cadence by scanning recently-updated memos.

To refine the loop — edit your runbook memo. The Template Cheat Sheet near its bottom maps each marker to its template and identity tag; add a row whenever you want a new template or operation supported. Change a step or a convention and the next pass follows it. The memo is the loop.

Contexts

• 🏷️#agentic-augmentation
• 🏷️#claude-code