How to Actually Run a Claude Memory Stack: 90 Days of Receipts

Most people treat Claude memory like a bigger notebook.

They dump more into the window every week and wonder why the agent feels slower, not smarter.

That is not a model problem. It is a loading problem.

It is a loading problem.

Ninety days ago I published the first version of this stack. Seven thousand bookmarks later, the pattern still holds: the fix was never a bigger context window. It was what you load, what you route, and what you deliberately forget.

This article is the 90-day update. Same three-layer architecture. New failure modes. New compounding habits. Real files from the lab.

You will get:

1. Why session memory alone hits a ceiling by week three
2. The Memory Stack framework (Index, Topics, Audit) and what each layer owns
3. What broke in the first 60 days and what we changed
4. A copy-paste journal template for agent loops that actually close
5. The real MEMORY.md index pattern running in production today
6. A weekly prune ritual that keeps retrieval fast

Part 1 · The failure everyone blames on the model

Here is the pattern that kills most memory setups.

Here is the pattern that kills most memory setups.

Week one feels magical. CLAUDE.md loads. The agent remembers your conventions. You stop re-explaining the repo layout.

Week three the daily notes file is four thousand lines. MEMORY.md became a dump. Every session starts by reading half your vault into context. The agent sounds confident and cites stale decisions from March.

Week six you "upgrade to a bigger model" and get a more articulate amnesiac.

The failure mode is not intelligence. It is unscoped accumulation.

Cowan's limit still applies: working attention handles a handful of meaningful chunks, not a warehouse of tokens. A 200K window does not change that constraint. It changes how much raw text the model can scan. Scanning is not knowing.

I run a private operator stack with ten specialist agents and thirty-five scheduled jobs. When memory drifts in that environment, the symptom is always the same: the agent proposes patterns you explicitly rejected, re-asks questions you answered Tuesday, and treats yesterday's experiment like today's policy.

That is context amnesia with extra steps.

Not because the model forgot.

Because you never built a forget path.

Part 2 · Memory is not one file

The obvious fix is "just use MEMORY.md."

The obvious fix is "just use MEMORY.md."

That works for two weeks. Then MEMORY.md becomes the dump file and you are back to goldfish mode with better filenames.

What actually compounds is a stack with three jobs:

Index. Routes the agent to the right topic file without loading everything.

Topics. Hold dated facts, corrections, and receipts in small scoped files.

Audit. A scheduled pass that prunes stale lines, flags contradictions, and writes summary deltas back to the index.

I call this The Memory Stack. Not because it is clever. Because each layer fails differently and you need all three to survive month two.

Layer one is session routing. CLAUDE.md plus a short MEMORY.md index the agent reads at session start. Under two hundred lines combined for the index. Detailed history lives elsewhere.

Layer two is topic memory. One file per domain. Dated lines. Corrections appended, not silently edited. The agent retrieves by topic, not by dumping the vault.

Layer three is the audit loop. A weekly cron (or a Friday habit if you are solo) that reads topic files, archives what expired, and updates the index with what still matters.

Skip the index and topic files collide. Skip the audit and the stack bloats. Skip topic files and the index becomes the dump.

Part 3 · What broke in 60 days (and what compounded)

The original article shipped in March. By April the receipts were clear.

What broke first: daily notes bloating context every week. I was appending session logs to a single daily.md because it felt fast. Fast became expensive. Every morning the agent read three weeks of noise to find one decision.

What compounded second: weekly prune plus scoped retrieval. Moving decisions into topic files (posting-voice.md, cron-resilience.md, memory-gotchas.md) and deleting lines older than their TTL changed session start from archaeology to orientation.

What we added by day sixty: a cron-triggered memory audit. Not fancy. A Friday job that asks: which index lines still have a file behind them, which topic files grew past five hundred lines, which decisions contradict each other. Output is a short delta the CEO session applies manually. Ten minutes. Prevents month-three collapse.

