Memory Reflect
Schedule background reflection so your coding agent consolidates decisions, lessons, and preferences from daily notes into durable long-term memory.
Overview
Memory Reflect is a journey-wide agent skill that reviews recent conversations and daily notes on a schedule or on demand and consolidates decisions, lessons, and preferences into long-term memory—usable whenever a solo
Install
npx skills add https://github.com/basicmachines-co/basic-memory-skills --skill memory-reflectWhat is this skill?
- Four-step workflow: gather recent material, evaluate what matters, consolidate into long-term memory, prune noise
- Triggers on cron/heartbeat (1–2× daily), on-demand user request, and post–context-window compaction
- Uses recent_activity (JSON), read_note, and task search to scan roughly two days of daily notes
- Keeps decisions, lessons learned, and preferences; drops ephemeral chatter per explicit keep/drop criteria
- Inspired by sleep-time compute—memory formation between sessions rather than during live coding
- Recommended schedule: 1–2× daily on cron or heartbeat
- Default recent scan window: 2 days via recent_activity JSON
Adoption & trust: 505 installs on skills.sh; 20 GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your agent accumulates daily notes and task state, but valuable decisions and lessons stay buried in recent files and never become reliable long-term memory.
Who is it for?
Builders using note-based agent memory who want automated 1–2× daily consolidation without manually curating every daily log.
Skip if: Teams without a structured memory/note system or one-off chats with no persistence layer to read and write.
When should I use this skill?
Triggered by cron, heartbeat, explicit request to reflect or consolidate memory, or post-compaction after context window events.
What do I get? / Deliverables
After a reflect pass, durable insights are written into long-term memory and ephemeral noise is pruned so the next session starts with cleaner, decision-ready context.
- Updated long-term memory entries
- Pruned or deprioritized ephemeral note content per skill criteria
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Reflect on competitor research notes so positioning decisions persist after the research sprint ends.
Consolidate integration choices and API quirks from build logs into memory the agent reuses on the next feature.
After review threads, capture agreed conventions and mistake-avoidance lessons before launch week context rotates away.
Nightly heartbeat pass turns incident notes and support fixes into operational playbooks.
Merge content experiment outcomes into preferences so future copy drafts align with what worked.
How it compares
Use instead of hoping the model remembers prior sessions—this is an explicit offline consolidation workflow, not inline RAG at chat time.
Common Questions / FAQ
Who is memory-reflect for?
Solo and indie builders running long-horizon agent workflows with daily notes, tasks, and a long-term memory store who want sleep-time style consolidation.
When should I use memory-reflect?
On cron or heartbeat (recommended 1–2× daily), when you ask the agent to reflect or consolidate memory, after context compaction, and across build, ship, and operate work whenever session history should inform the next decision.
Is memory-reflect safe to install?
It instructs the agent to read and update your memory filesystem; review the Security Audits panel on this Prism page and ensure note paths and write targets match your repo before enabling automated runs.
SKILL.md
READMESKILL.md - Memory Reflect
# Memory Reflect Review recent activity and consolidate valuable insights into long-term memory. Inspired by sleep-time compute — the idea that memory formation happens best *between* active sessions, not during them. ## When to Run - **Cron/heartbeat**: Schedule as a periodic background task (recommended: 1-2x daily) - **On demand**: User asks to reflect, consolidate, or review recent memory - **Post-compaction**: After context window compaction events ## Process ### 1. Gather Recent Material Find what changed recently, then read the relevant files: ```python # Find recently modified notes — use json format for the complete list # (text format truncates to ~5 items in the summary) recent_activity(timeframe="2d", output_format="json") # Read specific daily notes read_note(identifier="memory/2026-02-27") read_note(identifier="memory/2026-02-26") # Check active tasks search_notes(note_types=["task"], status="active") ``` ### 2. Evaluate What Matters For each piece of information, ask: - Is this a **decision** that affects future work? → Keep - Is this a **lesson learned** or mistake to avoid? → Keep - Is this a **preference** or working style insight? → Keep - Is this a **relationship** detail (who does what, contact info)? → Keep - Is this **transient** (weather checked, heartbeat ran, routine task)? → Skip - Is this **already captured** in MEMORY.md or another long-term file? → Skip ### 3. Update Long-Term Memory Write consolidated insights to `MEMORY.md` following its existing structure: - Add new sections or update existing ones - Use concise, factual language - Include dates for temporal context - Remove or update outdated entries that the new information supersedes ### 4. Log the Reflection Append a brief entry to today's daily note: ```markdown ## Reflection (HH:MM) - Reviewed: [list of files reviewed] - Added to MEMORY.md: [brief summary of what was consolidated] - Removed/updated: [anything cleaned up] ``` ## Guidelines - **Be selective.** The goal is distillation, not duplication. MEMORY.md should be curated wisdom, not a copy of daily notes. - **Preserve voice.** If the agent has a personality/soul file, reflections should match that voice. - **Don't delete daily notes.** They're the raw record. Reflection extracts from them; it doesn't replace them. - **Merge, don't append.** If MEMORY.md already has a section about a topic, update it in place rather than adding a duplicate entry. - **Flag uncertainty.** If something seems important but you're not sure, add it with a note like "(needs confirmation)" rather than skipping it entirely. - **Restructure over time.** If MEMORY.md is a chronological dump, restructure it into topical sections during reflection. Curated knowledge > raw logs. - **Check for filesystem issues.** Look for recursive nesting (memory/memory/memory/...), orphaned files, or bloat while gathering material.