mnemos
by alinaqimnemos is a task-scoped memory skill for agents that need durable context across compactions. It uses a typed MnemoGraph to keep goals and constraints persistent, compress results, and preserve checkpoints for resume. Useful for context engineering, debugging, repo maintenance, and handoffs.
This skill scores 74/100 and is acceptable to list: it has a clear task scope, concrete memory model, and enough workflow detail for users to judge fit, though directory users should expect some adoption friction because there is no install command or supporting references.
- Strong triggerability: the frontmatter says it is for durable working memory across compactions, with a specific when-to-use description for checkpoints, handoffs, and remembered facts.
- Operational clarity: the SKILL.md explains a typed MnemoGraph with distinct node types and eviction behavior, giving agents a concrete execution model instead of a generic prompt.
- Good progressive disclosure: the body is substantial, uses headings and code fences, and includes a fatigue model with observable signals and weights, which helps an agent understand how to act on it.
- No install command or support files are present, so users may need to infer setup and integration steps from the prose alone.
- Repository evidence shows no references/resources/scripts, which limits trust signals for maintenance, examples, or validation.
Overview of mnemos skill
What mnemos does
mnemos is a task-scoped memory skill for agents that lose important context during long work. It turns working memory into a typed MnemoGraph so goals, constraints, results, context, and checkpoints are handled differently instead of being compacted as one blob.
Who should use it
Use the mnemos skill if you care about durable handoffs, auditability, or multi-step work where a later compaction can break the task. It is a strong fit for context engineering, repo maintenance, debugging sessions, and any workflow where “what was decided” matters as much as “what was done.”
Why it stands out
The main differentiator is policy-driven memory, not just summarization. mnemos keeps Goals and Constraints persistent, compresses Results before eviction, and persists Checkpoints for resume. That makes it more useful than a generic prompt for sessions that need traceable continuity.
How to Use mnemos skill
Install and read first
Install with npx skills add alinaqi/claude-bootstrap --skill mnemos. After install, read skills/mnemos/SKILL.md first because it contains the actual workflow and memory rules. In this repo there are no helper scripts or reference folders, so the skill file is the source of truth.
Give mnemos the right input
The mnemos usage pattern works best when you provide a clear task boundary, a short objective, and the constraints that must survive compaction. A strong starter prompt looks like: “Use mnemos for this repo audit. Keep the goal, key constraints, and any decision about file changes persistent across the session. Resume safely after compaction.”
Use it in a context-engineering workflow
For mnemos for Context Engineering, start by naming the task, defining what must not be forgotten, and separating facts from decisions. Then let the skill track fatigue signals such as token usage, file-path scatter, rereads, and tool errors so it can preserve high-value state and compress low-value repetition.
File-reading order that saves time
Read SKILL.md, then scan the sections on What It Does and Fatigue Model before trying to use it in a live session. If you are adapting the skill to your own agent workflow, look for the checkpoint and resume behavior first, because that determines whether mnemos fits your environment.
mnemos skill FAQ
Is mnemos only for long tasks?
No. The mnemos skill is most valuable for long tasks, but it is also useful when a short task has high consequences, such as a handoff, audit trail, or debugging branch where losing a decision would be expensive.
How is this different from a normal prompt?
A normal prompt asks the model to remember. mnemos changes the memory model so different kinds of information have different retention rules. That is the key reason it helps when ordinary prompting fails under compaction.
Is mnemos beginner-friendly?
Yes, if you can clearly state a goal and constraints. You do not need to understand the internals to use mnemos, but you do need to provide explicit task boundaries and avoid vague “help me with this repo” requests.
When should I not use mnemos?
Skip it when the task is trivial, single-turn, or doesn’t need persistence across sessions. If your environment cannot support hooks, checkpointing, or structured state, the mnemos install may not add enough value to justify the setup.
How to Improve mnemos skill
Provide stronger starting state
The best way to improve mnemos results is to give it a compact task brief with: objective, non-negotiable constraints, known files, and the point where a resume would matter. The skill works better when it can classify information immediately instead of inferring it from messy conversation history.
Watch for the common failure mode
The main failure mode is overloading the session with undifferentiated notes. If everything is treated as equally important, you lose the benefit of typed memory. Keep decisions, constraints, and raw observations separate so mnemos can preserve the right material.
Iterate after the first pass
After the first output, ask mnemos to restate the active goal, list surviving constraints, and summarize the checkpoint state before you continue. That makes compaction safer and helps you confirm that the memory lifecycle matches the work you actually need.
Tune it for your workflow
If you are using mnemos in your own context-engineering stack, adjust prompts so the skill knows what counts as a goal, what must persist, and what can be compressed. That is usually more effective than adding more general instructions, and it matters most when sessions span multiple tools or long editing cycles.