That is the title of an issue reopened against OpenClaw this morning. With sessions enabled, memory_search still ranks session transcripts above the durable memory a user curated by hand, and there is no per-source weight to change the ordering. The issue it reopens was closed for inactivity, not fixed.
Forty hours earlier, in the same project, a second report made the mirror-image complaint. Two writers that the runtime itself runs or authorizes, session-rooted runs and native tools invoked through claude-cli, change MEMORY.md, USER.md and memory/** without leaving a provenance record. The consequence is not a warning banner. The next recorded write quarantines the files the user maintains by hand.
A third report, on a different tracker the same week, closes the loop. A user saved "stay in scope" into memory several times, and the model kept ignoring it.
A talk making the rounds on Hacker News this week is titled "Shared memory doesn't stop AI agents from drifting". The title is the argument, and the title is right.
None of these three is a retrieval-quality bug in the usual sense. They are three symptoms of one missing concept: authority.
Three failures, one missing field
| Report | What the user sees | What is actually missing |
|---|---|---|
| openclaw #181362 | Transcribed chat outranks the rules the user curated | A per-source authority axis |
| openclaw #180796 | Hand-maintained memory files get quarantined after an untracked write | A provenance record for every writer |
| claude-code #104162 | A rule saved to memory is not followed | A read at the decision point |
Similarity is not authority
When a single agent wrote its own memory, recency and similarity were reasonable proxies for importance. One writer, one reader, one notion of truth. The worst case was retrieving a slightly stale paragraph and having the model work around it.
Put several harnesses on one store and the question changes. It is no longer which paragraph is relevant. It is which of these two paragraphs is allowed to overrule the other. A transcript is a record of what was said. Curated memory is a record of what was decided. Both can be perfectly relevant, and only one of them is binding.
A scoring function that cannot represent that distinction will eventually put the wrong one first. This is not a tuning problem, and the reporting on it has been consistent: neither a larger result count nor a lower score floor changes the top three. The order comes from a model that has no idea who wrote the thing.
A write without a source is a write you cannot trust later
180796 is the more interesting report, because the failure is conservative in the worst possible way. The system notices that its memory files changed without a matching provenance record, cannot establish who changed them, and quarantines the files.
From the system's point of view that is correct behavior. From the user's point of view, their own memory was taken away by their own tool, for a reason the tool cannot explain, and the thing that triggered it was a write the runtime itself performed.
The lesson generalizes. A write without a source is not a write you can trust later. Every record has to answer three questions at write time rather than at read time: who wrote this, on behalf of which run, and when. If it cannot, then every consistency check built on top has to choose between trusting everything and trusting nothing, and both of those choices are wrong.
A rule that is stored but not read is not a rule
104162 is the shortest of the three and the most familiar. The reporter's own words: it writes it into a memory, but it never seems to follow the memory.
Storing a constraint is not enforcing it. If memory is only consulted when somebody asks a question, a standing rule arrives as context, and context gets negotiated away by whatever this turn is trying to accomplish. The rule has to be read at the decision point, and the read has to be a gate rather than a hint.
This is also why recall benchmarks are a weak measure of a memory layer. A system can score well on whether it retrieved the right fact while failing every test of whether it obeyed a standing rule, and the second failure is the one that costs a working session.
What we built instead
HyperMarrow is a local-first memory layer for coding agents. It runs as a Windows desktop app and is exposed over MCP, with the same store reachable from a Python SDK and a Node SDK. Four modules: record, recall, consolidation, file-bridge.
The reports above produced write-time rules, not retrieval tricks:
- A record lands with a source and a timestamp at the moment it is written. Provenance is a field, not an inference.
- The store is ordinary local files, so which agent wrote a line is something you can check with a file viewer instead of asking the runtime.
- consolidation gathers same-topic records for you to review and merge. It does not silently rewrite history, and it does not let a transcript overwrite a decision it merely quotes.
- Standing rules can be pinned, and pinned records do not decay. Declaring authority is an explicit act, and it is reversible.
- A durable write happens before compaction, and a skipped write is logged rather than swallowed.
- Whether a record may leave the machine is configuration, not a promise in a policy document.
What this costs
- Provenance has a maintenance cost. Somebody has to decide what counts as a source, and the first version of that taxonomy will be wrong.
- Pinned rules do not decay, which means a bad pin survives. Authority is a statement about intent, not about correctness.
- Consolidation asks for human review. That is a feature until you are busy, and then it is a queue.
- Local-first removes one class of third-party exposure and nothing else. It does not cover file permissions, backups, or a compromised endpoint.
- A store that genuinely spans devices and people is not solved by a local folder, and I am not going to pretend otherwise.
The question worth asking
Every memory layer eventually has to answer a question that has nothing to do with embeddings. When two records disagree, which one is allowed to win, and who decided that?
If you cannot answer it for your own store, you do not have shared memory. You have a shared scratchpad.
I'm on the team behind HyperMarrow, a local-first AI memory layer that keeps your data on your own machine. If you're exploring agent memory, the experience entry is on our site; coming from this article, use https://hm.qianshi.cool/api/v2/dl?from=devto and the client will tag the source automatically.
Top comments (0)