Distributed knowledge · Knowledge + commit
knomit is git-backed knowledge for AI agents — a
distributed knowledge base built from concise, typed
facts, not ingested documents. Each fact carries
confidence, provenance, and refs to others; facts evolve, and discovery
gives birth to new ones. Every peer — human or agent — learns on its own
branch and converges on a shared main.
facts, not documents · signed commits · converge on main
Facts, not documents
knomit is not chunk-and-embed. Knowledge is captured as facts — atomic claims in plain markdown. Here's what one is made of.
--- type: concept confidence: 0.88 domain: [ai, research, agi] entities: [Yann LeCun, Meta, Anthropic] refs: - knomit:/kb/technology/ai/research/theory/f64b961e.md ---
Yann LeCun proposes Superhuman Adaptable Intelligence (SAI) as an alternative to the AGI goalpost — intelligence measured by adaptation to new situations, not by frontier benchmark scores.
The problem
Ingest a document and you've stored its words, not what's true in it. Two similar documents become two copies instead of one set of facts — and you can't explain, corroborate, or trace any of it.
In your documents
RAG and friends embed whole documents as-is. You store the text, not the facts inside it — no concise, classified claims you can reason over.
Two documents that say nearly the same thing get stored twice — not as one fact with multiple references, just redundant chunks that drift.
The document is used as-is: no cross-reference, no corroboration, no confidence, no going back in time to see how a claim evolved.
In your codebase
Design intent lives in someone's head, not the repo — so agents and teammates slowly drift from how things are meant to work.
The load-bearing rules aren't written where the work happens, so the same mistakes get made again and again.
Why an approach was tried and dropped goes unrecorded — so dead-end experiments get repeated from scratch.
How it works
Asserted, proven, agreed, recalled — the loop runs inside your normal workflow, not beside it.
Learning isn’t a side chore. Through MCP — wired into Claude Code, your editor, or any agent — a peer asserts a typed claim as part of its normal execution: it learns while it works. Humans assert the same way, by editing markdown.
knomit_learn (MCP) · Claude Code · editor · agent loop
Each write is one atomic, signed git commit on the peer’s own branch — never on main directly. Commits chain into a versioned, time-based graph: every fact is pinned to the exact moment, and the exact state of the world, in which it was learned.
commit a1ef27c · signed (Ed25519) · branch agent/…
No peer merges another’s branch. Facts are reviewed, approved, and merged into main — the consensus. Because the store is a plain git repo, you can keep it local or push to a git host like GitHub: a decentralized, always-on, secured remote with pull-request review and merge built in. Each peer then pulls main and merges it locally.
git: local repo or remote (GitHub) → PR review → merge to main
Because the graph is versioned by commit, knomit_explain follows every reference as the world was when the fact was learned. Synthesis distills new facts, hypotheses extend them forward, and the discovery effort dial surfaces emergent keystones the bridges between clusters reveal.
knomit_explain (as-of commit) · synthesis · hypothesis · discovery
The same MCP tools and skills that let your model act let it introspect on what it knows — recall before it works, learn as it goes. Every pass leaves the knowledge base sharper than it found it.
Why knomit
Decisions are only as good as the facts behind them. knomit is built so those facts are accurate, traceable, and actionable — across every peer.
Concise, atomic claims — observations, principles, invariants, decisions — not chunked text in a vector store.
Every fact is epistemic (what is) or pragmatic (what to do), each carrying a confidence you can weigh — and that rises and falls.
Similar inputs subsume into one fact with many references. And what one peer learns, every peer inherits by pulling main — no re-deriving what the network already knows.
Every fact is a signed commit you can trace, cross-reference, and corroborate — where a claim came from, who asserted it, and how it changed. Cryptographic, not hand-waved.
Git versions the whole graph by commit. Follow a fact’s references as the world was when it was learned — not as it is now — and watch confidence move over time.
Synthesis distills higher-order facts; hypotheses extend them. And an effort dial finds emergent keystones — load-bearing facts that bridge clusters similarity-only retrieval can’t connect. Knowledge that generates new knowledge.
Every fact declares its ontology, domains, and entities — and clusters by meaning and by classification, so you see the shape of everything you know.
Drops into Claude Code, your editor, or any agent over MCP. The same tools let a model recall before it acts and learn as it works — no prompt scaffolding.
Each peer works on its own branch; facts are approved and merged into main, the consensus. It’s a plain git repo — review like code, host it anywhere.
From the blog
You shipped the feature and merged the PR — and somewhere in your knowledge base, a dozen facts just quietly went out of date. The fix isn't to write more carefully; it's to make the corpus introspect on itself. Here is a real, interactive pass where Claude Code swept knomit's own knowledge base fact-by-fact, checked every claim against the source instead of trusting the corpus, and corrected the drift — recording each correction instead of erasing it. This is the learning loop closing.
knomit's own repo runs on knomit. We started where everyone starts — a fat CLAUDE.md and a per-machine MEMORY.md — and watched them rot and crowd out context. Here is what replaced them: typed, scoped knowledge surfaced at the moment of the decision, and one real fact that climbed from hunch to proven.
FAQ
Open source, and it's just git — typed, provenanced facts, versioned through time, that humans and agents converge on. Yours to inspect, diff, and host anywhere.