The Complete Total Recall Playbook: Setting Up Selective Agent Memory for Personal and Fleet Workflows

//Unifying Long-Term Context and Overcoming Agentic Amnesia

AI coding assistants like Claude Code are fundamentally stateless between execution cycles. Every time you start a new terminal session or open a fresh command window, the agent starts with complete amnesia. It forgets your coding preferences, architectural boundaries, package-manager quirks, and past debug solutions.

Standard attempts to solve this problem usually fail:

Total Recall (developed by davegoldblatt) solves this by acting as a highly selective local notepad. Instead of dumping raw chat logs, it filters information through an LLM-driven Write Gate to evaluate if an observation will change future behavior, then categorizes it into a structured, four-tier hierarchy.

//The 4-Tier Memory Architecture

Total Recall partitions your agent's memory into four functional zones:

  [ Ephemeral Conversation ]  (Session chat history — discarded on exit)
             │
             ▼ WRITE GATE: "Does this change future behavior?"
             │
  [ Daily Notebook ]  (memory/daily/YYYY-MM-DD.md — raw, local, local-only logs)
             │
             ▼ PROMOTION: user-controlled via /recall-promote
             │
  [ Pantry Registers ]  (memory/registers/*.md — structured claims & context)
             │
             ▼ DISTILLATION: essential context automatically loaded
             │
  [ Working Memory ]  (CLAUDE.local.md — active tasks, habits, and preferences)
             │
             ▼ EXPIRY: completed / deprecated items
             │
  [ Storage Closet ]  (memory/archive/ — historic audit logs, searchable on-demand)

1. Counter / Working Memory (`CLAUDE.local.md`)

This is the active working context. It is loaded automatically at the start of every session. It is kept extremely lean (~1,500 words maximum) to avoid wasting your context window.

2. Pantry Registers (`memory/registers/`)

Structured, categorized markdown files (e.g., preferences.md, architecture.md, collaborators.md). These contain specific facts, schemas, or constraints that Claude queries only on-demand when performing relevant tasks.

3. Daily Notebook (`memory/daily/`)

Raw, timestamped scratch notes. Every new learning or correction made by the agent lands here first before being promoted.

4. Storage Closet Archive (`memory/archive/`)

Outdated or superseded entries. It acts as a historical audit log, keeping your active context clean while preserving searchability.

//Standard Installation (The Straightforward Path)

Total Recall is optimized to run as a native Claude Code plugin, but can also run in standalone mode for projects without plugin support.

Option A: Native Plugin Installation (Recommended)

Launch Claude Code and run the following slash commands directly:

/plugin marketplace add davegoldblatt/recall-marketplace
/plugin install recall@recall-marketplace

Note: In plugin mode, commands are namespaced with /recall: (e.g., /recall:recall-write and /recall:recall-promote).

Option B: Standalone Installation

If you prefer a standalone script-driven setup for other terminal workflows, run:

git clone https://github.com/davegoldblatt/total-recall.git
cd total-recall
./install.sh /path/to/your/project

After installation, reload your workspace or run /hooks in Claude Code to initialize session lifecycle triggers.

//Core Operations & Commands Cheat Sheet

//Non-Straightforward Installation: Personal vs. Fleet Partitioning

In a professional environment, developers face a critical security and compliance hazard: How do you leverage persistent agent memory across a distributed team without bleeding personal developer notes, credentials, and individual preferences into the shared Git repository?

If you commit everything, you leak sensitive context. If you commit nothing, every team member has to manually train their local agents on repo-specific guidelines from scratch.

The Separation Blueprint

The professional solution is to split the tracking of your memory folders in Git. This ensures shared guidelines stay synced while personal journals stay completely local.

📁 project-root/
├── 📁 rules/
│   └── 📄 total-recall.md        <── [COMMIT] Shared write gate & linting rules
├── 📄 CLAUDE.md                  <── [COMMIT] Shared build & test specifications
├── 📄 CLAUDE.local.md            <── [IGNORE] Personal active task / workspace branch
└── 📁 memory/
    ├── 📁 registers/             <── [COMMIT] Shared tech stack, API schemas, design systems
    ├── 📁 daily/                 <── [IGNORE] Personal transient developer notes
    └── 📁 archive/               <── [COMMIT] Shared historic project decisions

Step 1: Configure `.gitignore`

Add your personal working memory, scratchpads, and daily logs to your project's .gitignore file:

# Total Recall: Personal / Local Developer Memory
CLAUDE.local.md
memory/daily/

By excluding memory/daily/ and CLAUDE.local.md from version control, individual logs stay 100% private on your machine.

Step 2: Commit Team Registers and Rules

Commit the core guidelines and registers so they are automatically distributed to any developer (or CI agent) checking out the repository:

git add rules/total-recall.md CLAUDE.md memory/registers/
git commit -m "chore: initialize fleet-wide Total Recall memory registers"
git push origin main

Step 3: Enforce the Promotion Pipeline (The Human Gate)

To keep the shared memory/registers/ clean, establish a team convention:

//Multi-Profile Isolation: Separating Work from Side Projects

If you use a single laptop for both corporate work and personal side-projects, you must prevent your professional registers (like proprietary architecture structures) from bleeding into personal coding contexts.

The Solution: Workspace Partitioning via Symlinks

Since Total Recall naturally resolves paths relative to the current workspace root, you can create a centralized personal profile and reference it selectively.

mkdir -p ~/.personal-vault/memory/registers

ln -s ~/.personal-vault/memory /path/to/personal-project/memory

//Architectural Comparison: Personal vs. Fleet Architectures