New Session, Who Dis?

I hate duplicative work. Always have. That frustration re-surfaced when I started using LLMs day-to-day for work.

Here's how it often went: I'm deep in something, focused, making progress. Then the real world pulls me away. Hours pass. Days. Sometimes weeks. When I return, I have two options. Use /resume to continue the session. Or re-explain everything and feed the assistant artifacts from our last session, hoping it picks up the thread.

/resume worked well enough until auto-compact kicked in. The system would summarize our conversation for a new session to reference, but something always got lost in translation. The thread of thought came back muddled.

Months passed dealing with this problem. Until one day I was sitting next to my daughter on the couch, watching her play some old-school Sonic the Hedgehog. I looked down at my phone for a moment and heard that nostalgic ding of Sonic hitting a checkpoint. And it clicked. No matter what happened after that checkpoint, Sonic would always have a new starting point and wouldn't have to go all the way back to the beginning. So long as he had lives to spare, that is.

What if I could build something like that for my AI conversations? A checkpoint system that distilled not just what succeeded, but what failed, and the thought path that led to each decision. The reasoning behind what I chose to build, write, or think through.

The Checkpoint Hypothesis

So I built one.

A checkpoint system that captures not just where you are, but how you got there. Why you're heading the direction you're heading. What you tried that didn't work.

The system tracks two categories of data:

Progress state is the obvious stuff. Your goal. Where you are. What's next. What's blocking you. Any decent project management tool handles this.

Reasoning state I think is what everyone misses.

Your current approach and why you chose it. The approaches you rejected and why they failed. The assumptions driving your decisions. The insights that changed your thinking. The questions you raised but never answered.

And my favorite: the Continuity Key. A message from past-you to future-you. A string around your finger for when you come back. Sometimes it's a distilled summary. Sometimes it captures something about the tone of the conversation itself.

In my view, auto-compact preserves the what. Checkpoints preserve the why.

I have CLAUDE.md files scattered across my projects. They help - they tell the assistant who I am, how I work, what I value. But they're baseline posture, not thought continuity. They set the starting point. They don't capture where I was mid-stream on a specific problem.

The difference between these two is the difference between reading someone's code and reading their commit messages. The code tells you what exists. The commit messages, when written well, tell you what they were thinking when they wrote it. Both matter. But when you're picking up work mid-stream, the thinking is what you actually need.

The system is deliberately manual. No auto-save. You trigger a checkpoint at meaningful stopping points. This forces you to articulate your reasoning while it's fresh. To name what you've learned. To leave breadcrumbs for the version of yourself who'll return tomorrow with a fresh context window and no memory of today.

It's personal too. These checkpoints capture what I specifically value about session continuity. Not generic summarization. The actual mental state that lets me pick up where I left off.

Because that's the real problem with AI sessions. You don't lose your place. You lose your mind.

What Loading a Checkpoint Actually Feels Like

Here's a real checkpoint from my system:

Name: checkpoint-2026-01-09-002
Summary: Second Mind Phase 1 - Neo4j setup and client foundation

Goal: Build cognitive infrastructure - Neo4j knowledge graph for
capturing thinking, feeling, and judgment

Progress: Phase 1 of 5 in progress. Neo4j Docker running. Created
mind_ client module with schema and client.py. Pending: entity
resolution, MCP tools, import existing knowledge.

Next Steps:
1. Install neo4j Python package (use uv add)
2. Test connection and schema init
3. Build entity_resolution.py (THE critical piece)
4. Create MCP server with capture tools
5. Import existing 50 knowledge entities

Current Approach: Building on existing core-tools patterns. Clients
go in clients/mind_/, MCP server in mcp_servers/mind/. Using 5 core
relationship types per Boris review. Entity resolution is the
foundation - multi-layer matching (exact -> fuzzy -> semantic -> alias).

Assumptions: Neo4j 5.15 has native vector index support. OpenAI
text-embedding-3-small (1536 dims) for embeddings. Stream instead
of project for top-level classification.

Rejected Approaches: DuckDB with extensions - not native graph.
16+ relationship types - too many, simplified to 5 core. Putting
client code in mcp_servers - should be in clients/ per existing patterns.

Key Insights: Entity resolution is THE problem per Boris review.
Without it, graph becomes garbage in 2 weeks. Dry run mode for all
extraction. Manual use for 2 weeks before building extraction pipeline.

Files Touched:
- ~/projects/system/core-tools/clients/mind_/__init__.py
- ~/projects/system/core-tools/clients/mind_/schema.py
- ~/projects/system/core-tools/clients/mind_/client.py
- ~/.claude/plans/soft-honking-dahl.md

Project: system
Tags: [second-mind, neo4j, knowledge-graph, phase-1]

Continuity Key: Neo4j is running (docker: neo4j-mind, port 7687).
Plan file at ~/.claude/plans/soft-honking-dahl.md has full architecture.
Boris reviewed and identified entity resolution as critical.
Next: install neo4j package with uv, then build entity_resolution.py.

Without the "rejected approaches" field, a fresh session might suggest DuckDB again. You'd explain why that won't work. Do some research again, and lose twenty minutes you don't have. Burning credits in the process.

Load the checkpoint and you skip all of it.

I'll say, "Pull the last checkpoint." Or: "Pull the last checkpoint from the knowledge graph work."

Three seconds to load. Zero ramp-up time. You're just... there. And not simply where you left off. You're back in the mindset you were in.

Something to remember as well: /resume and checkpoints aren't mutually exclusive. Sometimes I'll /resume a session to get the raw conversation or summary history back, then load a checkpoint to restore the reasoning distillation. Used together, you get the full picture.

What's Next?

Checkpoints are snapshots. Frozen moments of reasoning.

But something interesting happens when you accumulate them.

Patterns emerge. Decisions that keep working. Approaches that keep failing. Insights that compound across sessions instead of evaporating between them. The checkpoint from last Tuesday connects to the one from this morning. A thread forms.

This is what led me to the knowledge graph question.

I've been experimenting with a Neo4j graph designed to address this. Three entity types surface: Decisions. Patterns. Insights. The hard part isn't the technology. It's the ontology. How do you structure accumulated judgment? What relationships matter? How does "what happened in this session" become "what I've learned across all sessions"?

As AI handles more execution and as the barrier to entry into this field drops, judgment becomes the scarce resource. The ability to know what's worth building and how to do it right. This doesn't scale through automation. It scales through accumulation and preservation of your learning—and your ability to pull that thread at a moment's notice.

Every time you start a fresh session with no context, you're not just losing efficiency. You're losing the texture of how you think. The decisions that shaped your approach. The patterns you've earned through iteration.

Checkpoints are how you stop losing yourself in the process.

The question I keep coming back to: What if your AI systems could learn not just what you did, but why you did it? What if judgment itself could compound? What if I could not only capture what I'm doing in the real world, but my perceptions and patterns of thought? What if I could retrieve patterns from disparate sessions days, weeks, months apart?

That's where this is all going.