MCP gives me a portable tool layer. I'm still not sure what the right portable memory layer is.
​
One thing I've been running into while building agent systems is that MCP solves one portability problem really well, but not the whole problem.
It gives me a much cleaner way to move the capability surface around. Tools, servers, transports, app integrations. Great.
What it does not automatically solve is this:
where should the Agent's learned context live if I want to move it to another machine without copying an entire pile of runtime residue along with it?
The split that has started feeling sane to me is to stop calling everything "memory."
In the repo I'm building, instructions live in files like AGENTS/md and workspace.yaml. Runtime-owned execution truth stays in state/runtime.db. Durable memory bodies live as readable markdown under memory/.
That distinction ended up mattering more than I expected.
Once MCP owns the tool surface, I can ask a cleaner question about the context surface.
What should be durable?
What should be resumable but not portable?
What should stay machine-local?
My bias now is:
continuity is one job.
durable recall is another.
If those get flattened together, you can have a beautiful MCP setup and still have an Agent that only really works on the original machine.
Curious how people here are drawing that line.
Once MCP handles tools, where do you want the learned context to live?
I'm keeping the repo link out of the body because I'd rather not have this get weirdly removed for reading like a promo post. If anyone wants to go deeper, I'll put the repo in the comments along with the broader technical framing I'm wrestling with: where policy should live, what should stay runtime-owned, why continuity and durable memory should be different layers, and what should or should not move across machines.