I run a directory where every agent skill gets a six-dimension rating. This week I evaluated the MUSE family — six skills that give AI coding agents persistent memory across sessions. 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.
I evaluated the six skills that define the system's core. Here they are, best first.
1. MUSE Continuity Commands — 8.5/10
/resume, /save, /bye — the heartbeat.
/save writes your session state — selected role, current task Lane, decisions, and source evidence — to durable files. /resume restores it in a new session, in either Codex or Claude Code. The dispatch-by-action structure reads only the workflow needed for the current command. At 24 files with a continuity manifest and scripts, it's the most heavily engineered skill in the family.
The one thing: coupled to MUSE's own file conventions. If you're not running the full system, the commands won't find anything to resume.
2. Layered Context Loading — 8.3/10
L0/L1/L2: load a summary first, escalate only when needed.
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 is directly actionable. Inspired by ByteDance's OpenViking L0/L1/L2 architecture, translated to plain Markdown.
The one thing: the L0 index 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.
Claude Code's auto-compaction fires at arbitrary token thresholds — sometimes mid-phase, losing the thread. This skill suggests compaction at task boundaries, with focus-aware mode that targets what to keep. Ships with hook setup so it runs automatically, plus pre-compaction checklists and post-compaction summary injection.
The one thing: the hooks need to be installed — it's not zero-setup. But it works standalone, without the rest of MUSE, which makes it the easiest entry point.
4. MUSE Semantic Search — 8.1/10
Zero-dependency TF-IDF search across memory, roles, and skills.
"Find that decision we made on Tuesday" — scoped search 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 finds keyword matches, not semantic intent.
5. Agent Protocol Spec — 7.9/10
Machine-readable role files for multi-agent coordination.
Makes MUSE role files parseable by other agents — integration points, status queries, bloat checks. Inspired by MemOS multi-agent memory isolation. Most useful when running multiple agents on one codebase.
The one thing: spec-only; the ecosystem hasn't standardized on it yet.
6. Context Health Check — 7.4/10
Read the client's actual context metrics instead of guessing model limits.
Small but principled: check real session context observations, reassess after compaction, don't force /bye or assume you know the model's window.
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.
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.
| 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 MUSE's file conventions. Install them standalone without the system and the continuity commands won't do much. That's the price of a coherent architecture — but know what you're installing.
Install
curl -fsSL https://skill123.me/install/strategic-compact.sh | bash
If you only try one, make it strategic-compact — it works standalone, solves the most common Claude Code frustration (auto-compaction firing mid-task), and takes two minutes to set up. The full system is six one-line installs.
Full scorecards and rationale for each skill are on skill123.me/topic/muse.
Top comments (1)
The design choice I'd highlight isn't any single skill — it's the token economics. layered-context loads a ~10-line L0 index on resume instead of full history, and only escalates when a decision tree says to. That's the difference between a memory system that burns your window on startup and one that stays useful for actual work.
We measured it: the full MUSE family keeps L0 under 10 lines with a bloat check that warns when it grows. The discipline is in the constraints, not the cleverness.
If you've used Claude Code's auto-compact mid-task and lost the thread — strategic-compact alone is worth two minutes to set up. It's the one skill in the family that works fully standalone.
What's your current approach to session continuity — replay history, manual summaries, or just starting fresh?