Session Memory Layer + PMM - Never Lose Context Again in Claude CoWork

Here's the problem Claude CoWork doesn't solve out of the box: continuity.

Every session starts cold. Claude doesn't remember what you worked on last Tuesday, what decision you made and why, or what you told it to follow up on. You either re-explain everything at the start - or you lose the thread entirely.

PMM (Poor Man's Memory), originally inspired by Millennial Cat's work (excellent stuff - definitely check out his threads!), solves the first layer. It gives Claude a structured knowledge base to read at session start. Your contacts, your rules, your processes, your decisions - all formatted as typed markdown files Claude loads before doing anything.

But PMM solves what Claude knows about you. It doesn't solve what you and Claude worked on together yesterday.

Session Memory Layer solves that.

Together, they're a complete two-layer memory system.

---

What Each Layer Does

PMM — Curated domain knowledge

- Who your contacts are and what they need

- Your rules, decisions, and processes

- Your terminology, preferences, and brand context

- Loaded by workspace (sales, writing, legal, etc.) based on routing rules in CLAUDE.md

Session Memory Layer - Working continuity

- What was worked on in the last 10 sessions (rolling log)

- What's still open and needs follow-up (persistent thread tracker)

- Loaded at *every* session start, regardless of domain

- Updated at *every* session end, automatically

Think of PMM as your institutional knowledge base. Think of Session Memory as your working memory - the part that remembers "last time we were halfway through that proposal."

-------

The Two Files

Session Memory Layer lives in two markdown files. That's it.

### session-log.md

A rolling 10-session history. Each entry is lean (about 6 fields, roughly 6–8 lines). It captures:

- What was worked on

- Decisions made

- Files created or modified

- Contacts touched

- Open threads created

- Threads closed

Newest entry at the top. When you hit 11 sessions, the oldest one drops off.

### open-threads.md

A persistent tracker for anything unfinished. Each thread gets a sequential ID (OT-001, OT-002, etc.) and lives in Active until it's resolved. Resolved threads move to a Closed section. Nothing gets deleted.

A thread gets created when:

- A task starts but doesn't finish

- A decision gets deferred

- A document gets partially drafted

- A follow-up action gets identified but not executed

- A question comes up that needs more research

A thread closes when the work is done.

---------

How the Two Layers Work Together

Here's what the full flow looks like at session start:

1. Claude reads `session-log.md` and `open-threads.md` (always, before anything else)

2. Claude checks for open threads relevant to your stated task

3. If there's a match, it surfaces it before starting work: *"You have an open thread from [date] on [topic] - want to continue that or start fresh?"*

4. Then it routes to the right PMM workspace based on task type (sales, writing, brand, etc.)

At session end:

1. Claude writes a lean entry to `session-log.md`

2. Claude updates `open-threads.md` - new threads added, resolved ones closed

3. No confirmation needed. It runs as part of the wrap-up automatically.

PMM gives Claude the deep context it needs for your domain. Session Memory gives it the thread it needs to pick up where you left off.

-------

## Step-by-Step Build Guide

### Step 1: Set up your PMM base (if you haven't already)

Follow Millennial Cat's PMM framework. https://www.skool.com/quantum-quill-lyceum-1116/multi-agent-memory-management-with-folders-and-files At minimum, set up:

```

memory/

[workspace-name]/

CONTEXT.md ← workspace map, tier file index

decisions.md ← append-only decisions log

lessons.md ← what failed and what to do instead

rules.md ← rules that override session context

processes.md ← repeatable step-by-step workflows

```

Add a routing table to your CLAUDE.md that tells Claude which workspace to load based on task type.

### Step 2: Create your Session Memory folder

```

memory/

sessions/

session-log.md

open-threads.md

CONTEXT.md ← optional but recommended

```

### Step 3: Build session-log.md

Start with this template:

```markdown

# Session Log

Last updated: [DATE]

---

## Open Threads (Quick Ref)

See open-threads.md for full detail. High-priority items listed here for fast reference.

|----|--------|--------|-------------|

---

## Session History (Last 10 | Rolling)

[entries will go here]

```

### Step 4: Build open-threads.md

```markdown

# Open Threads

Last updated: [DATE]

---

## Active Threads

|----|--------|---------|--------|----------|-------------|

---

## Closed Threads (Last 20)

|----|--------|--------|--------|------------|

```

### Step 5: Add Session Startup Protocol to CLAUDE.md

Tell Claude to run this at every session start, before any workspace routing:

```

1. Read memory/sessions/session-log.md

2. Read memory/sessions/open-threads.md

3. Identify open threads that match the user's stated task or domain

4. Surface relevant open threads before starting work

5. Proceed with standard workspace routing

```

### Step 6: Add Session Capture Protocol to CLAUDE.md

Tell Claude to run this at every wrap-up, without asking for confirmation:

```

1. Write a lean entry to session-log.md

- Format: ### YYYY-MM-DD | [Session Title]

- Fields: Worked on / Decisions / Files created / Contacts / Open threads created / Threads closed

- Prepend newest entry to top

- Remove oldest entry if count exceeds 10

- Update "Last updated" date

2. Update open-threads.md

- Add new open threads with next sequential OT-XXX ID

- Move resolved threads to Closed section

- Update "Last updated" date

```

### Step 7: Add the routing row to your CLAUDE.md routing table

Add a universal row that loads before any domain-specific routing:

| Task Type | Workspace | Load Path |

|-----------|-----------|-----------|

| Every session start (universal) | Sessions | memory/sessions/session-log.md + memory/sessions/open-threads.md |

---

## Pros

- **Zero re-explaining.** Claude picks up where you left off without you having to summarize the last session.

- **Nothing falls through the cracks.** Open threads persist until they're explicitly closed. Partial work doesn't vanish.

- **Lightweight.** Two files. Lean entries. Rolling window of 10. No bloat.

- **Automatic.** Claude writes the log and updates threads at wrap-up. You don't have to maintain it manually.

- **Works across domains.** Session Memory loads universally. PMM loads by workspace. The two layers don't interfere with each other.

- **Auditable.** You always know what Claude worked on and what it was told to follow up on.

## Cons

- **Requires wrap-up discipline.** The log only gets written if you explicitly wrap up the session. Skip the wrap-up, and that session doesn't get captured.

- **Rolling window loses old history.** After 10 sessions, the oldest entry drops. If you need long-term history, you'll need to archive manually or adjust the window size.

- **Thread hygiene is on you.** Claude creates threads when it identifies unfinished work, but it'll miss things it wasn't involved in. If you made a decision outside of CoWork, it won't know.

- **Context window cost.** Both files load every session. If your session-log or open-threads grow very long, they add to your context load. The lean-entry format is designed to minimize this, but worth watching.

- **CoWork-specific.** This system is built for Claude CoWork with file access. It won't work in standard Claude.ai chat.

---

## One More Thing

The value compounds. A single session log entry isn't that impressive. After 5–10 sessions, you have a working record of everything you and Claude built together - decisions made, threads opened and closed, files created. That record is the system.

It also makes Claude dramatically better at suggesting what to work on next. When it knows the last 10 sessions, it sees patterns you might miss.

Build the base. Let it run. It gets more useful every session.

There's likely a better way to do this - hence my post sharing this. I'm working to keep it lean, low token usage (I'd rather burn tokens on other fun tasks). Ideally this helps smooth the experience and creates a stronger Claude Assist for whatever you're building.

---------

*Built on PMM architecture inspired by Millennial Cat. Session Memory Layer design by me. Running in Claude CoWork.*

10 comments