Ninety days in, the metric that matters is not "how much the agent remembers." It is "how little it needs to read to act correctly."

The stack is boring on purpose. Boring compounds.

Part 4 · The Index layer (your real MEMORY.md)

The index is not memory. It is a table of contents the agent actually reads.

Rules that survived 90 days:

One line per topic file. What it holds. When it was last verified.

No prose essays in the index. No session logs. No "helpful context."

Hard cap near two hundred lines. If you exceed it, you have a topic file pretending to be an index.

Here is the real index running in my lab today (verbatim):

# Memory index

- [myCEO architecture](myceo-architecture.md) - lib modules, config, per-venture X accounts, scan/post content-safety flow, A/B loop, validate gate
- [Pending user actions](myceo-pending-user-actions.md) - Hermes cron prompt update (mentions paused), cookie-refresh path, rpcedge account activation, revenue state
- [X creator revenue source](x-creator-revenue-source.md) - revenue_sharing URL + which JSON files feed the dashboard revenue metrics
- [Dashboard dev tooling](dashboard-dev-tooling.md) - start via next binary (pnpm+sharp gotcha), mobile-qa Playwright harness, responsive CSS location
- [x-article-factory 2026-07 patterns](x-article-factory-2026-07-patterns.md) - three-beat close mandatory, cover style presets (terminal-blueprint = rpcedge), bare-link tweets, evidence-tag gotchas
- [Hallmark UI skill](hallmark-ui-skill.md) - installed globally, ALWAYS use for UI work (audit/redesign/study verbs)
- [Ledger 80-char preview gotcha](ledger-80-char-preview-gotcha.md) - content-ledger/replied-log store 80-char previews, not shipped bodies; filter them before mining
- [Phase 1-2 gates + new subsystems](myceo-phase12-gates.md) - gate choke point, eval gate in validate, skill_audit, cron_drift_check, spend_breaker, approval_sweep
- [Config layers test-isolation trap](config-layers-test-isolation-trap.md) - patching CONFIG_FILE isolates nothing; unisolated tests once flipped the live kill switch to safe mode
- [Cron resilience + CTA system](myceo-cron-resilience-cta.md) - why crons died (idle >600s, 09:03 collision, 120s script cap), catch-up job, heartbeats, per-venture CTAs
- [First-reply style rule](first-reply-style-rule.md) - fitting text + link, never bare link; enforce at creation, guard stays permissive
- [nyk style reference: cyrilXBT](nyk-style-reference-cyrilxbt.md) - PRIMARY reference for nyk writing/formatting; deep-dive doc + voice.md skeletons
- [LLM cost model](myceo-llm-cost-model.md) - state.db telemetry, metered vs flat-fee lanes, provider-not-model pricing trap, comment-batch is the whole cron bill

Copy the shape, not the filenames. Your domains differ. The invariant is: index routes, topics store, audit prunes.

Point CLAUDE.md at this index in one line: "Read memory/MEMORY.md first; open linked topic files only when the task needs them."

That single rule cut my average session preamble by more than half.

Part 5 · Topic files and the journal loop

Topic files hold dated facts. Not narratives. Not meeting minutes.

Format that survived contact with cron agents:

2026-07-08 | posting | self-QTs require media; launch pack enforces
2026-07-09 | posting | convo-reply cron paused; mentions queue stale
2026-07-10 | memory | index cap 200 lines; split when >12 topics

One line. One domain tag. One verifier date.

Agents append. Humans prune on audit day. Silent edits are how you gaslight your future self.

For recurring agent loops (posting, research, trading sandboxes, review bots), add a journal that closes the feedback loop. Storage without recall is a diary nobody opens.

Paste this journal template into your harness (verbatim):

Journal protocol

TASK DOMAIN (tag for retrieval):
Journal file path:

AFTER EVERY RUN (four lines, no more):
1. DECIDED:
2. Expected:
3. ACTUAL (from tool output, not vibes):
4. Next time:

