The Muse Skills: Session Memory for AI Pair Programmers (Evaluated)

Six skills from the MUSE governance system, evaluated this week on our six-dimension rubric. The top three score above 8.2. Here's what they do, how they compose, and the honest weak spot.

Every AI coding agent has the same embarrassing problem: it forgets everything when the session ends. The decisions you spent an hour explaining, the architecture you agreed on, the bug you were halfway through debugging — gone when you close the terminal.

MUSE (35★, MIT, 66 skills) is one of the most systematic attempts to fix this. "Memory-Unified Skills & Execution" — a pure-Markdown governance system that gives Codex and Claude Code persistent memory across sessions, explicit context economics, and search over everything the agent has ever decided. We evaluated the six skills that define the system's core identity.

1. MUSE Continuity Commands — 8.5/10

/resume, /save, /bye — the heartbeat.

Why: This is the skill that makes memory real. /save writes your session state — selected role, current Lane (MUSE's task-lane concept), decisions, and source evidence — to durable files. /resume restores it in a new session, in either Codex or Claude Code. /bye is the graceful shutdown that ensures nothing is lost. The dispatch-by-action structure reads only the workflow needed for the current command, and it ships with a continuity.json manifest plus scripts. At 24 files, it's the most heavily engineered skill in the family.

The one thing: It's coupled to MUSE's own file conventions. If you're not running the full system, the commands won't do much.

2. Layered Context Loading — 8.3/10

L0/L1/L2: load a summary first, escalate only when needed.

Why: The token-economics layer. On /resume boot, MUSE loads L0 — a ~10-line index of the project's current state — instead of replaying full history. L1 adds active file summaries and recent decisions. L2 is the full archive. The decision tree for when to upgrade from one layer to the next is directly actionable ("if the user references a specific past decision → load L1 for that domain"). Inspired by ByteDance's OpenViking L0/L1/L2 architecture, translated to plain Markdown.

The one thing: The L0 format requires discipline to maintain — the skill tells you how, but you have to actually do it.

3. Strategic Compact — 8.2/10

Manual /compact at logical boundaries instead of random auto-compaction mid-task.

Why: Claude Code's auto-compaction fires at arbitrary token thresholds — sometimes mid-phase, losing the thread. This skill suggests manual compaction at task boundaries, with focus-aware mode (derived from OpenClaw) that targets what to keep and what to drop. Ships with hook setup so it runs automatically in real sessions, plus pre-compaction checklists and post-compaction summary injection. Solves a real daily pain.

The one thing: The hooks need to be installed — it's not zero-setup.

4. MUSE Semantic Search — 8.1/10

Zero-dependency TF-IDF search across memory, roles, and skills.

Why: "Find that decision we made on Tuesday" — the skill does scoped search (memory / roles / skills / all) using TF-IDF over local files. No API keys, no embeddings, no vector database. Honest about what it is: grep plus math. For finding text in your own project's memory files, that's exactly right.

The one thing: TF-IDF is recall-oriented — it finds keyword matches, not semantic intent. Don't expect it to find "that thing about the database" if the exact word "database" isn't there.

5. Agent Protocol Spec — 7.9/10

Machine-readable role files for multi-agent coordination.

Why: Makes MUSE role files parseable by other agents — integration points, status queries, bloat checks. Inspired by MemOS (multi-agent isolation + sharing). Most useful when you're running multiple agents on one codebase and need them to share a governance layer.

The one thing: Spec-only; the ecosystem hasn't standardized on it yet, so you're mostly talking to yourself unless you build the other side.

6. Context Health Check — 7.4/10

Read the client's actual context metrics instead of guessing model limits.

Why: Small but principled: check real session context observations, reassess after compaction, don't force /bye or assume you know the model's window. The anti-guessing stance is right.

The one thing: Thin content; relies on MUSE runtime conventions more than in-file guidance.

How they compose

The system is a memory pipeline: /resume boots with layered-context (L0 index → escalate as needed) → context-health-check monitors real usage → strategic-compact fires at phase boundaries to keep the window healthy → semantic-search retrieves anything the layers didn't surface → /save persists it all for the next session. agent-protocol makes the whole thing readable to other agents.

The philosophy is governance, not magic: MUSE doesn't try to give the agent perfect recall — it gives the agent disciplined recall with explicit boundaries when source history is incomplete.

Scores at a glance

| Skill | Overall | Trigger | Structure | Workflow | Content | Engineering | Security |

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

| muse-commands | 8.5 | 8.5 | 9 | 8.5 | 8.5 | 8.5 | 8 |

| layered-context | 8.3 | 8 | 9 | 8.5 | 9 | 7.5 | 8 |

| strategic-compact | 8.2 | 7.5 | 9 | 8.5 | 8.5 | 8 | 8 |

| semantic-search | 8.1 | 8 | 8.5 | 8.5 | 8 | 7.5 | 8 |

| agent-protocol | 7.9 | 7 | 8.5 | 7.5 | 8.5 | 8 | 8 |

| context-health-check | 7.4 | 7 | 7 | 8.5 | 7 | 7 | 8 |

The honest weak spot: coupling. These skills assume the MUSE file conventions (roles, Lanes, L0 index, memory directory). If you install them standalone without the system, the continuity commands won't find anything to resume. That's not a flaw — it's the price of a coherent architecture — but know what you're installing.

Install

All six are one-line installs:

curl -fsSL https://skill123.me/install/muse-commands.sh | bash
curl -fsSL https://skill123.me/install/layered-context.sh | bash
curl -fsSL https://skill123.me/install/strategic-compact.sh | bash
curl -fsSL https://skill123.me/install/semantic-search.sh | bash
curl -fsSL https://skill123.me/install/agent-protocol.sh | bash
curl -fsSL https://skill123.me/install/context-health-check.sh | bash

Or give this to your AI assistant:

Install the following 6 skills by visiting each URL below and following its installation instructions:

- https://skill123.me/install/muse-commands
- https://skill123.me/install/layered-context
- https://skill123.me/install/strategic-compact
- https://skill123.me/install/semantic-search
- https://skill123.me/install/agent-protocol
- https://skill123.me/install/context-health-check

If you only try one, make it strategic-compact — it works standalone (no MUSE conventions needed), solves the most common Claude Code frustration, and takes two minutes to set up.