Skip to main content
Employee Resources

Memory

Understand personal, project, and @Waker chat memory, then inspect, edit, and restore Waker memory.

Memory preserves role preferences, project conventions, and long-term knowledge that remains useful across tasks. It is not a full chat archive and must not contain one-off instructions, passwords, tokens, cookies, or customer-private data.

Choose the correct scope first

ScopeStoreApplies to
Personal memoryLong-term role, output preferences, and general rulesFuture relevant tasks for this Waker
Project memoryRepository structure, project conventions, test commands, and stable contextTasks using that project or directory
Group shared memoryConfirmed facts and conventions everyone in the group should reuseThe current enabled @Waker group chat
Member memoryOne member's role, preferences, and collaboration habitsThat member in the current group
Direct-chat memoryLong-term context specific to a member's bot chatThe current @Waker direct chat
Personal and project memory are managed on this page. Group shared, member, and direct-chat memory are managed from the corresponding @Waker chat. Topics summarize a discussion or task context; they are not long-term memory. See @Waker. A practical test: if a new task will still need the information several weeks from now, it may belong in memory. If it is only needed for this request, keep it in the task or topic.

Open Memory

Path: Waker Management → target Waker → Memory & Learning → Memory. View Full Memory on the Waker home page opens the same page.
Inspect Waker memory
The page shows the current scope, last update, category cards, timeline, and version controls. If a project selector is available, verify whether you are viewing personal memory or a project. Archive an ended project when its memory must be retained. A new Waker may show only its initial role profile or an empty state. Completing one task does not guarantee a new memory; the information must be useful beyond that task.

Decide what belongs in memory

AppropriateNot appropriate
Stable responsibilities, preferences, and testable rulesInstructions that apply only to the current task
Project conventions reused by many tasksOne-off dates, people, or version details
Confirmed group collaboration decisionsUnverified assumptions or raw chat transcripts
Verified operating rules and risk boundariesPasswords, tokens, cookies, and private customer data
Store each rule at the narrowest useful scope. Do not turn a project rule into a personal default or a member preference into a group-wide fact.

Inspect and edit memory

  1. Confirm the Waker and scope at the top of the page.
  2. Open a category card and inspect its source and update time.
  3. Edit the content using concise Markdown.
  4. Remove one-off, expired, duplicated, or unverified statements.
  5. Save, then check the timeline for the edit.
  6. Start a new task that clearly tests the rule.
Prefer instructions that can be observed. “Run tests relevant to the changed code” is more reliable than “care about quality.” Test project memory inside that project. Test personal memory in a new task without repeating the expected rule in the message; current instructions may override memory.

Edit the complete MEMORY.md

Use Edit Full File in version management when categories must be reorganized or conflicts resolved. Confirm whether the current scope is personal or project memory and record the current version first. Headings affect category display. Do not remove the main structure casually. If the page reports a conflict, load the latest version, compare changes, and merge intentionally.

Use the timeline

  1. Select a date range and, when useful, a source filter.
  2. Find events before and after a behavior change.
  3. Open an event and verify its scope, category, and source.
  4. Edit the correct scope or restore a version when the change is wrong.
Automatically learned content still needs review. A system source does not guarantee that a statement is accurate or appropriate for long-term use.

Use version management

  1. Open version management and confirm the current scope.
  2. Select a version and inspect its time, source, and complete content.
  3. Compare it with the current version.
  4. Restore it, then recheck categories and update time.
  5. Validate important rules with a new task.
A restore replaces the complete MEMORY.md for that scope, not one item. For a small correction, editing the category is usually safer.

Maintain @Waker chat memory

Open @Waker → enabled chat → Memory:
  • Group chats expose group shared memory and member memory. Filter by member, time, or source before editing.
  • Direct chats maintain memory only for that member and bot chat.
  • Topics organize summarized discussion and task context. Confirm any conclusion before promoting it to long-term memory.
  • Before pausing or removing a chat, move durable conclusions to a team-accessible project or knowledge base.
A normal chat message is not automatically a reliable rule. Confirm facts and scope before preserving ownership, customer details, or business policy.

Routine maintenance

  • Remove one-off dates, people, versions, and obsolete paths.
  • Merge duplicate rules.
  • Check for conflicts between personal, project, and chat memory.
  • Review automatically learned content.
  • Remove credentials, personal data, and information that should not persist.
When a role changes substantially, update the role configuration first, then clean up obsolete memory. Memory does not replace role files, permissions, knowledge bases, or resources.

Troubleshooting

SymptomResolution
A new Waker has no memoryComplete useful tasks or add an immediately required stable rule manually
A rule is ignoredCheck scope, save state, role conflicts, and current instructions; test in a new task
A project rule affects other projectsMove it from personal memory to project memory
A member preference affects everyoneMove it from group shared memory to member memory
An obsolete rule is still usedLocate its source in the timeline, then edit or restore that scope
A save conflict appearsLoad the latest content and merge the difference
A restore seems ineffectiveRefresh the same scope and start a new task
Categories look wrongCheck the current MEMORY.md heading structure and save a corrected version
Done when: the information is stored at the correct scope, changes can be traced and restored, and new tasks follow the intended rule without affecting unrelated work.