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. See the MCP tools.
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.
Interoperable by design
A knomit knowledge base is private and agent-shaped. knomit-okf publishes it as a portable OKF repository — Google Cloud's open spec — from a single git URL. Plain markdown any conformant consumer can read, and a bundle that is validated against the spec before it commits.
How publishing works$ knomit-okf clone -b main <kb-url> my-kb $ git push -u origin main $ knomit-okf sync && git push
it commits · you push
From the blog
One command turns a knomit knowledge base into 566 markdown files. The docs stop at git push; this is what you have afterwards — the anatomy of a bundle, and four ways to spend it, including Gemini and Claude both answering a design question straight off the files, with no knomit, no server and no MCP.
The same task, with and without the knowledge base, eight runs per arm, judged blind. The assisted arm was always faster and cheaper — but one subtly flawed fact made it worse than no knowledge at all. Repairing that single fact flipped 30 of 32 blind comparisons and prevented a mistake models invent unprompted.
Store a model's speculation in the same shape as a verified observation and retrieval will grant them equal authority — that is how a guess gets laundered into a decision. knomit's answer is the move programming languages made decades ago: type every fact by its epistemic status and its origin, and enforce what may be derived from what. A guess can be stored, retrieved, even confirmed later — but it cannot pass as an observation.
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.