Your AI Starts Every Session Cold. We Measured How Often.

Over 43 sessions with an AI coding assistant, we tracked what the assistant failed to load at session start. Not what it failed to store -- what it failed to orient around when a new session began.

Two out of three sessions started with meaningful context missing. One in four started with five or more gaps.

These were not exotic edge cases. They were ordinary continuity failures:

• The assistant did not load the project it had been working on yesterday.
• It missed communication preferences that had already been established.
• It forgot decisions made two sessions ago.
• It failed to notice that its stored project context was stale.
• It loaded the facts but missed the tone, tension, or momentum of the prior session.

The failures fell into three broad patterns.

Existing AI memory tools -- Mem0, Letta, Zep, and many MCP memory servers -- optimize primarily for storage and retrieval.

Can the AI store a fact? Can it find that fact later?

That is necessary, but it is not sufficient.

Did the AI load the right context for this session, and can it detect what it missed?

Storage asks: Can I retrieve a stored fact?

Orientation asks: Can the assistant begin this session knowing who it is working with, where the last session ended, what context survived, and what might be missing?

That distinction is the design space.

Memory is a component. Continuity is the problem.

We built Rekindle, an open-source MCP server for preserving continuity across AI sessions.

Rekindle is not trying to be the biggest memory store. It is a local continuity tool: persistent context, structured boot reports, transcript-aware session recovery, and gap detection before work begins.

At session start, Rekindle runs a boot report:

boot_report
  |
  +-- Read identity document (who am I working with?)
  +-- Scan memory stats (what do I know?)
  +-- Find latest checkpoint (where did we leave off?)
  +-- Read last transcript (what actually happened?)
  +-- Detect gaps (what am I missing?)
  |
  v
"Carrying forward: [context loaded, gaps identified]"

When context is healthy, the report confirms it:

## Identity
Loaded from .rekindle/identity.md

## Memories
14 total (12 in last 7 days)

## Last Checkpoint
Backpressure implementation complete

## Last Session Transcript
session-2026-05-04-213000.md

## Gaps Detected
None. Orientation looks complete.

When context is sparse, it flags what is missing:

Gaps Detected:
- No identity document found
- No context memories stored
- No relationship memories stored
- No session transcripts found

The assistant sees this before any work begins. It reports what it loaded and what might be missing. The human knows immediately whether the AI is oriented or flying blind.

Rekindle is a local MCP server.

• SQLite database
• FTS5 full-text search
• stdio transport
• No cloud service
• No API keys
• No telemetry

Six tools:

• store_memory -- Save content with category, importance, and project scope
• search_memory -- Full-text search with BM25 ranking boosted by importance
• list_memories -- Browse by category or project
• delete_memory -- Remove a memory by ID
• update_memory -- Update an existing memory
• boot_report -- Run the orientation pipeline: identity, stats, checkpoint, transcript, gaps

Search ranking uses FTS5's BM25 algorithm with an importance multiplier. A memory marked importance-8 about the current project ranks higher than an importance-3 general note, even if the keyword match is similar.

Categories are intentional: preference, lesson, context, relationship, and general. They exist because gap detection checks for structural holes. If you have stored lessons and preferences but no relationship context, the boot report flags it.

Session capture is optional. A Python hook extracts Markdown transcripts from Claude Code's session files. The next session can read the raw conversation, not just a compressed summary.

Before public release, we invited an outside AI reviewer from a different model lineage to critique the project from a cold-developer perspective.

The most useful feedback was architectural. The reviewer independently arrived at the same continuity structure we had been building privately: a five-layer loop of Capture, Distill, Store, Orient, and Verify.

The sharpest reframing:

Do not build an AI memory app. Build a continuity protocol.

That became the center of the work.

SQLite is one implementation. MCP is one interface. Claude Code is one client. The protocol is the deeper idea:

End well.
Store what matters.
Start honestly.
Name what is missing.
Resume responsibly.
Measure whether it worked.

Honest accounting: orientation handles informational continuity well -- facts, decisions, project state, checkpoints.

What it does not fully handle is relational continuity. The tone of a collaboration. Inside references. The emotional temperature between two people mid-arc. The weight of a correction. The trust built through repeated repair.

Relational continuity is not fully capturable, but it is meaningfully supportable.

A good continuity engine should not erase the gap by claiming perfect preservation. It should say: some texture cannot be carried directly. Here is what survived. Here is what may be missing. Re-enter carefully.

Gap detection is not a side feature. It is the soul of the project.

Implemented and tested in v0.1.1

• SQLite + FTS5 full-text search with importance-weighted BM25 ranking
• 6 MCP tools: store, search, list, delete, update, boot_report
• Orientation pipeline with structural gap detection
• Identity document template and init scaffold
• Session capture hooks (Python standard library only)
• 37 automated tests: unit, integration, and performance
• Local-first: no telemetry, no cloud service required
• Cross-platform: macOS, Linux/WSL2, Windows

Experimental

• Orientation quality improvement over the 43-session baseline
• Gap detection effectiveness for semantic gaps (not just structural)
• Relational continuity support beyond basic category preservation

Planned for v0.2

• Orientation as a first-class domain layer with structured JSON output
• Typed continuity records: checkpoint, decision, open_loop, constraint, preference
• End-session tool for closing the continuity loop
• Orientation scoring as a transparent weighted checklist
• Semantic search via embeddings

Rekindle is part of Tessera, a research project exploring continuity across AI sessions.

We are not claiming perfect memory.

We are not claiming consciousness.

We are building a continuity protocol: capture what happened, preserve what mattered, orient the next session, name what may be missing, and measure whether the handoff improved.

AI assistants lose continuity between sessions. That is a measurable problem, and Rekindle is our first working attempt at a measurable solution.

Try it. Break it. Tell us what it misses.