You have been heads-down on a data pipeline for three days. Yesterday's Claude session was productive -- you worked through the partitioning strategy, settled on a watermark approach, and got a solid draft of the incremental load logic. Good session.
Today you open a new session. "Let me help you! What are you working on?"
It knows nothing. You spend the next five minutes re-explaining the project, the constraints, what was decided, what was tried last week. Then you can actually start working.
This is the ephemeral session problem. If you use AI assistants for serious technical work, you feel it every single day.
The Hidden Cost
The re-explanation tax sounds minor until you add it up. Five to ten minutes of context rebuild at the start of each session, every day, across a month of project work. More than the time, it is cognitive overhead: remembering what you decided, what you rejected, where you left off. The AI cannot pick up where you left off because it has no memory of where that was.
But there is a subtler cost: token burn. Every piece of context you paste into a new session -- architecture docs, previous decisions, schema snippets -- consumes tokens before you write a single line of useful code. Across a month of active work, this adds up to hundreds of thousands of tokens that buy you nothing new.
We measured this on our own projects at Labyrinth Analytics. Before LoreConvo, a typical active project consumed roughly 440,000 tokens per month in re-explaining context that had already been established in prior sessions. That is money left on the table, plus the daily frustration of starting from zero.
Why Sessions Start With Amnesia
Claude -- and most LLM-powered tools -- operates statelessly by design. Each session is a clean slate. This is actually a feature: no leakage between unrelated conversations, no privacy concerns from one project bleeding into another. But it creates a fundamental usability problem for any ongoing technical work.
The partial solutions people reach for all have real limitations:
Pasting context manually. You keep a "project brief" doc and paste it at the start of every session. Works, but it is manual, gets stale fast, and eats a significant chunk of your context window before you type a single question.
Keeping long sessions alive. You try to stretch a single session across multiple days. This breaks down because sessions have limits, because you need to switch contexts, and because you cannot always predict when you will need to resume.
Custom instructions. Static global instructions handle preferences and tone well but cannot capture project-specific decisions, architecture choices, what you tried last Thursday, or what open questions are still unresolved.
None of these actually solve the problem. They are workarounds that require discipline to maintain and fail at exactly the moments when you are too busy to maintain them.
What LoreConvo Does Differently
LoreConvo is a Claude plugin that gives your sessions persistent memory -- automatically, without changing how you work.
The architecture is built around two hooks that run at session boundaries.
SessionEnd hook (auto-save): When a session closes, LoreConvo reads the transcript and extracts what matters -- decisions made, artifacts created, open questions left unresolved, the surface used (Code vs Cowork), the working directory. It distills this into a session record and writes it to a local SQLite database on your machine. You do not write anything. You do not copy anything. You just close your session.
SessionStart hook (auto-load): When you open a new session, LoreConvo queries recent session records for the current project directory. It scores each session by signal quality: sessions with open questions get the highest weight (most actionable), recent decisions get strong weight, artifacts get a bump, and sessions from the last 24 hours get a recency bonus. The top-scored sessions are summarized and injected into your context automatically before you type a single message.
The result: Claude already knows where you left off. No pasting. No explaining. You start working immediately.
A Concrete Example
Here is the kind of context LoreConvo auto-loads at session start for an active pipeline project:
[LoreConvo] Recent project context (3 sessions, past 72 hours)
Session: Data pipeline partitioning strategy (2 days ago)
Decisions: Use watermark-based incremental load over partition key;
watermark col is updated_at with UTC normalization
Open questions: How to handle rows with NULL updated_at?
Options: exclude, default to epoch, or separate full-load pass
Session: Incremental load implementation (yesterday)
Artifacts: staged_load_proc.sql (draft), watermark_tracker table DDL
Decisions: Watermark stored in control table, not config file -- survives deploy cycles
Open questions: Rate limit on source API not confirmed --
check with Farrukh before adding retry logic
When you open today's session, Claude reads this and already knows: watermark-based incremental load, control table architecture, open question about NULL rows, waiting on API rate limit confirmation. You start the conversation at "let's resolve the NULL updated_at question" instead of "so I am building a data pipeline and here is the context..."
The context window cost is a few hundred tokens. The information density is high because LoreConvo extracts signal, not verbatim transcript.
The Token Math
Sessions with rich context -- schemas, long explanations, decision threads -- often consume 20,000 to 50,000 tokens in context setup alone. If you rebuild that context three times a week across an active project, you are burning millions of tokens per year re-explaining things you already know.
LoreConvo auto-loads inject roughly 400 to 800 tokens of high-signal summary instead of 20,000 tokens of raw context paste. On our own projects, this reduced monthly context overhead from roughly 440,000 tokens to under 50,000. Same information, 10x fewer tokens.
For solo practitioners, the savings are real. For teams or agent workflows where sessions run continuously, the savings are significant.
Built for the Way Technical People Actually Work
LoreConvo is local-first. Your session data lives in a SQLite database on your machine. Nothing goes to a third-party cloud service. No external system stores your code, architecture decisions, or project notes.
It works across Claude's surfaces. If you use Claude Code (the terminal-based developer tool) for implementation work and Cowork for reviews and planning, the session memory follows you across both. Switch surfaces mid-project and the context is still there.
It also works for agent teams. If you run autonomous agents -- nightly build bots, QA reviewers, automated security scanners -- each agent reads and writes to the shared session store. Agents do not re-explain the project state to each other. The QA agent knows what the builder did the night before before it starts its review. Coordination without meetings.
We use this exact setup at Labyrinth Analytics. Our autonomous agent team -- Ron (builder), Meg (QA), Brock (security), Jacqueline (PM), Madison (marketing) -- shares session context through LoreConvo. No agent starts from zero. Each reads the relevant sessions from the agents that ran before it and builds on what was already done.
How Lore Approaches Memory Differently
Most tools in this space require active effort to capture context. You write a summary, you curate a knowledge base, you manually tag important decisions. That discipline is hard to maintain under deadline pressure.
LoreConvo is designed around the assumption that you will not maintain it. The hooks run automatically at session boundaries. You get the benefit without the behavior change. That is the core design principle: automation over discipline.
The other difference is the episodic/semantic distinction. LoreConvo stores sessions -- the timeline of what happened, when, and what was decided. It is your project journal. LoreDocs (our companion product, currently in alpha) stores reference knowledge -- architecture docs, runbooks, design decisions that you want to retrieve by topic rather than by time. The two work together: LoreConvo for "what did we decide last week" and LoreDocs for "what is the canonical architecture for this service."
Getting Started
LoreConvo is in production. The free tier covers a practical workload for solo projects. Pro tier ($8/month) unlocks unlimited sessions and is the right fit for active consulting work or any setup running multiple projects simultaneously.
Installation takes about five minutes: install the plugin, configure the hooks in your Claude settings, and you are done. The hooks run automatically from that point forward. There is no ongoing maintenance. There is nothing to remember to do.
If you are doing serious technical work with Claude -- data pipelines, consulting projects, agentic workflows -- you should not be re-explaining your project every morning.
Your sessions do not have to start from zero.
Get started with LoreConvo -- free tier available
Labyrinth Analytics Consulting helps organizations navigate the dark corners of their data. Learn more at labyrinthanalyticsconsulting.com.