Unified Memory between coding agents
Hey Product Hunt,
I just saw a post about unified memory for AI agents, and it made me realize that we accidentally built something similar into Murmell.
But our original goal was different. We needed to preserve a workspace when a canvas freezes, restarts, or moves to another machine. The agent should come back with its files, terminal state, the context and even the conversation intact.
But this also means you can start working with Claude Code, switch to Codex, and let it continue from the same context. You do not need to explain the project again or spend tokens rebuilding everything the previous agent already understood.
We built it for workspace recovery and It accidentally became a shared memory layer for every agent working inside the canvas.
Now I am curious: how do you preserve context when switching between coding agents?
Replies
The ability to keep files, terminal state, and conversation intact after switching agents sounds really useful.
Murmell
@david_turner12 Thanks David. That was the original goal: you should be able to close the workspace, come back later, or switch agents without rebuilding the entire environment and context from scratch.
The discussion here is making me realize that recovery and agent handoff need different levels of memory, though.
Worth separating the two jobs, because they want opposite things out of the same mechanism. A crash wants everything back exactly as it was. That is workspace recovery, and you have it. A handoff wants close to the opposite. If Claude Code burned forty thousand tokens going down a dead end and you hand that workspace to Codex, Codex inherits the dead end as established context. It reads the wrong turns as settled decisions, because nothing in the transcript marks which was which. Does the handoff let me choose what carries over, or is it all or nothing?
Murmell
@rabnoor_s
That's a really good distinction. Right now, Murmell is closer to “everything carries over” because our initial problem was workspace recovery.
But I agree that agent handoff is a different problem. You don't necessarily want Codex to inherit every failed attempt Claude made, you want the useful state: files, decisions, current task, relevant context, etc.
We're actually thinking about making that handoff explicit: being able to choose what the next agent inherits rather than blindly passing the whole conversation/state.
The interesting part is that the underlying infrastructure is already there. We just need to add the layer that decides what is worth carrying over.
The part that decides what's worth carrying over can't be built after the fact. Marking something a dead end has to happen at the moment it dies, and by then the agent has moved on and nothing wrote it down. I do it by hand, one file per project where I note what I tried and why it failed, and that file is the only thing that survives a tool switch intact. If Murmell wrote that as it went, kept or abandoned per attempt, I'd want it more than the terminal state.
The part that will decide it is who picks. If the human picks, it becomes a chore they skip by week two. If the agent picks, it is selecting with the same judgement that produced the dead end in the first place. So make it neither. Carry the artifacts, not the transcript. Files that shipped, tests that pass, the diff that landed. Decisions are reconstructible from what survived, and the dead ends only ever exist in the conversation. A test for the handoff blob: if it would still be useful with the conversation stripped out entirely, it is the right blob.