Helping your AI remember tasks between sessions (Session Aware Memory Management )

TLDR: LLMs forget everything between sessions. You re-explain yourself constantly, lose progress on long-running work, and have no reliable way to pick up where you left off — especially when switching between models or tools. I built PMM to fix that.

@Deacon Wardlow

helped me improve it by identifying a specific gap: session continuity — what changed, what’s still open, where you stopped. That’s now live in PMM v 2.8.

Edit: I figured screenshots tell a better story => same memory on three different tools with 3 different models, where I've asked the LLM to basically recall outstanding tasks across the 4-5 current projects. Slightly different perspectives because I'm working a slightly different project with each model.

I initially built PMM to remember stuff beyond the context window to fix an issue i had with the LLMs I use failing to remember and recall over long conversations. I used it to have the same conversation, while switching between Claude Code CLI and Co-work.

Eventually it became a tool for helping me with continuity in my conversations with different LLMs on different apps and harnesses ( I switch a lot between Claude, OpenCode and GitHub Co-Pilot). I now use it to give multiple agents long-term memory (while they switch between different models on Claude, Gemini, Model Ark and a couple of smaller local models) without the use of model routing.

I currently deploy it (along with with another agentic plugin I developed) to give agents long-term individual and collective organisaitonal memory in their conversations with multiple users over telegram in a small pilot.

@Deacon Wardlow

tested PMM in his own workflows, identified a gap in session memory management, and tried a couple of changes, which he outlined in another thread discussing Session Memory Layer + PMM.

The problem: your work changes between sessions, and you need the LLM to remember progress, granular task completion and what changed.

PMM already retains knowledge about you, your work and what you're working on
However, there was a gap where session awareness and continuity was lacking

It didn't retain knowledge of files and facts that change between sessions: what did you work on, what you did, where you stopped, what needs to be done at the next session and why.

Deacon proposed:

What was worked on in the last 10 sessions (rolling log)
What's still open and needs follow-up (persistent thread tracker)

Some of these were already implemented partially in existing memory files. I figured we also needed:

Resource tracking (what repos, directories, files belong to which thread / projects)
An archive of sorts for completed threads to minimise context usage for completed threads
Additional info (context, notes, blockers, dependencies) for threads

Initially I proposed, that anyone who wanted to implement

@Deacon Wardlow

's session memory layer on PMM could simply tell the LMM what it needed to be done (PMM is extensible that way). But I forgot that the agentic plugins and skills building skill I developed was a separate plugin than PMM. It would work without, but not as well as it should with the plugin. So I pushed it as a memory feature in v2.8.

Based on his feedback, I integrated session awareness into PMM (and duly credited him with the idea and methodology for the fix). The feature is live for Claude Code CLI and Co-work (but I haven't gotten around to doing it for the OpenCode plugin, yet).

You can install PMM v 2.8 from the github repo.

Here are the changes that were implemented:

timeline.md doesn't just capture session summaries and updates at the end of every session
It now captures what changed and indexes / refers to the entries in the other memory files
This includes entries in the newly introduced threads-open.md and threads-closed.md which tracks issues and projects user is working on (what it is, why you're working on it, what needs to be done, what's been done, success criteria etc). Doesn't require you to say explicitly (but it will help).
When completed, a summary is retained in threads-open.md with a reference to the completed project or issue (archived) in threads-closed.md
Loaded at every session start or after every compact or clear
Saved at every session end (I still recommend manually /pmm:save)

How PMM is different form the other memory systems out there:

Other systems are passive, like filing cabinets, and only as smart as the retrieval assistant searching through them and deciding what is relevant to hand off to the LLM that speaks to the user.
Retrieval system like RAG and a storage system like Graph or Vectors decide what is relevant from past conversations and hands it to the LLM
PMM autonomously decides what's relevant, what to save and what to retrieve

PMM makes the LLM an active participant in its own memory.

It was an experiment in "what happens when I just tell the LLM about memories and where they are" instead of trying so hard to stuff what I (or some other system) think is relevant into context memory.

I've been working on something more polished: a more organic memory system that strips PMM down to core essentials with more autonomy for the LLM. But that's a discussion for another day....

1 comment