The last post was about subtraction: the commands and backends we removed to get the tool to start in the first minute. This one is about a design decision we made early and have refused to walk back, even when it would have been easier to. The memory your agents build up does not belong to any one agent vendor. It belongs to your repo, and anything that can shell out can read and write it.
That sounds like a small architectural detail. I think it's the whole game.
The bet inside a vendor-bound memory
Most coding agents that remember anything remember it inside themselves. The context, the decisions, the "we tried that and it broke" notes live in that vendor's store, reachable through that vendor's surface. It works well, right up until the day you reach for a different tool.
I want to be fair about this, because it's an honest design and not a trap anyone set on purpose. Keeping memory inside the agent is the simplest thing to build, it demos cleanly, and for a user who picks one tool and never moves, it's genuinely fine. But it is a bet. The bet is that you will still be using that exact agent next year, and that you are not, right now, using two at once.
That's a bet I wouldn't take about my own setup. I switch tools mid-task. I run one agent in the editor and another in a terminal. The whole category moves fast enough that the best tool for a job in June may not be the best one in December. Every time the tool changes, vendor-bound memory resets to zero, and the team relearns what it already knew.
What we did instead
We made the memory a layer, not a feature of an agent.
Spelunk is a separate process the agent calls. The interface is deliberately boring: it speaks JSONL over stdout, it returns honest exit codes, and there's an optional REST surface and an MCP server for harnesses that prefer to call it that way. None of that is specific to one vendor. If your agent can run a command and read its output, it can read and write the same memory every other agent reads and writes.
So the test we hold ourselves to is simple. The memory layer should not change when the agent does. Claude Code today, something else tomorrow, a script in CI that never logs in: same store, same decisions, same "why," queried the same way. The agent is a client. The memory outlives the client.
Why it lives in git, not in our cloud
There's a second half to this, and it's the part that matters most for trust.
A memory layer that you can call from any agent, but that only exists inside our hosted service, has just moved the lock-in up one floor. You'd be free of your agent vendor and tied to us instead. That's not the deal we want to offer.
So the memory writes through to git notes, anchored to your commits, living in your history. It clones with the repo. It works with no account and no network. We do offer a hosted layer on top for teams who want one, but the base case is yours on disk, in a format you already trust, that survives us entirely. Owning your memory has to mean owning it, not renting it back from the company that wrote the tool.
What this buys you
Three things, concretely.
You can change agents without amnesia. The tool you adopt next inherits everything the last one learned, because the learning was never stored inside the old tool.
You can run more than one agent at a time and have them share a brain. The decision one agent recorded this morning is on the next agent's first query this afternoon, even if they're different products.
And you can hand the repo to a teammate, or a CI job, or yourself on a second machine, and the context comes with it. The "why" travels with the code instead of staying behind in a session you can't get back to.
None of this requires you to predict which agent wins. That's the point. We're not asking you to bet on a tool, including ours. We're asking the memory to stay put while the tools come and go.
The next post in the series is the last beat: what changes when it isn't one engineer's agents sharing memory, but a whole team's, and one person's sharper convention quietly becomes everyone's default.
Spelunk is open source and code-aware, callable from whatever agent you already use. Repo and docs: spelunk.cloud.