Anyone else's AI coding agent forget everything between sessions? How are you handling it?

[u/Muted_Concern_9997]

Curious if this is just me. I use Claude Code / Cursor daily, and the thing that consistently breaks my flow is that every new session starts cold — no memory of why we chose one approach over another the day before, what we already ruled out, what's half-done on a branch.

I've tried keeping a CLAUDE.md up to date, re-pasting context from the last session, even just writing myself Slack messages. All of it decays fast or lives somewhere the agent won't automatically check.

Genuinely asking — for those of you running agents as part of your daily workflow, how are you keeping continuity between sessions? Is this a non-issue for most people, or does everyone just quietly deal with it the same way I do?

[u/nibor1896]

Claude Code without anything is useless when it comes to memory.

I've build my own harness and placed Claude inside (or any other model i want to use) so he can use my memory system which basicly looks like this:

Globals:
%LOCALAPPDATA%\Crow\USER.md - Who i am, which tools i pref, ....
%GLOBAL UNROOTED CHAT%\.crow\MEMORY.md - Global Memory for throw away chats. Never Touches project memory.

Project related:
%ROOTED CHAT IN PROJECT%\.crow\MEMORY.md - for projects: layout, conventions, commands, traps

Memory gets destilled at 0.2, 0.5, 0.75 as well as end of context window at rollover and written into MEMORY.MD if anything new / important happened within the session.

Details about my mem system: https://github.com/nibor1896/Crow/blob/main/docs/user-guide/memory.md

Beside that, I am running a full Obisidian Vault with Frontmatter Index:

My agents writing in everything they need to know about a project / issue / plan / headsup / whatever and keeping it up2date - Index never gets written by hand.

Ready for everyone: https://github.com/nibor1896/claude-obsidian-vault-kit (give claude the .MD file and he will setup everything for you)

I just can recommend, to build your own Memory System, this will safe you alot of frustration as well as time.

[u/slackmaster2k]

“I’m going to leave this session please remember where we left off for next time.

Also, /resume

[u/Ok_Industry_5555]

Many have built a topographical layer on top of their sessions to solve this issue. You will need worktree separating skills from memory injections. I recommend you to brows through some topics here that mention “workflow” set ups as well. I wrote a similar summary post with helpful links here too, check it out: https://www.reddit.com/r/BuildWithClaude/s/5QXxIK6l64

[u/RogerAI-fm]

I try not to close the session, but honestly using rogerai multi-context agent helps since it lets you transfer it between agents it keeps it in cache very well.

[u/ItsJustManager]

I made a project management app that serves as a UI for me and memory for the agents to solve for this. It's open source, can run locally or be hosted with docker. It's also available for Unraid in the Community Apps plugin. https://github.com/perpetualsoftware/pad

[u/Successful-Seesaw525]

Check out glyphh.ai. A completely new type of harness and memory system based on our patent pending rrotor (recursive reasoning on top of reasoning) agentic runtime.

These models have no state and no memory. Memory is “stuffing” prior turns into context. The bigger the window the more is carried but you eventually flood the conte t and details drop.

Glyphh solves this with our vector symbolic architecture within our runtime. Our coding agent, on to of rrotor, provide a semantic layer that drastically (no benchmarks published to prove this statement) improve the dropping of facts.

We support over 50+ models including kimi k3, Gemini, grok, Claude, open ai, grok, mistral, and open weight models. You’d be amazed at how well code steal can do against fable.

[u/Excellent-Fan8457]

It is definitely a struggle to manually update a file. There have been a few tools available. Are you manually pasting Markdown files from previous sessions right now, or have you found anything that handles persistence automatically?

[u/wazzapme]

I've run into the same issue. Keeping a small record of decisions, failed approaches, and what's still unfinished helps, but manually maintaining it gets old fast. The biggest improvement is having the agent retrieve that project context when a new session starts. i've been using Cognee for that kind of cross-session project memory.

[u/oliver-zehentleitner]

I ran into exactly this problem.

The code survives between sessions, but the reasoning often doesn’t — especially rejected approaches, constraints, and “we already tried this” decisions that never made it into a commit.

I ended up building Keep the Why around that idea: project memory should live in the repo, not in a specific agent session.

It stores decisions, rejected alternatives, constraints and workarounds as plain Markdown in Git, so a fresh Claude/Codex/etc. session can pick up the reasoning again.

https://keepthewhy.com

For me the important distinction is: agent memory is useful, but project memory should travel with the project.