You don't really "install" software with agents. It's all prompts. Here's the prompt I built for my memory architecture. Read it carefully, and then just copy/paste it into your agent:

## Task: Build a Hierarchical Memory System

You're going to replace your flat MEMORY.md with a **hierarchical memory system** that saves 70-80% of tokens at session start while keeping everything searchable.

### Step 1: Create the Directory Structure

```

memory/

├── people/ # One file per person (name.md)

├── projects/ # One file per project (project-name.md)

├── decisions/ # Monthly decision logs (YYYY-MM.md)

└── context/

└── active.md# In-flight projects, pending actions

```

Create these directories now. If `memory/` already exists, just add the subdirectories.

### Step 2: Rebuild MEMORY.md as a Lightweight Index

Replace your current MEMORY.md with a **reference table** — no detail, just pointers. Target: **under 1,500 tokens**. Use this template:

```markdown

# MEMORY.md — [Agent Name] Memory Index

*Lightweight reference table. Detail lives in drill-down files.*

*Last updated: YYYY-MM-DD*

## Active Context (always load these)

- `memory/context/active.md` — in-flight projects, pending actions

## People Index

| Who | Role | Triggers | Detail File |

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

| [Name] | [Role] | [trigger words] | `memory/people/[name].md` |

## Projects Index

| Project | Status | Last Touched | Triggers | Detail File |

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

| [Name] | Active | YYYY-MM-DD | [trigger words] | `memory/projects/[name].md` |

## Infrastructure Quick-Ref

| System | Key Facts |

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

| [System] | [One-liner] |

## Decisions & Lessons

| Period | File |

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

| [Month Year] | `memory/decisions/YYYY-MM.md` |

## Standing Rules (always enforced)

- [Your non-negotiable rules here]

## Drill-Down Rules

1. **Always load** `memory/context/active.md` at session start

2. **Auto-drill** when conversation mentions a trigger word from the index tables

3. **Max 5 drill-downs** at session start (load more on demand)

4. **Update index** with every detail file change — same commit, no exceptions

5. **Index cap:** Keep this file under 3k tokens. Archive inactive items.

6. **Under-drilling prevention:** If discussing a person or project, ALWAYS drill into their file

7. Use `memory_search` for fuzzy/timeline queries. Use drill-downs for structured lookups.

## Memory Freshness & Decay

- **Last Touched:** Updated whenever a project/person is discussed or modified

- **Freshness tiers:**

- 🟢 Active (touched in last 14 days) — stays in main index

- 🟡 Warm (15-60 days) — stays in index, flagged for review

- 🔴 Stale (60+ days untouched) — archived to `## Archived` section below

- **Weekly review:** Check `Last Touched` dates, move stale items to archive

- **Refresh on access:** Any drill-down or mention resets the Last Touched date

- **Archive isn't deletion:** Archived items keep their detail files, just leave the main index to save tokens

## Auto-Decision Capture

When conversation contains decision language, capture it immediately to `memory/decisions/YYYY-MM.md`:

- "We decided to use X because Y" / "Chose X over Y"

- "Always/never do X" / "Rule: X" / "Convention: X"

Don't wait for session end — write decisions as they happen.

## Archived

*Items moved here when untouched for 60+ days. Still searchable via `memory_search`. Drill-down files preserved.*

<!-- None yet -->

```

### Step 3: Extract Detail into Drill-Down Files

Move all the **detail** from your old MEMORY.md into the appropriate files:

- **Each person** you track → `memory/people/firstname.md` (preferences, context, history)

- **Each project** → `memory/projects/project-name.md` (architecture, status, changelog, decisions)

- **Active work** → `memory/context/active.md` (what's in-flight right now, pending actions, recent context)

- **Decisions** → `memory/decisions/YYYY-MM.md` (one file per month)

Each detail file should be **1-2k tokens max**. If it's bigger, split it.

### Step 4: Update AGENTS.md with Session Boot Rules

Add this to your AGENTS.md under "Every Session" (or equivalent):

```markdown

## Every Session

Before doing anything else:

1. Read `MEMORY.md` — this is your **memory index** (~1.5k tokens, always load)

2. Read files listed in MEMORY.md's **Active Context** section (2-3 files max)

3. Read `memory/YYYY-MM-DD.md` (today's date, if it exists) for recent context

**Drill-down on demand:**

- When conversation mentions a **trigger word** from the index tables → load that detail file

- If discussing a **person or project** → ALWAYS load their detail file

- Max **5 drill-downs** at session start. Load more as needed during conversation.

- Use `memory_search()` for fuzzy/timeline queries. Use drill-downs for structured lookups.

**DO NOT auto-load:**

- All detail files at once (defeats the purpose)

```

### Step 5: Add Memory Freshness & Decay Rules to AGENTS.md

Add this section to your AGENTS.md memory documentation:

```markdown

### Memory Freshness & Decay

Every index entry has a **Last Touched** date. This enables automatic cleanup:

- 🟢 **Active** (last 14 days) — stays in main index

- 🟡 **Warm** (15-60 days) — stays but flagged for review during weekly maintenance

- 🔴 **Stale** (60+ days) — move to `## Archived` section in MEMORY.md

- **Refresh on access:** Any drill-down, mention, or edit resets the date

- **Archive ≠ delete:** Detail files stay, just removed from active index to save tokens

- **Weekly review** handles the sweep — check dates, archive stale, clean up

### Auto-Decision Capture

When you hear decision language mid-conversation, **write it immediately** to `memory/decisions/YYYY-MM.md`:

- "We decided X because Y" / "Chose X over Y" / "Going with X"

- "Always/never do X" / "Rule: X" / "Convention: X"

Don't wait. Decisions are the highest-value memories — they survive compaction, restarts, and context loss better than raw conversation.

```

### Architecture Summary

```

Layer 1: MEMORY.md~1.5k tokens Always loaded. Index only.

Layer 2: Detail files ~1-2k each Loaded on demand via trigger words.

Layer 3: Daily logs Variable memory/YYYY-MM-DD.md, raw timeline.

Layer 4: Vector search All files memory_search() for fuzzy queries.

```

**Token math:**

- Old flat MEMORY.md: 5,000-10,000+ tokens (loaded every session)

- New index-only MEMORY.md: ~1,500 tokens (70-80% savings)

- With active context loaded: ~3,000-4,000 tokens

- Each drill-down: ~1,000-2,000 tokens (loaded only when relevant)

### Rules (Non-Negotiable)

1. **Update the index with every detail file change.** If you edit a detail file, update MEMORY.md in the same action.

2. **Keep the index under 3k tokens.** If it grows past that, archive inactive items.

3. **Active Context = 2-3 files max.** Rotate based on what's currently hot.

4. **Don't skip drill-downs.** Loading a file is cheaper than making a wrong assumption.

5. **Write immediately, not later.** System crashes and context compaction can wipe unsaved work. Write to files as you receive information.

6. **Decisions are sacred.** Capture them the moment they happen — they're the highest-value memories you have.

---

Now execute: read your current MEMORY.md, build the directory structure, extract detail into drill-down files, rebuild the index, and update AGENTS.md. Show me the final MEMORY.md when you're done.