It checks Python and installs the server
mcp, pyyaml, and the okf-mcp command.
Notes that live · files you own
Knowledge that reviews itself.
Every note senses when the world moves past it, and corrects itself. RAG gives you an answer; this gives you evidence the source is still alive.
vault graph — live t+0d
reviewed due / stale no sensor
typed edge (frontmatter) wikilink (body)
real example from the demo vault
What this is
A versioned, self-correcting substrate for operational knowledge, shared between humans and agents.
Until now, knowledge was something you maintain. You organize it, update it, correct it, search it. That was always the deal: from filing cabinets to RAG, from NotebookLM to every agent memory on the market. The knowledge depends on a mind that takes care of it.
This inverts that.
Knowledge that sustains itself. It corrects, observes, assimilates, and evolves on its own. When a human mind touches it, with a repo, a paper, a decision, a conversation, it isn't organizing anything. It's feeding it. The knowledge grows with the touch, and keeps growing without it.
The people and the agents that use it are not its users. They are its inhabitants.
The unit of continuity is not the person, and not the agent. It's the model. It grows with every interaction. Humans and agents live inside it, each contributing their own.
That's why this is not "memory for agents." It's not "notes that organize themselves." It's the substrate where both live.
And that's the frontier: the question it opens is not "how do I organize my notes better?" It's what happens to knowledge when it stops needing to be taken care of.
What does this enable?
Continuity across agents and time. The unit of continuity is not a person and not an agent. It's the model. Agents enter and leave; sessions end; the knowledge stays. What was decided, tried, reversed, and learned is there for whoever comes next, human or machine.
Beliefs that can be wrong, and discover it. Nothing in this system needs to be right permanently. Every claim carries its evidence, its confidence, and its review date. When the world moves past it, the system notices and corrects it. An agent doesn't have to hold the truth forever; it can learn it was wrong, and the record shows the correction, not the stale belief.
Many agents on the same world. A team of agents operates on the same graph: reviewers, analysts, dreamers, workers, coordinated by the shared model instead of by fragile handoffs. Humans direct intent and risk; the context takes care of itself.
A machine that assimilates what you bring. A repo, a paper, a decision, a conversation: the system reads it, contrasts it with what it already knows, and integrates what's valuable. The model grows with every thing you feed it, and keeps growing after. That's the difference: not a tool that processes your knowledge, but a knowledge that evolves with the world you bring it.
Some of this works today, measured and verifiable. The rest is the direction: long-horizon work sustained across many agents, knowledge that evolves from simple self-repairing entities. The distinction matters. This is a system with a verified core, not a promise.
Get started
What the command does
One command. It checks for Python, installs the server, and creates a config file next to your notes.
$ curl -fsSL https://syberloop.com/install.sh | bashPython 3.11+ and bash. No services, no daemons. Safe to re-run — it never overwrites an existing config.
It sets up your vault
You give it a path (default ~/OKF-Vault). It creates the directory if it doesn't exist and copies .okf.config.yaml — without touching one you already have.
It verifies the install
Runs the health check and prints the MCP registration snippet for your AI tools.
Straight answers
The things people ask before they try it.
Isn't this just Notion, Obsidian, or a folder of notes?
Those hold your knowledge perfectly. What they can't do is keep it true. You reverse a decision, and the old note sits there — an agent reads it weeks later, believes it, rebuilds what you tore out. This retires a reversed decision: still visible for provenance, but no longer served as truth. A file has no opinion about what's still true. A living entity does.
Do I need to be a developer to use this?
No. The ideas are about knowledge, not code. You bring the world — a repo, a paper, a decision, a conversation — and the model grows. The one command installs it; after that, you live inside it the way you live inside your notes today. Developers get agents and automations; you get a knowledge that keeps itself true.
Does my knowledge really correct itself?
Yes, and it's measured. The system runs scheduled reviews: each entity carries a review date, and when one expires, it's evaluated against recorded evidence, the outcome is recorded, and the next review is scheduled — end to end, without a human in the loop. That's the difference between a promise and a loop that closed.
Isn't this just AI memory?
Agent memory is personal: it learns what one tool does inside one session, and a teammate starts cold. This is the opposite direction: the knowledge is the unit of continuity — not the person, not the agent. Humans and agents live inside the same model, each contributing their own. When the tool changes, the knowledge stays.
Where does my data live?
On your machine, in your files. The server reads and writes Markdown in place; git keeps history. No hosted database, no telemetry, no training on your data. If you want to see the graph in Obsidian, the optional Cognitive Trace plugin renders it there — still local.
What can it grow into?
That's the frontier. Memory that evolves from simple self-repairing entities. Agents that run long-horizon tasks without losing context. A machine that assimilates new architectures and adds them to what it knows. Some of this works today; the rest is the direction. Either way, the knowledge you feed it keeps compounding.