Give your AI the right knowledge, at the moment it needs it.
> /plugin marketplace add assafkip/kipi-system
Give your AI the right knowledge, at the moment it needs it.
Kipi turns the scattered knowledge around your work into context that follows you across AI sessions: decisions, conversations, projects, people, commitments, lessons, documents, history.
You do not have to remember which file holds something, or tell Claude what to read. Ask a question. Kipi works out what you are asking about, reads the sources that matter for that kind of question, and puts the evidence in front of the model before it answers. Then it tells you what it found, which file and line each piece came from, which sources were empty, and which ones it could not read.
The result is an AI that does not start from zero every conversation. Your brain, externalized, with the plumbing that gets the right memory into active thought.
It runs in Claude Code. Plain markdown all the way down. No vector database, no black box. You can open every fact with cat and diff it with git.
Saving information is the easy part. The hard part is getting the right information to the model when it matters.
Kipi's own history is the proof. Every store in the system had a writer and a hook guarding it. The fact graph refused to close a session if it had fallen behind. The commitment ledger dropped any promise it could not quote verbatim. The decision log refused an entry without a tag saying who decided. And nothing read any of it when a question arrived. A question naming a client got none of the client's facts. Careful storage, zero delivery.
So Kipi treats knowledge as a supply chain. Capture. Organize. Retrieve. Deliver. Prove what was delivered.
flowchart LR
subgraph capture ["Capture"]
C1["a debrief after a conversation"]
C2["a handoff at session end"]
C3["a mistake, and why it happened"]
end
subgraph organize ["Organize"]
O1[("canonical: positioning, decisions, objections")]
O2[("a dated fact graph: people, companies, pushback")]
O3[("commitments, meetings, open follow-ups")]
O4[("lessons, shared across every copy")]
end
subgraph retrieve ["Retrieve"]
R["your question names a person,<br/>a project, or a kind of work"]
end
subgraph deliver ["Deliver"]
D["verbatim lines, each with<br/>file, line, date and status"]
end
subgraph prove ["Prove"]
P["a receipt per source: read, empty,<br/>unreadable or skipped.<br/>First line: FULL, PARTIAL or NONE"]
end
C1 --> O1
C1 --> O2
C2 --> O3
C3 --> O4
C4["the project's own documents,<br/>one knowledge base per case"] --> O5[("docs and sub-stores")]
O1 --> R
O2 --> R
O3 --> R
O4 --> R
O5 --> R
R --> D --> P
Ask about a person, and Kipi pulls their relationship history, the decisions that involved them, the commitments made to them, recent meetings, and the open follow-ups. Ask about a project, and a different set of sources becomes relevant. Ask it to build something, and the lessons from previous failures are placed in front of it before it starts.
The reader reads the project's own folder, never a template. Three things make that true:
output, research, inputs, investigation, build, docs, notes, memory) are searched under the project root and under every sub-store, one pass per question, every excerpt with its file and line. The list is data, not code: it is the folders key of q-system/.q-system/knowledge-sources.json, so a project can change what counts as a document folder.The model never has to remember to go looking.
An empty search result is not proof that nothing exists. Most retrieval treats it that way.
Kipi's supply step writes a receipt. Every source the question needed is recorded as read, empty, unreadable, or cut short. The first line of what the model receives says COVERAGE: FULL, or COVERAGE: PARTIAL with the missing sources named, or COVERAGE: NONE when not one declared source could be read.
Where the line is drawn, precisely, because this is the sentence a reader trusts hardest. Only a source the manifest marks required can move the verdict. A deadline or a byte cap that cuts a required source short drops it to COVERAGE: PARTIAL and names the source. The same truncation on an optional source is written into that source's receipt row as partially searched (...) and leaves the verdict alone. In the shipped manifest the document scan is optional in all five task classes, so a truncated document pass can sit under COVERAGE: FULL with the truncation one line down in the receipt. If you want it to move the verdict, set "required": true for docs in q-system/.q-system/knowledge-sources.json, which is what the investigation manifest does. One function computes the verdict, in q-system/.q-system/scripts/knowledge_supply.py.
flowchart TB
Q["ask about a client"] --> S{"each source the question needs"}
S -->|"read, has lines"| A["supplied verbatim, with file and line"]
S -->|"read, nothing there"| B["recorded: searched, empty"]
S -->|"file missing or corrupt"| C["recorded: could not read"]
S -->|"cut short, source is required"| D["recorded: partially searched"]
S -->|"cut short, source is optional"| E["recorded: partially searched"]
A --> F["COVERAGE: FULL"]
B --> F
E --> F
C --> P["COVERAGE: PARTIAL, missing sources named"]
D --> P
C -. "every declared source unreadable" .-> N["COVERAGE: NONE"]
So there is a difference between these two sentences, and the system says which one is true.
"We searched the relevant sources and found nothing."
"We could not read two of the sources that might hold the answer."
Those should not produce the same confidence. Now they cannot.
Technical readers will file this under retrieval-augmented generation. The retrieval is the boring half. What Kipi cares about is what the retrieval knew.
It learns in two ways.
It learns about your world. People, projects, decisions, preferences, relationships, commitments, terminology, history. A debrief after a conversation writes the facts. A handoff at the end of a session writes what tomorrow needs. Both are files, so both survive.
It learns from what went wrong. When the system makes a mistake and you work out why, the lesson becomes durable knowledge supplied to future work. Kipi used to show the model a list of lesson titles and hope it opened one. It did not. It hit the exact failure one of those titles described. Now the relevant lesson bodies are placed in the prompt before the work starts. And where a script can catch the mistake, the lesson becomes a check that refuses it.
flowchart LR
subgraph world ["It learns about your world"]
DB["a debrief after a conversation"] --> G["a dated fact graph,<br/>newest fact wins"]
E["end of session"] --> HO["a handoff note, every claim<br/>labelled measured, stated or guessed"]
end
subgraph wrong ["It learns from what went wrong"]
M["a mistake, and why it happened"] --> L["a lesson, shared across every copy,<br/>client data scrubbed"]
M -. "when a script can catch it" .-> K["a check that refuses<br/>the same mistake"]
end
G -->|"a question naming someone"| S["the next session"]
HO -->|"session start"| S
L -->|"a request to build something"| S
K -->|"every action"| S
It grades itself too. A newer fact supersedes an older one. A handoff line says whether it was measured, stated or guessed. A memory that never gets opened stops being trusted. A source that could not be read is recorded, never assumed empty.
Honest boundary: the lessons path proves the lesson entered the context. It cannot prove the model read it, or that it changed the work that followed. It is stronger than a promise, because a promise leaves no artifact. It is weaker than proof of application, and nothing here claims otherwise.
Everything above rests on one thing: the model receives files it cannot talk its way past. That takes machinery. Here is the machinery.
flowchart LR
F(["You"]) -->|"type"| CC["Claude Code session"]
CC <-->|"small scripts run on every action"| H["Guardrails"]
CC <-->|"reads and writes"| K[("Your knowledge:<br/>plain files on disk")]
CC <-->|"deterministic tools"| M["Local tool server"]
CC -->|"opens"| G["Pull requests + Linear issues"]
J["Scheduled jobs on your machine"] -->|"review, merge, report"| G
J --> K
S[("One template repo")] -->|"one command"| I["Many copies,<br/>one per project"]
I -. "each one is" .-> CC
You type into a Claude Code session. Before, during and after every action, small scripts called hooks run. They add context the AI would otherwise forget, they block actions that would break a rule, and they record what happened. The session reads and writes plain files that hold what you know. A local tool server gives the AI checks that return the same answer every time. Work leaves through pull requests and issues, where scheduled jobs review, merge and report without you in the loop. All of it lives in one template repository and is copied to every project you run.
1. Assume the AI is unreliable. It invents facts, forgets what it read, agrees with whoever is talking, and says "done" before anything ran. Nothing here makes it accurate. Everything here makes its mistakes findable, so a wrong answer leaves a trail and a right one carries its evidence.
2. Files are receipts. A chat transcript is folklore with a timestamp. A file can be opened tomorrow, searched by a script, diffed, and dated. If you told the system something and it did not make it into a file, it does not exist the next morning.
3. Guardrails, not reminders. A reminder is a sentence the AI is supposed to remember. A guardrail is a script that runs whether or not anyone remembers. Anything a script can check is checked by a script that can say no.
4. You are never the next step. Engineering signals go to a queue an agent drains. You decide three things: publish, spend, delete. Everything else has a machine that owns it.
5. One skeleton, many instances. Improvements are made once and fanned out. Each copy keeps its own facts; the template owns the machinery.
View @assafkip’s profileAnti-hallucination toggle for Claude Code. Activates citation constraints from Anthropic's documentation that force Claude to cite sources, say "I don't know" when unsure, and ground responses in direct quotes. Using Kipi Founder OS?
@assafkipkipi-system is a Claude Code plugin with 16 hand-picked skills, indexed on Flowy in the Agent Memory category. Install it with the command on its page. It includes architecture-review, audhd-executive-function, deck-ai. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.
Is this plugin yours?
Claim it with GitHubSubmit a pluginPromote it