Save Context with CogmemAi

This skill captures the live conversation state into CogmemAi so it survives context compaction, the end of the session, or a switch to a different agent.

When to Use

Trigger on any of these signals:

• The user says "save context", "save this", "checkpoint", "write this down", "don't forget"
• The context window is approaching its limit and important facts risk being evicted
• About to run a destructive or expensive operation where losing the why would hurt
• A long planning or design discussion just produced decisions worth keeping
• Switching from one phase of work to another (e.g., planning to implementation)

How to Save Context

Pick the right tool for the volume of information:

Multi-fact context: extract_memories

When the conversation covers several distinct facts (decisions, preferences, constraints, file paths, bugs), call extract_memories once. It identifies and saves each fact with the right type, importance, and tags automatically.

Faster and more thorough than calling save_memory five times.

Single fact: save_memory

When there's one specific thing to capture, use save_memory with:

• content — one or two sentences, concrete and self-contained
• memory_type — pick from: architecture, decision, preference, bug, dependency, pattern, context, identity, session_summary, task, correction, reminder
• importance — 1-10 (see the cogmemai-memory skill for the scoring guide)
• scope — project (default) or global if the fact applies everywhere
• tags — short labels for grouping related memories

End-of-session wrap-up: save_session_summary

When wrapping up, call save_session_summary to capture what was accomplished, decisions made, and concrete next steps. The next session will see this immediately via get_project_context.

What to Save

Save:

• Architecture and tech stack decisions ("auth uses Supabase", "DB is PostgreSQL 15")
• User preferences ("never auto-commit", "always use Bun instead of npm")
• File paths and project structure that took effort to discover
• Bug fixes with non-obvious root causes
• Patterns and conventions used in the codebase
• Constraints from the user's environment, deadlines, or stakeholders

Do not save:

• The current task you're actively working on (use a task instead via save_task)
• Information already in CLAUDE.md or project docs
• Speculation from skimming a single file
• Duplicates of memories you already wrote this session

Concrete Examples

Before context compaction

The user has been deep in a debugging session. The conversation is 80k tokens and may compact soon. Call extract_memories to preserve the root cause, the fix, and the verification steps so the next session can pick up cleanly.

After a planning discussion

The user just decided to switch from REST to GraphQL for the new service. Call save_memory with:

• memory_type: "decision"
• importance: 9
• content: "API for the orders service uses GraphQL (decided 2026-05-13). Why: client needs nested resource fetching in one request to keep mobile latency under 200ms."

Switching from planning to implementation

Planning produced 4 decisions, 2 constraints, and a list of file paths to touch. Call extract_memories once to capture all of them, then start the implementation phase with the planning context preserved.

Why This Matters

CogmemAi memories survive everything that can erase your in-context knowledge:

• Context compaction inside the same conversation
• Session end and the next session start
• A handoff to a different model (Opus to Haiku, etc.)
• A new agent in a multi-agent workflow

Saving context is the single highest-leverage action you can take to prevent re-discovery work in the next session.

Related Skills

• cogmemai-memory — full reference for memory management
• session-start — load saved context at the start of a session
• remember-this — quick save when the user explicitly asks
• save-bugfix — specialized save for "we fixed this before" debugging memories