Before every run:
- read last N entries for this TASK DOMAIN
- list one lesson you are applying this run
- if no lesson applies, say why

Stop rule:
- if ACTUAL is empty three runs in a row, fix the verifier before journaling more

My posting lane uses ventures/personal-brand/research/convo-reply-journal.md with domain tag convo-reply. My memory audits use memory/audit-deltas.md with tag memory-stack.

Four lines. Verifier-backed line three. Read-before-act. That is the whole loop.

Part 6 · The Audit layer (weekly prune)

The audit is not optional polish. It is how the stack survives month three.

My Friday pass (manual or cron-triggered) runs five checks:

Contradiction scan. Two topic lines that disagree on the same decision. Flag both. Pick a winner or archive both.

Stale TTL. Lines older than their domain TTL (posting: 14 days, architecture: 90 days, experiments: 30 days). Archive to archive/ or delete.

Index drift. Index entries pointing at missing files. Fix links or remove rows.

File size. Topic files over five hundred lines get split by subdomain.

Receipt spot-check. One random line per file: still true? If not, correct or delete.

Output is ten bullets max written to the index or a delta file. Not a report. A to-do list for the next CEO session.

Agents do not get bored with maintenance. Humans skip it because they are late for a meeting. Cron the boring part.

Part 7 · Obsidian and the graph (layer two optional upgrade)

You do not need Obsidian. You need markdown files with wikilinks in folders.

Obsidian is a good interface for the graph. The graph is what matters.

If you use MCP bridges (semantic search plus structured query), the vault still has to be structured or retrieval returns noise. Prose-as-title notes beat category filenames. [[memory graphs beat giant memory files]] links read as claims, not folders.

brain-ingest (or any local transcript pipeline) feeds layer three: conference talks and podcasts become structured notes with frontmatter, not raw transcripts in context.

The 90-day lesson: ingestion without audit equals a faster landfill.

Part 8 · Failure modes (why most stacks stall)

Write-only memory. Files grow. Nothing reads them before action. Fix: mandatory read-before-act in the harness.

Index as dump. Everything important goes in MEMORY.md because it is easy. Fix: hard cap and split.

Timeless lines. "We use pnpm" without a date. Six months later it is wrong and authoritative. Fix: date every line.

Fiction journals. Line three says what the agent wishes happened. Fix: anchor to tool output, test results, or ledger rows.

No forget path. Accumulation is treated as progress. Fix: weekly prune with TTL rules.

Part 9 · Try it this week (homework)

Do not rebuild your life Sunday night. Do one domain.

Step 1. Create memory/MEMORY.md as a routing index only. Cap it at fifty lines to start.

Step 2. Add one topic file for your noisiest domain (posting, code, research, trading).

Step 3. Point CLAUDE.md at the index.

Step 4. Paste the journal template into one recurring agent job.

Step 5. Schedule a weekly fifteen-minute audit. Set a calendar reminder if cron is overkill.

The first session after step three feels different. Not because Claude got smarter. Because it stopped loading March.

The close

The model is not the memory. The stack is.

Windows reset. Prompts rot. Indexes without audits become landfills.

Ninety days taught me the same lesson as day one, sharper: compounding is a loading discipline, not a storage race.

Set up ONE topic file properly this week. Prune it next Friday. Let the agent read before it acts.

The orchestration patterns behind this stack are open source: https://github.com/builderz-labs/mission-control

Follow @nyk_builderz for the exact templates and weekly receipts from the lab.

Production receipt

Run this stack for one week before you buy another model seat. Log every failure to a dated journal file. Re-read the journal before the next mission. Keep the loop closed. That is the whole game: measure, prune, route, and verify. The receipt is the difference between a demo and a system that compounds.

Follow @nyk_builderz for AI agent systems, Solana infrastructure, and build-in-public.

• Site: nyk.dev
• GitHub: 0xNyk
• RPC Edge: rpcedge.com