Comparison
The landscape, by operational profile.
The tools agents use for memory cluster into four profiles. Each is good at something. None of them refine what they store — or let you audit how it changed. That gap is where knomit lives.
Everyone else accumulates. knomit refines — and signs its work.
The four profiles
What each cluster is good at — and where it leaves you exposed.
Operational profiles describe what a system can do and how it behaves at runtime — capabilities, not brand names — so they stay stable even as tools churn. You’ll recognise where your stack sits.
Raw piles & DIY
You wire up a vector store or a folder of notes yourself. Text goes in; similar text comes back.
Dead simple, no new dependency — fine for one-shot retrieval over a static set of documents.
Nothing dedups or structures itself. Duplicates pile up, knowledge drifts, and every chunk is trusted equally with no idea where it came from.
Recall layers
Drop in a memory API. It captures the conversation automatically and replays the relevant bits next time.
Low-effort continuity for a single assistant, with broad framework integrations.
Memories are flat free text with no link back to their source, siloed per agent, and impossible to review or version like code.
Graph engines
Run a graph database, ingest data into entities and relationships, and reason across multiple hops.
Structured, multi-hop reasoning — and, at best, genuine temporal awareness of when a fact held.
Heavy infrastructure bound to a database you can’t diff in a pull request, with unsigned facts and updates that sometimes overwrite history.
Agent runtimes
Adopt a whole stateful-agent platform; the agent edits its own memory as it runs.
Self-editing memory and stateful agents out of the box, with strong tooling around the runtime.
You inherit the entire runtime, each agent keeps its own private silo, and the change history — where it exists — is unsigned.
Where knomit sits
A fifth profile: the knowledge refinery.
knomit isn’t a better point on the memory axis — it’s on a different one. It refines the knowledge it holds, and signs every change so you can trust what it kept and what it dropped.
It distills, not just stores
Similar inputs subsume into one fact; synthesis derives higher-order structure. Every other profile retrieves what is similar — knomit also discovers, surfacing emergent keystones across the cross-cluster bridges similarity is blind to. The corpus sharpens as it grows instead of bloating.
It forms hypotheses
Synthesis extends into falsifiable predictions with settlement criteria. When evidence arrives, a hypothesis becomes an observation. That is a research capability — reasoning forward — not a recall one.
Every change is signed — and reversible
Each fact is an Ed25519-signed git commit. Because the substrate is git, knomit prunes and rewrites itself safely: nothing is ever lost, and every refinement is a commit you can review, diff, and revert.
Knowledge converges across peers
Agents and humans propose facts on branches; review merges them to main. One reviewed source of truth, shared instead of siloed — the gap every other cluster leaves open.
Provenance, time-travel, and synthesis aren’t three features. They’re one: a knowledge base that improves itself — and lets you audit every improvement.
Underneath it all: typed atomic facts, not chunks; a customisable epistemic ontology you author in plain markdown; confidence that rises and falls with the evidence; and external references that keep provenance intact beyond the corpus.
Is it the right tool?
When to reach for knomit — and when not to.
We’d rather you pick the right cluster than the loudest one.
Reach for knomit when…
- Knowledge has to be shared and trusted across many agents and humans, not siloed inside one tool.
- You need to explain a claim — where it came from, how confident it is, how it changed.
- You want it reviewable like code and hostable anywhere: it’s just a git repo.
- You want the store to improve itself — dedup, synthesis, hypotheses — not merely hold text.
A simpler cluster is fine when…
- You only need conversational recall for a single assistant, and that’s the whole job.
- A one-shot retrieval over a static document set already answers your questions.
- There’s nothing to dedup, explain, version, or share — raw similarity search is enough.
See knowledge compound, not drift.
It’s open source and it’s just git. Clone it, point your agents at it, and watch the corpus sharpen itself.