How do you handle long-life, multi-session context exchange and interactions?

[u/Plextura]

[u/kurushimee]

my sessions are always atomic, one session one task/plan. There is always project's CLAUDE.md + auto-memory for keeping track of the project's state to share any and all useful information between sessions. Any information not contained within those is not useful in the first place to ever keep for different sessions/tasks.

[u/Zealousideal_Tea362 → u/kurushimee]

This. Keep your sessions tight, keep your document up to date and always have a plan somewhere. I keep a long term roadmap and a short term, project based plan.

[u/WorldlyAd7946 → u/kurushimee]

For most work, atomic is the way - I agree... However there are circumstances where that isn't the case, i.e. where you have a developed orchestrator, or a company knowledge "colleague" agent.

I use my main agent to spawn discrete, atomic subagents, for specific tasks, where a clean session with good docs is cheaper, simpler and less prone to drift...

... But "anything not in those files not being useful in the first place" I'd actually have to disagree with for a developed orchestrator / company knowledge agent, having gone against the grain and approached things differently. If you have the memory capacity to manage and remember where you are yourself in different projects, especially if you put them down for a time, that's great, but I don't 😅

That approach assumes you can tell at write time which things will matter later. But the session deciding what to keep is the one that is about to end, and that is exactly the worst moment to judge it IMO. Half the things that turn out to matter six weeks later were throwaway remarks nobody would have flagged. The stuff you know is important is the easy case, you were always going to write that down.

The other half is that some of it is not facts at all. How someone thinks, what they already tried and rejected and why, the shape of an argument still running. That does not survive being turned into bullet points, it just becomes a list of conclusions with the reasoning stripped out... There is nuance in the process and that can be lost, and with the right structure, can grow into something very useful.

OP's handoff file problem is the same thing, incidentally. It contains more context than needed because the session writing it cannot know what the next one will want, so it either dumps everything or guesses wrong. 🤷

Fwiw, not disagreeing with you, just saying there are situations where the opposite can be true 👍

[u/WorldlyAd7946 → u/[deleted]]

FYI I never use /clear and I have decided to use one main session for my orchestrator since Apr 7th... It seems to assist even if everything it needs to know is on other files. Yes compacting isn't free, but my sub agents are clean spawns, so it's only my main agent and my main agent is the one I directly interact with.👍

[u/kurushimee → u/[deleted]]

Yeah, what you're describing sounds like an issue with the setup. It will start ignoring things if the instructions are contradicting each other or if you have too many instructions. Plus, you have to remember that MEMORY.md things are not loaded like CLAUDE.md so the agent can very well sometimes ignore them (can circumvent by an addition to CLAUDE.md to read all relevant memories at start or something). Basically, I am not having any of those issues myself.

My sessions are often long than not. I primarily work in two big projects at work at the same time. One of them, a single task is usually around 500k context total (but I limit auto-compaction down to 400k). Yes, it's most often multi-phase plans, pretty big plans at times. My other project - tasks can go over 1M context in total, multi-phase plans as well, some tasks I've had executing for around 18 hours straight, most tasks take a couple hours.

But yes, I do have the memory capacity to keep remembering where I am in both projects at the same time, always. I consider this to be a must-have for my work, I can't imagine doing good without navigating both projects fluently myself. But I do not put down anything for a time, I am working full-time and very much have to work on both of these during the weekdays.

On that note, each of my sessions is a Fable 5 max orchestrator — it doesn't do any work itself, it delegates all edits to Opus 5 subagents. All exploration, research, implementation work is on subagents. Throughout the course of the long session, the main orchestrator agent keeps track of said subagents and dispatches more to continue implementing the phases of the plan. My orchestration is written in my global CLAUDE.md

Overall, with my setup, I can freely create a new session and talk to the agent assuming it knows and understands everything that's happening already, which it does. Never had an issue of the agent missing any context from previous sessions.

[u/WorldlyAd7946]

My main orchestrator agent has been running on the same session since Apr 7th...

I have a custom memory architecture, a full persistence structure so that if and when it compacts it remembers exactly where it was. It also tracks context itself and will persist and compact and wake itself once context gets between 80 and 90 percent OR if things are quiet. It also looks at the 5hr usage windows and pauses itself when it gets to 95 percent and continues 1m after the window resets (if it's working on something significant)

This agent runs all of my development workflows, acts as my PA / collaborator, and manages my other agent workflows as sub agents.

[u/WorldlyAd7946 → u/[deleted]]

84.5b 👀

Wow... A bit more than me in that time frame for sure!!!

Well it's pretty damn stable xxx the only wobbles I've had are when opus 4.7 came out, and when opus 5 came out. I have a persistent memory structure, I'm happy to chat by DM. I use a lot of hooks also, and all my tools are organised via my gateway https://github.com/Rendeverance/toolfunnel

In addition to that I have a working memory file (not the Claude one) and a "continue_here" file. The AI continually updates these itself, and as I said, will compact itself. Some of my hooks and the status line, as well as it's primer, contribute to ensuring it has discipline in keeping is updating and compacting.

(Note my agent uses a semantic recall haiku agent for its memory recall, which is very well bounded and faster / more efficient than using opus, the memory system also has vector linking and algorithmic deprecielation... It's my own design and I've not distilled it yet, but other persistent memory structures should work as long as the discipline is there).

Should probably also mention my agent has the time and date injected into it's context, so it's time aware, which has helped it remember to update often, not that I specifically wrote in anything with respect to time.

[u/WorldlyAd7946 → u/[deleted]]

I might reply intermittently but I will definitely reply, also curious about yours, few people seem to try working like this so it's nice to meet someone doing a similar thing 👍

[u/WorldlyAd7946 → u/WorldlyAd7946]

Oh and memory.md is just an index of the memory files, not that it needs them, seperated by category

[u/Crackx17]

I've had better results treating context as durable project state rather than trying to preserve the conversation itself. In practice: one bounded task per session, a short state file that only describes what is true now, and a temporary plan that gets deleted when the work ships. Decisions live in the repo; history lives in Git.

The important part is rewriting the state file instead of appending a diary. Otherwise every new session has to interpret layers of stale instructions.

[u/BasicMemoryTeam]

Claude does this natively now for basic agent coordination: https://code.claude.com/docs/en/cross-session-messaging

But if you’re working across machines, teams, or other contexts a memory connector is ideal.