MemNexus
GuidesWorkflows

Session Start Ritual

How to warm up your AI at the start of each session so it walks in knowing what matters — instead of starting cold.

Every AI session starts cold. The model has no memory of what you worked on yesterday, what decisions you've made, or what you've already tried. Without a warm-up step, you spend the first few minutes of every session re-establishing context that you've established dozens of times before.

The session start ritual fixes this. It takes about 30 seconds and means your AI walks into each session knowing what it needs to know.

The basic ritual

The core pattern is: before you start working, load relevant context.

# See what you worked on recently
mx memories recap --recent 24h

# Get synthesized context on what you're about to work on
mx memories digest --query "payments service" --digest-format structured

Run these at the start of a session, read them, and share the output with your AI assistant. Now it knows your recent history and the current state of what you're working on.

If you're using Claude Code with MCP, the AI can run these commands itself. Tell it: "Search MemNexus for context on what we've been working on before we start."

Tailoring the ritual to your situation

Resuming interrupted work

You were in the middle of something yesterday and picking it up now:

# See exactly where you left off
mx memories recap --recent 24h

# Find any notes you left for yourself
mx memories search --query "next steps TODO" --recent 48h --brief

Starting work on a feature area you haven't touched in a while

# Get the synthesized state of this area
mx memories digest --query "auth service" --digest-format structured

# Find gotchas and patterns from previous work
mx memories search --query "auth service" --topics "gotcha,decision" --brief

Starting a debugging session

# Look for similar issues you've seen before
mx memories search --query "symptoms you're seeing" --timeline

# Check if this is a known pattern
mx memories search --query "error message or component name" --mode facts

Starting work on someone else's code (or code you didn't write)

# Get the architectural context
mx memories digest --query "service or feature name" --digest-format structured

# Find any known quirks or non-obvious patterns
mx memories search --query "service name gotcha pattern" --brief

Automating it with Claude Code

If you use Claude Code, you can automate the session start ritual by adding instructions to your CLAUDE.md file:

## Session start

At the start of every session, run the following before doing anything else:

1. `mx memories recap --recent 24h` — see recent work
2. `mx memories search --query "[current project]" --timeline --recent 7d` — load project context

Share the output as context before we begin.

This means every session with Claude Code automatically starts with your memories loaded. You don't have to remember to ask.

For teams using a shared workspace, the session start ritual surfaces work from your whole team — not just your own. If a teammate found a root cause yesterday, it's in the memory store, and your session starts knowing about it.

Saving context at session end

The ritual works both ways. At the end of a session, spend 60 seconds capturing what happened:

# Save where you are and what's next
mx memories create \
  --conversation-id "conv_current" \
  --content "Pausing work on rate limiting feature. Middleware is in place and passing unit tests. Next: integration tests against the staging Redis instance. Known issue: the connection pool config needs to be revisited — current 20-connection limit may be too low under load." \
  --topics "rate-limiting,in-progress"

When you pick this up tomorrow, recap --recent 24h returns exactly this. Your next session starts knowing where you left off.

What to include in the warm-up

The warm-up is most useful when it covers:

  • What you're about to work on — so the AI has domain context going in
  • Recent relevant decisions — so it doesn't suggest approaches you've already ruled out
  • Known gotchas in this area — so it doesn't repeat known mistakes
  • Where you left off — if you're resuming interrupted work

You don't need to load everything. A focused query on what you're actually working on today is better than a broad dump of everything in the last week.

A real example

Here's what a session start looks like in practice. You're picking up work on a feature after a weekend:

You: "Before we start, search MemNexus for context on the billing integration work."

Claude Code runs:

mx memories recap --recent 48h
mx memories digest --query "billing integration" --digest-format structured

Output includes:

  • Last session summary: you got the webhook handler working, left off on the refund flow
  • Architecture decision: you're using idempotency keys on all Stripe calls because of a previous duplicate-charge incident
  • Known gotcha: the Stripe test mode webhook signature verification is stricter than production — you need to use the CLI-forwarded events for local testing
  • Next steps you saved: implement POST /refunds, write integration tests against test mode

Now the session starts with all of that loaded. You don't re-explain the idempotency key decision. You don't re-discover the webhook signature issue. You don't spend five minutes figuring out where you were.

That's the ritual. It's worth the 30 seconds.

Next steps

recap vs digest vs search

When to use each retrieval method — and how to combine them for different situations.

Team Workflows

How to use shared memory as a team — handoffs, standups, onboarding, and keeping context from disappearing when people switch tasks.

On this page

The basic ritualTailoring the ritual to your situationResuming interrupted workStarting work on a feature area you haven't touched in a whileStarting a debugging sessionStarting work on someone else's code (or code you didn't write)Automating it with Claude CodeSaving context at session endWhat to include in the warm-upA real exampleNext steps