Knowl · persistent memory for AI coding agents
worse than none.
Because it gets trusted. Knowl gives every fact your agents store **a record of where it came from**, a **review trail**, and a **successor when it changes** — so the answer they hand back is the current one, and you can see who settled it.
How this was built— the approaches that failed first, and the measurements that ruled each one out.
~/your-repo
$ npm install -g **@dat999zx/knowl** added 1 package $ knowl --version 5.15.0
Node 20 or newer. No API key, no vector database, no service to run alongside it.
Forty seconds on what Knowl does.
In March an agent works out your API rate limit. **100 a minute.**
In June somebody raises it to 500. **The note still says 100.**
An agent reads the note. **It builds against 100.**
Nothing announces it. **You find out when something breaks.**
!Image 2: Four facts in a chain, two checked, one crossed and pointed at
Checkable by design
Every fact carries its reasoning, its evidence and its provenance — observed, stated by a person, or inferred. A claim you can check without asking anybody.
Reasoning, evidence and provenance on every fact
!Image 3: Facts held locally, one of them published upward to a cloud
Yours until you publish
Knowl runs in your repository and keeps its knowledge there. Your code, your embeddings and your session history are never uploaded.
Local by default, shared on purpose
!Image 4: Two faded facts replaced in turn by a current one
Built to go out of date
A fact records what it replaced and what replaced it. Superseded knowledge is never deleted — there is no delete verb in the product at all.
History is the feature, not a changelog
Adapters
Knowl runs as an MCP server, so anything that speaks MCP works with no adapter to write. Three of these also take lifecycle hooks, which is what lets an agent capture what it learned without being asked.
- Claude Code`knowl init claude`MCP + hooks
- Codex CLI`knowl init codex`MCP + hooks
- Cursor`knowl init cursor`MCP + hooks
- GitHub Copilot`knowl init copilot`MCP + hooks
- OpenHands`knowl init openhands`MCP + hooks
- Antigravity`knowl init antigravity`MCP + hooks
- Windsurf`knowl init windsurf`MCP + gate
- Cline`knowl init cline`MCP + plugin
- Zed`knowl acp`MCP + ACP
- JetBrains`knowl acp`MCP + ACP
- Neovim`knowl acp`MCP + ACP
- Kiro`knowl acp`MCP + ACP
- Claude Desktop`knowl init claude-desktop`MCP
- OpenCode`knowl init opencode`MCP
- Anything else`speaks MCP`bring your own
Before / after
Most teams already have agent memory. It is a markdown file nobody trusts, and a person who remembers the rest.
- **CLAUDE.md**`API rate limit: 100/min`Somewhere in nine hundred lines. True in March, still there in June.
**The fact, and its successor**`500/min supersedes the March fact`The old one stays readable. Nobody had to remember to edit anything.
- **Pasting context every session**The same explanation, every new chat
**The agent already knows**And can show you where it learned it
- **Asking in Slack**“does anyone remember why we…”
**One workspace memory**Disagreements surface as disputes, not silence
- **A teammate who remembers**Until the day they don't, or they leave
**A record that outlives them**With the alternatives it beat still attached
Freshness
A memory tool that only stores things goes stale silently. That rate limit, in full: what Knowl records over the four months it takes one claim to go from true to retired — every step kept, nothing overwritten, nothing deleted.
1. In March Your agent asks “What's our rate limit on the public API?”
100 requests a minute _fact_ _observed_ _api-gateway_
An agent worked this out mid-task and stored it, with the run that established it still attached.
2. A week later A teammate confirms it Approved in the review queue
From here the claim carries a name, not just a timestamp — so “who decided this” still has an answer six months later.
3. In June The same question “What's our rate limit on the public API?”
500 requests a minute _supersedes the March fact_
It changed, and the answer changed with it. Nobody had to remember to go and edit anything.
4. Any time Ask what it used to be The March answer is still there
Retired, not deleted. You can see that it changed, when, and what replaced it — which is the part a file full of notes can never tell you.
Proof
When a fact changes, most memory tools keep handing back the old one. On the public benchmark for exactly this, Knowl got 90 of 100 right.
90%!Image 5: KnowlKnowl
79%!Image 6: agentmemoryagentmemory
60%!Image 7: OpenAIGPT-4o long-context
54%HippoRAG-v2
48%BM25
45%!Image 8: OpenAIGPT-4o-mini long-context
29%!Image 9: QwenQwen3 Embedding-4B
28%!Image 10: CogneeCognee
28%!Image 11: LettaMemGPT
18%!Image 12: Mem0Mem0
14%MIRIX
7%!Image 13: ZepZep
SubEM on MemoryAgentBench FactConsolidation-SH at 262K, scored with the benchmark’s own harness. Method, raw results, and the splits where we do worse: the full write-up.
In their words
Memory going stale is not our framing of the problem. It is written into the documentation of the agents your team already runs.
!Image 14Anthropic
> “Over many sessions a memory store accumulates duplicates, contradictions, and stale entries.”
Managed Agents documentation — Dreams
!Image 15OpenAI
> “Memory can become stale. Agents are instructed to treat memories as guidance only.”
Agents SDK — agent memory
Greyhound Research
> “The deepest flaw in current agent memory is that it mistakes retrieval for memory.”
Sanchit Vir Gogia, Chief Analyst — via InfoWorld
Quoted verbatim from published sources, read August 2026. These are observations about the problem, not endorsements of Knowl — every link goes to the page the sentence was read on.
Pricing
Queries never reach us — your agents read a replica on your own machine, so reading back is free at every tier and always will be.
Accounts are free and so is your first workspace. Anyone can be invited in and use all of it — you pay when your team outgrows what Free carries each period.
