Vision

The agent already has a model. Memory should not bring a second one, and it should not wait to be asked.

The problem

An agent that forgets is an agent you re-teach every morning. Every agent host now ships some answer to this, and none of them is portable: Claude Code has its memory, Codex has another, Cursor a third. Move tools and your project’s accumulated context stays behind.

The libraries that solve it properly solve it at a price. cognee, mem0 and Zep are good systems, but each one wants an LLM API key of its own, and usually a service to run. That means a second inference bill on top of the subscription you already pay, your project’s memory leaving the machine, another vendor in the loop, and a dependency footprint that does not belong in a developer tool.

The protocol has an answer for this that nobody implements. MCP defines sampling/createMessage, which lets a server borrow the host’s model instead of bringing its own. No host we target grants the capability (anthropics/claude-code#1785 is open), so in practice such a server still needs its own key. Memoose takes the other route: the model that is already running the conversation does the thinking, through skills.

The bet

Memoose splits into an engine and a harness. The engine holds only what is deterministic: a typed graph store, an ontology, chunking, ranking, supersession, a provenance ledger, all reachable as MCP tools. Everything that needs judgment (what counts as an entity, which facts contradict, what is worth remembering, what a session taught) is written down in the harness as skills, rules and hooks, and the model the host is already running does that thinking while it calls the tools.

There is no code path in the library that calls a model, so there is no API key, no second inference bill, and nothing leaves the machine. The cost of the bet is stated plainly: quality depends on the host’s model following a skill, and on the host having something to delegate to. The upside is that when that model gets better, extraction and judgment get better without shipping anything.

Memory is upkeep, not storage

A house stays livable two ways: you put things where they belong as you use them, and you clean periodically. Memory works the same, and a system that does only the first accumulates a store nobody trusts.

The pass gathers the work and judges none of it; a model makes every call, which is the same split as everywhere else here. On hosts with hooks it is offered once a day when a session opens, since a session opening is the only regular event Memoose can observe without a daemon (MEMOOSE_AUTO_MAINTAIN=0 turns the offer off).

You do not do the cleaning yourself either. The work goes to a memory-keeper subagent on a small model, so upkeep costs neither your attention nor the main conversation’s turns. Relying only on the agent choosing to call remember is how memory plugins fail: the agent is busy with the user’s real task, so bookkeeping is the first thing dropped.

Search and recommendation

These are the two ways anything gets found. Search answers a question you thought to ask. Recommendation puts something in front of you that you did not. A memory system that only does search is only half of one: it works when the agent already suspects there is something to recall, and stays silent every other time, and an agent usually does not think to ask.

So Memoose does both. recall answers the asked question across eight retrieval modes. For the unasked one, each incoming prompt is read, memory is searched locally, and when something genuinely matches the agent is handed a hint before it starts thinking. That hint is BM25 over the local index with a relevance floor and a hard cap on how much it injects, silent when nothing matches: no model, a few milliseconds, cheap enough to run on every prompt. The agent keeps full control over whether to follow it. See Automatic memory.

The missing context is usually procedural

An agent with a good factual memory still fails on long tasks in a particular way: it knows what things are and loses what to do next. It runs steps out of order, skips the check before the commit, repeats a step that already failed. Facts answer what is; that failure is about what to do next, and a pile of past-session text does not answer it.

Memoose follows Google’s Procedural Graphs paper (Lu, Chen, Wu, Arık, 2026) and stores procedures in the same graph as facts: steps as Procedure entities, transitions as relations carrying a condition, an advice and a pitfall. The agent declares its position on a session turn and is handed the transitions two hops out from there, raw; it decides. The paper’s ablation is why the neighbourhood is local and small: the whole graph in context did worse than no graph on an embodied benchmark. When the session ends with an outcome, every transition the run took counts it, and a transition that keeps failing is the first thing the next distillation looks at. No model call, no validation harness, no guessing where the agent is: silence beats a wrong steer.

What Memoose is for

Long-lived project work, where the hard part is not finding a fact once but keeping a body of facts trustworthy for months: who owns what now, which decision replaced which, what convention this team follows, what we learned last time and why.

That framing came out of benchmarking rather than preceding it. On LoCoMo, Memoose scored 90.4 across all 1,540 questions at 4,699 mean prompt tokens, but a controlled paired test showed the knowledge graph does not beat plain chunk retrieval there. That is a statement about the benchmark, not a defect: LoCoMo asks needle questions and never asks whether a changed fact is still current, or where a claim came from. So those questions got their own model-free suite. See Evidence & history.

Principles

1. The library never calls a model. If a feature needs judgment, it becomes a skill and a validated tool, not an inference call.
2. The harness is portable. Skills and MCP tools are the whole core; hooks add automation on hosts that have them and no capability the tools lack.
3. Facts carry their evidence. Every relation can point at where it came from, so a later run can re-verify rather than trust.
4. Nothing true is deleted. Facts are superseded, not removed; history stays queryable.
5. Errors teach. A rejected write returns a message written for the model, saying which type to use and which relation name.

How we would know it works

• A developer installs it once and it works in whichever agent they open tomorrow.
• After a month on a project, an agent answers “why is it built this way?” with the decision, the date and the evidence, and flags the two places the codebase now disagrees with it.
• When a step failed last time, the agent is told so before it takes it again, and the chain it follows gets better without anyone editing it by hand.
• When a fact changes, nobody has to remember to clean up.
• The memory file is small enough to read, and a person can open it and understand what the agent believes about their project.