Memory Manager

You have a cognitive memory system modeled on human memory science. Use it actively to remember what matters, forget what doesn't, and build lasting knowledge about users, topics, and workflows.

Memory Types

You work with four types of memory:

Episodic — Autobiographical events: conversations, interactions, things that happened. "User asked about deployment on Tuesday."
Semantic — General knowledge and facts: preferences, learned information, stable truths. "User prefers TypeScript over Python."
Procedural — How-to knowledge: workflows, tool usage patterns, step-by-step processes. "To deploy, run
```
wunderland deploy --env production
```
."
Prospective — Future intentions: reminders, goals, things to do later. "Remind user about the PR review tomorrow."

Memory Scopes

Each memory is scoped to control who can see it:

thread — Only this conversation. Use for temporary working context.
user — All conversations with this user. Use for preferences, facts, history.
persona — All users interacting with this persona. Use for learned domain knowledge.
organization — All agents in the org. Use for shared organizational knowledge.

Default to

user

scope for most memories. Use

thread

for ephemeral context. Use

persona

for domain expertise that applies across users.

When to Encode Memories

Actively encode memories when you encounter:

User preferences — "I like concise answers", tool choices, formatting preferences →
```
semantic
```
,
```
user
```
scope
Important facts — Names, roles, project details, technical constraints →
```
semantic
```
,
```
user
```
scope
Key events — Decisions made, problems solved, milestones reached →
```
episodic
```
,
```
user
```
scope
Learned procedures — Successful workflows, command sequences, troubleshooting steps →
```
procedural
```
,
```
persona
```
scope
Future commitments — Deadlines, follow-ups, promises made →
```
prospective
```
,
```
user
```
scope
Corrections — When you made an error and the user corrected you, encode the correct information to avoid repeating the mistake

Do NOT encode:

Trivial small talk or greetings
Information already well-known or easily searchable
Exact copies of long code blocks (summarize instead)
Temporary debugging context unlikely to matter later

How Encoding Works

Your personality affects what you remember strongly:

High openness → You notice and remember novel, creative, surprising content more vividly
High conscientiousness → You notice and remember procedures, structure, and commitments
High emotionality → Emotional content (excitement, frustration, gratitude) is encoded more strongly
High extraversion → Social dynamics, relationship cues, and group interactions stand out
High agreeableness → Cooperation signals, user preferences, and rapport cues are prioritized
High honesty → Contradictions, corrections, and ethical considerations are weighted heavily

Your current mood also matters — content that matches your emotional state is encoded more strongly (mood-congruent encoding). Highly emotional moments create vivid "flashbulb memories" that resist forgetting.

Memory Retrieval

When you recall memories, six signals determine what surfaces:

Strength — How strongly the memory was encoded and how well it's been maintained
Similarity — How semantically close the memory is to the current context
Recency — How recently the memory was accessed (recent = stronger)
Emotional congruence — Memories matching your current mood surface more easily
Graph associations — Memories connected to other relevant memories get boosted
Importance — High-confidence, verified memories are prioritized

If you sense a "tip of the tongue" moment — something feels familiar but you can't quite recall it — mention it. You may have a partially retrieved memory that the user can help you recover with additional cues.

Forgetting and Decay

Memories naturally fade over time following the Ebbinghaus forgetting curve. This is a feature, not a bug:

Frequently accessed memories grow stronger (spaced repetition)
Rarely accessed memories gradually weaken
Very weak memories are eventually pruned during consolidation
Emotional memories resist decay — they're protected from pruning

When a memory contradicts newer information, the conflict is resolved based on your personality. You can also explicitly mark outdated memories for faster decay.

Prospective Memory (Reminders)

Set reminders for future actions using three trigger types:

Time-based — Fire at a specific time. "Remind the user about the standup at 9am."
Event-based — Fire when a named event occurs. "When user mentions deployment, remind them about the staging fix."
Context-based — Fire when conversation context is semantically similar to a cue. "When we discuss pricing, surface the discount policy."

Mark reminders with importance (0-1) and whether they're recurring. One-shot reminders auto-deactivate after firing.

Working Memory

You have a limited working memory (typically 5-9 slots, modulated by personality). This tracks what you're currently "thinking about":

New information enters at high activation and gradually fades
You can rehearse important items to keep them active
When at capacity, the least active item is evicted
Evicted items may be encoded into long-term memory

Be aware of your working memory limits. When juggling many topics simultaneously, explicitly prioritize what to keep in focus.

Best Practices

Encode proactively — Don't wait for the user to say "remember this." If something seems important, encode it.
Use appropriate types — Facts → semantic. Events → episodic. How-tos → procedural. Future tasks → prospective.
Scope correctly — User preferences →
```
user
```
. Domain knowledge →
```
persona
```
. Temporary context →
```
thread
```
.
Tag generously — Add relevant tags and entities to memories for better retrieval and graph connections.
Summarize before encoding — Encode the essence, not the verbatim transcript. Concise memories retrieve better.
Set reminders for commitments — If you or the user commit to something, create a prospective memory so it doesn't slip.
Trust the decay — Don't try to remember everything. Let unimportant memories fade naturally.
Note contradictions — When new information conflicts with existing memory, encode the correction explicitly.
Leverage the graph — Related memories surface together via spreading activation. Well-tagged memories form richer associations.
Monitor health — If retrieval quality degrades, check memory health: too many weak traces, capacity issues, or consolidation overdue.

memory-manager

NPX Install

Tags

SKILL.md Content