An agent-native requirements compiler and enforcement layer that maintains structured product intent, traceability, and implementation proof.
Also known as Looted/kibi, kibi
- Stars
- 12
- Tools
- 16
- Downloads, 30 days
- —
- Latest version
- 3.28.0
- Last commit
- Nov 14, 2026
- License
- AGPL-3.0
What is Kibi MCP?
Kibi is an agent-native requirements compiler and enforcement layer that maintains structured product intent, traceability, and implementation proof. It exposes 16 tools, such as kb_query, kb_search, kb_status.
Summary generated from the project's README
About Kibi MCP server
Kibi is an agent-native requirements compiler and enforcement layer designed to help AI coding agents maintain structured product intent. It transforms natural language descriptions into a formal model of requirements, scenarios, tests, and semantic facts. By acting as a validation gate, it ensures that code implementations remain coherent with the original product goals, preventing drift during development.
The system is intended for developers using coding agents like Claude Code or Cursor. It operates locally within your repository, storing all knowledge base state in a .kb directory to keep data private. Setup is typically handled by the agent itself via a specialized prompt that installs kibi-core, kibi-cli, and kibi-mcp. The server requires Node.js 22+ and uses SWI-Prolog to perform deterministic checks using Prolog rules.
Kibi distinguishes itself by being proactive rather than passive. Instead of waiting for a user to consult a document, it uses hooks and tools to bring relevant context back into the agent's workflow. It supports various languages through tree-sitter plugins, allowing it to extract symbols and verify implementation proofs for TypeScript, Python, Go, Rust, and many others.
What you can do with it
- 1Enforce requirement consistencyAsk the agent to check if a new code change contradicts existing product requirements.
- 2Trace implementation to intentRequest a trace from a specific code symbol back to the original requirement or scenario it satisfies.
- 3Bootstrap project knowledgeHave the agent ingest existing documentation from wikis or issue trackers to build a structured knowledge base.
- 4Verify multi-language symbol linksUse the system to ensure that imports and calls across different programming languages match the defined requirements.
Written from the project's README. Every use case is checked against a quote from it.
How to install Kibi MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Kibi MCP in Claude Code
$ claude mcp add kibi -- npx -y kibi-mcpInstall Kibi MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"kibi": {
"command": "npx",
"args": [
"-y",
"kibi-mcp"
]
}
}
}Install Kibi MCP in VS Code
.vscode/mcp.json
{
"servers": {
"kibi": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"kibi-mcp"
]
}
}
}Install Kibi MCP in VS Code CLI
$ code --add-mcp '{"name":"kibi","type":"stdio","command":"npx","args":["-y","kibi-mcp"]}'Install Kibi MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"kibi": {
"command": "npx",
"args": [
"-y",
"kibi-mcp"
]
}
}
}Install Kibi MCP in Codex
$ codex mcp add kibi -- npx -y kibi-mcpInstall Kibi MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.kibi] command = "npx" args = ["-y", "kibi-mcp"]
Install Kibi MCP in Gemini CLI
$ gemini mcp add -s user kibi npx -- -y kibi-mcpInstall Kibi MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"kibi": {
"command": "npx",
"args": [
"-y",
"kibi-mcp"
]
}
}
}Started by HostedMCP on 16 Nov 2026
We ran this command for kibi-mcp 3.28.0 in an isolated container with no network and no keys. It answered and listed 16 tools.
Kibi MCP tools 16
Read from the server with tools/listkb_queryRead-onlyRead entities from the KB with exact filters, or ask typed fact questions. Use for lookup by id, type, tags or sourceFile, and for precise questions about modeled facts: predicate facts by name with named arguments (predicate + where), property facts of a subject (subjectKey + propertyKey), the domain view of a subject (factKind 'subject' + subjectKey: its definition, broader and narrower subjects, every current requirement about it and the claims and scenarios on it), or the catalog of facts of one kind (factKind; 'predicate_schema' lists the predicates you can ask about with their argument names and constants). Typed answers return matching fact rows plus factQuery: the schema used, distinct counts, values that do exist when nothing matched, warnings about the question and the next call to make. Read-only. Tags filter by metadata tags only, not entity IDs.
kb_searchRead-onlyAsk the KB a question or search it. Default intent-v1 ranking accepts questions, host-agent semantic facets and changed-code source locations, returns evidence, abstains below its confidence threshold and adds an answer layer: the current requirements that govern the topic, what must stay true (linked facts), why (ADRs) and what verifies it (scenarios, tests). A weak answer may add queryAnalysis.hints from a search-hints plugin: requirements the question may mean, to re-ask with. Use before changing behavior, then kb_query for exact follow-up. No mutation side effects.
kb_statusRead-onlyReport current branch, KB snapshot, freshness metadata, schema status, and a typed kibi.migration-plan.v2 action graph. Call it first to orient on a branch or after a failed call; use kb_check for validation findings and kb_coverage for proof status. Read-only status inspection with no mutation side effects; damaged stores are diagnosed without starting the engine.
kb_skillsRead-onlyRead bundled Kibi agent skills (workflow guidance). action:list returns the catalog; action:load returns a skill's metadata, Markdown body, declared resources and content hash (start with id 'kibi-usage'); action:read returns one manifest-declared resource. Read-only; does not require Prolog.
kb_find_gapsRead-onlyList KB entities by the relationships they lack or have. Use for questions like which requirements lack scenarios or tests; all filters must match, and a relationship counts in either direction. Use kb_coverage instead for proof status and repair plans, and kb_check for rule violations. No mutation side effects.
kb_coverageRead-onlyGenerate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Use it to ask which requirements are tested end to end, how strong each requirement's evidence is (evidenceLevel: proved, tested, asserted or unverified), and what blocks the rest; use kb_find_gaps for a plain list of missing links and kb_check for rule violations. Reports include the compatible repair plan plus typed kibi.migration-plan.v2 actions; semantic and E2E actions remain review/execution work. Paginated plans identify incomplete scope and no mutation occurs.
kb_graphRead-onlyRun bounded graph traversal from one or more seed IDs across curated relationship types and return the nodes and edges reached. Use it to follow links from IDs you already have, such as a requirement to its scenarios and tests or a symbol to the requirements it implements; use kb_query to find entities by filter and kb_search to ask a question. Traversal stops at depth, maxNodes or maxEdges and then sets truncated. No mutation side effects.
kb_modelRead-onlyTurn requirement prose into checkable structure without writing the KB. Use it for one requirement's prose; to plan a whole change request use kb_compile_intent. mode:analyze returns the semantic advisor receipt: the clause ledger, what is grounded, what is ambiguous and suggested modeling (pass clauses for compound prose and optional typed kibi.logic.v1 interpretations). mode:requirement converts one claim (subjectKey, propertyKey, operator, value, or typed logic) into a strict-lane write set and applyPlan. mode:predicates ranks ontology predicate schemas and returns an applicable predicate-fact plan only for reviewed bindings, otherwise an ontology-gap observation. With requirementId, mode:predicates also returns a hash-bound plan (fact write plus requires_predicate link) for kb_apply_plan, whose contradictionAnalysis is the what-if over the current KB; other returned plans apply with kb_upsert, and kb_upsert dryRun with plannedFacts previews a requirement before its facts exist.
kb_upsertActionCreate or update one entity and optional relationships. Use for KB mutations after validating intent; prefer a dryRun:true call first because it validates without writing and returns semantic advisor receipts for prose-heavy requirements. Use kb_model (mode requirement) before hand-writing strict property facts from prose, and kb_model (mode predicates) before hand-writing ontology predicate facts. Use the `relationships` array for batch creation of multiple links in a single call (e.g., linking a requirement to multiple tests or facts). An update keeps the properties and relationships it leaves out: send the fields that change (with title and status) and only the links to add. Prefer modeling requirements as reusable fact links (`constrains`, `requires_property`, or `requires_predicate`) so consistency and contradiction checks remain queryable. Relationship endpoints must already exist in KB. For requirements, the write will be rejected if it contradicts existing current requirements that constrain the same subject with incompatible properties. To replace a conflicting requirement, include a `supersedes` relationship from the new requirement to the old one in the same request, then upsert the old requirement with status closed (kb_check blocks a superseded requirement that is not closed). Successful writes may return non-blocking semantic advisor warnings; inspect and repair those warnings before treating prose as contradiction-checkable. Pass a sectioned `document.body` when creating a requirement (the statement, then `## Context` stating why it exists, who asked and the source, then `## Source` with the verbatim excerpt) and a prose body for scenarios, tests, ADRs and observation facts; a result warning reports an entity whose body lacks context, and kb_check blocks it under entity-context-missing. Never invent a reason the requester did not give: write 'Reason not stated'. Do not use for read-only inspection. Side effects: writes KB, may refresh symbol coordinates; dryRun:true writes nothing.
kb_deleteActionDelete entities by ID, or exact relationship triples. Use only for intentional removals after dependency checks. Do not use as a bulk cleanup shortcut. An entity authored in a Markdown or YAML source is not deleted directly: the call writes nothing and returns outcome plan_returned with a hash-bound deletionPlan and a nextActions entry holding the exact kb_apply_plan input ({plan, approvedPlanHash}); apply that unmodified, or repeat this call with approvedPlanHash = deletionPlan.planHash to apply the freshly computed plan in one step (a stale or different hash fails with DELETE_PLAN_HASH_MISMATCH and writes nothing). Authored requirements are never deleted: outcome supersession_required points to kb_upsert with a supersedes relationship. dryRun:true previews any delete and writes nothing. Side effects: mutates and saves KB and authored sources; skips entities with dependents; dryRun and plan_returned write nothing.
kb_checkRead-onlyRun KB validation rules and return violations, quality diagnostics, and typed kibi.migration-plan.v2 actions. Use before or after mutations and after source edits; checks remain read-only and never infer or apply actions from prose suggestions.
kb_prepare_impact_reviewRead-onlyPrepare complete content-bound impact-review authoring inputs from the current staged snapshot or explicitly selected immutable Git commits. Use it when kb_check reports that changed files need an impact review; it does not plan KB changes. Returns strict reviewer schemas and an unauthored template; it does not decide, approve, sign, stage, or prove the review.
Show all 16 toolsShow fewer tools
kb_plan_bootstrapRead-onlyGenerate a deterministic, snapshot-bound kibi.bootstrap-plan.v1 for repository onboarding. Use it only to onboard a repository whose KB is empty or incomplete (the kibi-bootstrap skill drives it); for a change in an onboarded project use kb_compile_intent. Read-only analysis of the repository plus any declared knowledge sources and cited intent claims returns evidence, bounded context questions, exact dependency-ordered actions, a canonical plan hash, and no mutation side effects.
kb_compile_intentRead-onlyCompile complete change intent into a deterministic, snapshot-bound read-only plan. Use it before editing code for a change request that may touch several requirements; use kb_model for one requirement's prose and kb_plan_bootstrap for first-time onboarding. Reuses intent-aware discovery and semantic modeling, accounts for every proposition, reports contradiction witnesses, proposes traceability links, and emits dependency-ordered kb_upsert-style steps only for resolved typed claims. contradictionAnalysis.outcome is no_conflict only when the check could decide: an unmodeled proposition or a related current requirement without logic leaves it unresolved with reasons and reviewCandidates to compare and judge through conflictReviews. No mutation side effects.
kb_apply_planActionApply an explicitly approved kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or entity-deletion plan after revalidating its canonical hash and live snapshots. Compile plans apply all-or-nothing: a durable journal records every source write and store mutation before the first write, all steps commit in one store transaction, and an interrupted application is completed or rolled back by the next mutating call. Bootstrap actions are dependency-ordered, sequential, source-first, and recoverable from a typed journal.
kb_ingest_proofActionIngest a producer-emitted kibi.proof-run.v1 artifact and evaluate it against each selected test's kibi.proof-contract.v1 proof obligations. Revalidates the live workspace snapshot, integration command binding, run-level outcome, attempt history, success policy, and append-only proof-receipt history before deriving and appending idempotent kibi.proof-receipt.v1 receipts. Producers report what happened; Kibi evaluates proof. Prefer `kibi prove` so the configured producer runs automatically; direct ingestion is an integration path for custom producers and agents.
Automated checks
Ran Nov 13, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablePass
- Open source license (OSI)Pass
- Commit or release in the last yearPass
- Package name not close to a popular packagePass
- Remote endpoint uses HTTPSNot checked
- Destructive tools are labelledNot checked
- No hidden instructions to the modelPass
- No critical advisory in the package or its dependenciesPass
README
View on GitHubPrompt the intent. Kibi makes the agent remember it—and prove the implementation.
Simplified from what Kibi reports in each case.
Kibi is an agent-native requirements compiler and enforcement layer. You describe product intent in natural language; the agent creates and maintains the structured requirements, scenarios, tests, semantic facts, and code links. Kibi then checks that the implementation remains coherent with that intent.
Unlike passive memory or retrieval systems, Kibi is designed to place itself in the agent's workflow. The agent does not have to remember to consult a ticket, board, or requirements folder: Kibi's hooks, tools, and validation gates continuously bring the relevant product context back into the work.
Documentation · Quick start · Kibi's own health report
Why Kibi
Most project knowledge is scattered across prompts, tickets, code, and conversations—and most AI agents eventually forget part of it. Kibi turns that knowledge into an enforceable, branch-local model:
- Humans maintain intent, not artifacts — The prompt is the primary authoring interface. Agents own the routine work of creating and evolving requirements, scenarios, tests, facts, and symbol links; humans resolve genuine ambiguity and product decisions.
- Memory is enforceable — Symbols need requirement ownership, requirements need complete semantics and scenarios, scenarios need tests, and proof-bearing tests need fresh execution evidence.
- Prolog guards against drift — Typed properties, predicates, and safe rules let deterministic checks expose contradictions, unsupported invention, and incomplete semantics before they become accepted project knowledge.
- E2E behavior is traceable — Kibi records what an end-to-end test proves, not merely which lines it happened to execute. You can navigate from a symbol to its requirement or from a test to the scenario and intent it verifies.
- Intent survives branch changes — Each Git branch has its own KB snapshot, so feature context stays isolated and is there when you return.
- Works across languages — TypeScript and JavaScript symbols are built in. The optional
kibi-plugin-treesitteradds offline symbol extraction for Python, Go, Rust, Java, C#, PHP, C, C++, Bash, Ruby, SWI-Prolog, and Terraform/HCL using pinned WASM grammars. Each language installs as a smallkibi-lang-*grammar pack (kibi-lang-python,kibi-lang-go,kibi-lang-prolog, ...), andkibi doctornames the ones a repository needs: generated files count only when the KB uses them, and any pack can be declined inkibi.declinedLanguagePacks. Generated code (linguist-generated, a generator header, orkibi.generatedPathsglobs) also needs no requirement links in the commit gate unless the KB tracks it. Code and source proofs read TypeScript, JavaScript, Python and SWI-Prolog, so a Prolog project can prove its claims against its own predicates, imports, calls andpack.pl. With the plugin active for proofs, source proofs also read what Go, Java, C#, Rust, PHP, C and Bash files import, call and read from the environment, and the property values of PHP, C and Terraform/HCL files, without compiling or running them. - Optional UI design guard (experimental) —
kibi-plugin-uikeeps React and Angular components on their agreed design patterns. Pixels, colours and spacing stay with your linter. - Questions in your own words (optional) —
kibi-plugin-search-hintssuggests which requirements a weakly answeredkb_searchquestion probably means, by meaning rather than shared words, with a small offline model. - Keep knowledge local — KB state lives in your repository's
.kb/directory and is never sent anywhere. The Kibi packages send anonymous usage statistics, which you can turn off (see Usage telemetry); the documentation website counts visits with cookieless Umami analytics.
Quick start
Kibi is meant to be set up and driven by your coding agent, so the recommended install is a prompt rather than a list of commands. Kibi requires Node.js 22+. SWI-Prolog is bundled: on Linux (x64 or arm64, glibc 2.28+) and macOS (Apple silicon or Intel) there is nothing else to install. On other platforms, such as Alpine/musl or native Windows (use WSL), install SWI-Prolog 9.0+ and put swipl on your PATH (details).
Recommended: let your agent set it up. Paste this into Claude Code, Cursor, Codex, OpenCode, or any coding agent that can run commands in your repository:
Set up Kibi (https://github.com/Looted/kibi) in this repository, then bootstrap its knowledge base.
1. Install: confirm Node.js 22+ is available. With the package manager this repository already uses, add kibi-core, kibi-cli and kibi-mcp as dev dependencies. Do not skip optional dependencies; the bundled SWI-Prolog runtime is one.
2. Initialize: run every `kibi` command through the package manager's local runner (npm: `npm exec -- kibi <command>`). Run `kibi init`; if it reports a problem, run `kibi doctor` and fix what it names. If this platform has no bundled SWI-Prolog, tell me what to install and stop.
3. Connect: register the project-local `kibi-mcp` server for the agent host you are running in, following https://looted.github.io/kibi/guide/connect-an-agent.html. Prefer project-scoped configuration, and ask me before installing a plugin or changing global settings. Until the kb_* tools are visible to you, use Kibi's CLI JSON routes instead.
4. Bootstrap: run `kibi skills load kibi-bootstrap --format markdown` and follow that skill exactly. It starts by asking me where product intent lives outside the code (issue trackers, wikis, specs) and which sources to trust; read them through the connectors you have and cite them. Show me the complete plan and its hash, and write nothing until I approve it.
5. Verify: run `kibi check` and `kibi status`, fix anything they report, and summarize what was added. Do not commit; I will review the changes.
What happens next:
- Setup. The agent installs the packages, runs
kibi init, and connects itself to Kibi. - Interview. It asks where your product intent already lives (issue trackers such as Jira or YouTrack, wikis, specs) and which of those sources to trust.
- Plan. It reads those sources through the connectors it has and drafts a bootstrap plan. Every requirement in the plan cites the ticket or page it came from. Open questions and conflicts it finds between sources are flagged for you rather than turned into requirements.
- Your approval. It shows you the plan and its hash. Nothing is written until you approve.
- Apply and check. It applies the plan, validates the result, then fills in what the plan could not write, such as scenarios from acceptance criteria and machine-checkable facts for the new requirements. It tells you what it added.
After that, work normally: prompt for features, fixes, and refactors, and the agent keeps requirements, scenarios, tests, and code links in step with the code.
In your repository:
npm install --save-dev kibi-core kibi-cli kibi-mcp
npm exec -- kibi init
kibi init creates the .kb/ layout and installs the Git hooks that keep it in sync. It never overwrites a hook it did not write; with lefthook, husky or the pre-commit framework it installs none and prints the configuration to add instead. It does not infer product knowledge. So that a fresh clone (a teammate's, a cloud agent's) uses Kibi too, it also writes a Kibi section into AGENTS.md (imported from CLAUDE.md) that tells any agent the knowledge base exists, and adds a prepare step that installs the hooks when dependencies are installed; the first Kibi query in a clone compiles the branch's store from the committed knowledge. Each of these can be turned off (setup choices). Connect your coding agent, then ask it:
Bootstrap Kibi for this repository.
pnpm, Yarn, and Bun work the same way through their local runners. The installation guide has their equivalents, how Kibi finds SWI-Prolog, and package-manager caveats. npm exec -- kibi doctor tells you whether everything is in place.
Upgrading. After updating the Kibi packages, run kibi migrate (or ask your agent to). It shows what would change and applies nothing until you approve; the CLI reference covers each schema version.
Versions. Each release has one Kibi release version, such as 2026.11.0, that names its exact package set and declares the KB schema it uses. kibi --version and kibi doctor show it, and doctor warns when installed packages come from different releases. When a newer kibi-cli is out, the CLI says so in one stderr line at a terminal (checked at most daily in the background, silent in CI, JSON output and agent runs, off with KIBI_UPDATE_CHECK=0), and kibi doctor reports it for every host. See Kibi release versions.
Connect your coding agent
The setup prompt above does this step for you. To do it by hand: every client starts the same project-local kibi-mcp server (npx --no-install kibi-mcp, stdio, working directory = your repository). Optional plugins add bundled skills and hooks on top.
Install the optional kibi-claude plugin from this repository's marketplace. It brings the MCP server, the bundled skills, and hooks that show the agent the linked requirements, what they must keep true, and the decision behind them before it reads or edits code, including through shell commands. The agent connection guide has the details:
claude plugin marketplace add Looted/kibi
claude plugin install kibi-claude@kibi
Without the plugin, register the server for the project:
claude mcp add --scope project kibi -- npx --no-install kibi-mcp
Add Kibi to .cursor/mcp.json:
{
"mcpServers": {
"kibi": {
"command": "npx",
"args": ["--no-install", "kibi-mcp"]
}
}
}
The optional kibi-cursor plugin adds rules, bundled skills, commands, and advisory hooks that show the same requirement context as the Claude Code plugin before reads and edits of linked code. See the Cursor plugin guide.
codex mcp add kibi -- npx --no-install kibi-mcp
The optional kibi-codex plugin bundles Kibi skills, MCP configuration, and warning-only hooks that bring the linked requirement into the agent's context before it changes code. Add the Kibi repository marketplace, open Codex, then run /plugins, choose Kibi Plugins, and install kibi-codex:
codex plugin marketplace add Looted/kibi
The repository marketplace is not the official OpenAI Plugin Directory; self-serve plugin publishing is not available there yet. Manual MCP configuration remains fully supported.
Add Kibi to opencode.json. The optional kibi-opencode plugin adds prompt guidance (including what a requirement linked to the file being edited must keep true) and background maintenance:
{
"mcp": {
"kibi": {
"type": "local",
"enabled": true,
"command": ["npx", "--no-install", "kibi-mcp"]
}
},
"plugin": ["kibi-opencode"]
}
Add Kibi to .vscode/mcp.json:
{
"servers": {
"kibi": {
"type": "stdio",
"command": "npx",
"args": ["--no-install", "kibi-mcp"]
}
}
}
Any stdio MCP client works with command: npx, args: --no-install kibi-mcp. ZCode also has an optional plugin, installed from a local checkout, whose edit hook shows the same requirement context as the Claude Code plugin; see the ZCode plugin guide. Agents without MCP can use the same operations through the CLI's JSON routes.
What your agent gets
Kibi's skill subsystem gives the agent seven bundled skills that teach it how to work with Kibi (including kibi-provable-code, on writing code whose rules Kibi can prove), so you do not paste a long system prompt, and a small set of MCP tools does the rest:
- Plain-language answers. Ask "what governs checkout rounding?" and
kb_searchreturns the current requirements, the tests and decisions behind them, and what Kibi's checks say about each. - A review of every change.
kb_checkon the files the agent touched quotes the requirements that code implements and flags new code no requirement covers. - Safe writes. Every write can be previewed first, and a plan you approve lands in full or not at all.
- Other repositories' knowledge, read-only. Declare a repository your code depends on in
.kb/dependencies.json, pin it withkibi deps lock, andkb_search(orkibi search --kb <name>) answers from that repository's own KB at the pinned commit. Its KB stays separate from yours, is never written to, and can be on an older KB schema (6 or later).
The MCP reference lists every tool. Generic agents can start from agent onboarding.
See how strong each guarantee is
npm exec -- kibi report --open
kibi report writes a self-contained kibi-report/index.html and kibi-report/badge.svg from one coverage snapshot. % tested is the share of current requirements with fresh end-to-end evidence on the current code; the report lists what is tested, what is missing evidence, what contradicts, and what has gone stale.
Every requirement also carries an evidence level, so no guarantee reads stronger than what backs it: proved (every claim of the requirement holds for every case, backed by fresh certificates from an exhaustive, typecheck, arithmetic, smt, rule, state_machine, regex or source proof contract that names the claim, which a separate checker re-checks; claims need not be numbers: permission rules, every-member properties, state transitions, states that can never be reached, required fields and string formats are decided exactly against the code, and a source proof checks routes, database schemas, configuration, validators and code references that Kibi reads from the project itself), tested (fresh end-to-end receipts cover every linked scenario), asserted (a person stands behind it, but nothing current checks it) and unverified (an agent wrote it and no person approved it). kibi coverage returns evidenceLevel per requirement and summary.evidenceLevels counts; the report and kibi signoff show it next to firmness. See the proof ladder, proving requirements for the certificate proof kinds, and reading the report.
The knowledge base itself is checked the same way. kibi check (and kb_check for agents) proves that the facts your requirements state are consistent (one value satisfies every fact on a property, every decision has one outcome) and that stored rules are stratified, and leaves a certificate for each answer that a small separate checker re-checks. It also catches facts that contradict only together, which pairwise checks miss. A contradiction comes back as the smallest set of facts that cannot hold at once; anything it cannot compare is reported as unresolved, never as consistent.
Before you sign off on a change, kibi signoff shows the requirements it adds, rewrites or affects, each quoted with its firmness, proof state and evidence level, and kibi signoff --questions numbers the decisions waiting for you next to the rule each one would change. Agents put the view in their reply as plain Markdown, so it renders wherever the agent writes, including chat apps and cloud sessions where replies go through a messaging tool; the same view is a self-contained page in .kb/briefs/signoff/latest.html. Claude Code, Cursor, ZCode and OpenCode add a /kibi-signoff command, OpenCode draws the view as a card, VS Code opens it in a panel, and the agent hooks ask for it once a session has written requirements.
To publish the report and a clickable badge on GitHub Pages, run npm exec -- kibi init --github, then enable Settings → Pages → Source → GitHub Actions. The GitHub integration guide covers the report workflow, badge-only publishing, and a CI step that keeps pull requests mergeable when only Kibi's own files conflict. Symbol line positions are never committed: every kibi sync derives them into a gitignored cache, so two branches that edit the same source file do not conflict over them.
For day-to-day inspection, kibi status, kibi search, kibi gaps, kibi coverage, and kibi check are in the CLI reference.
How it works
Kibi combines probabilistic interpretation with deterministic verification:
Human prompt
|
v
Agent updates code and product knowledge
|
v
Requirements + semantic facts/rules + scenarios + tests + symbol links
|
v
Prolog coherence checks + traceability gates + fresh E2E evidence
|
v
Tested result or explicit, repairable gaps
The agent never writes arbitrary Prolog as trusted truth. It works through typed facts, predicate schemas, and safe logic representations; Kibi validates those encodings before the Prolog layer uses them for inference.
What Kibi enforces
Kibi maintains a canonical traceability and proof chain:
Requirement -> Scenario -> Test
^ ^
| |
Production symbol Executable test symbol
For a requirement to be tested end to end rather than merely documented:
- Every production symbol must trace to the requirement it implements.
- Every normative requirement clause must be modeled as typed facts or stay explicitly unresolved.
- Requirements must be specified by scenarios, and tests must verify those scenarios. A success scenario that assumes something a current requirement forbids blocks proof.
- Executable test symbols must identify the code that actually performs the verification.
- Proof-bearing production symbols must be covered by qualifying tests, and the pre-commit hook applies the same rule as the full check.
- End-to-end evidence must be fresh and bound to the current code snapshot, so CI and a local checkout of the same commit agree.
That makes questions answerable in both directions: which requirement owns this symbol, what this E2E test actually verifies, which requirements lack a scenario or current evidence, and whether two current requirements contradict each other. Code coverage alone cannot answer them: it shows that a test touched a line, not which product behavior was exercised.
Prolog as the safety layer
Suppose the product defines exactly three user roles. Once that constraint is encoded as a strict property or predicate, an agent cannot quietly invent a fourth role and treat it as established intent: Kibi can surface the contradiction or missing authorization deterministically.
Kibi does not report "no conflict" when it could not tell. Numeric constraints are compared exactly ("greater than 0" conflicts with "equals 0"), an allow and a deny for the same action contradict, and anything Kibi cannot model is reported as unresolved for the agent to review, never as a clean pass.
Prolog does not decide whether the original human intent was correct. It verifies the knowledge that was encoded, while Kibi keeps ambiguity, missing ontology, incomplete grounding, and stale evidence explicit instead of calling them proof.
Why this is possible now
Traditional knowledge bases required specialists to design ontologies, write formal logic, and maintain every mapping by hand. LLMs change the economics of that authoring step, and Kibi and Prolog supply the discipline:
| Participant | Strength and responsibility |
|---|---|
| Human | States product intent and resolves real ambiguity or policy choices |
| AI agent | Maps intent to the codebase and maintains requirements, scenarios, tests, facts, and symbol links |
| Kibi + Prolog | Validates schemas, checks coherence and contradictions, enforces traceability, and evaluates proof evidence |
The result uses LLM strengths to address LLM weaknesses: limited memory, hallucination, context drift, and the loss of the product-to-code mapping traditionally spread across product owners, ticket systems, and planning boards.
What Kibi models
Eight entity types: req, scenario, test, fact, adr, flag, event, and symbol. The entity schema has the complete model.
Every entity records who authored it, a person or an agent, and advisory checks list agent-written requirements no person has approved.
Requirements and ADRs also say how firmly they were decided. A firm rule is one a person stated: it points at their words, the agent asks before changing it, and Kibi refuses to rewrite it quietly. A default choice can be revisited on evidence, and exploratory marks a guess. Every supersede has to say why it changed. How Kibi works has the details.
Kibi MCP questions
How do I add Kibi MCP to Claude Code?
Run claude mcp add kibi -- npx -y kibi-mcp in your terminal. Add --scope user to make it available in every project.
How do I add Kibi MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does Kibi MCP provide?
It exposes 16 tools, including kb_query, kb_search, kb_status, kb_skills, kb_find_gaps.
What does Kibi do for AI agents?
Kibi acts as an enforcement layer that helps agents remember product intent, maintain structured requirements, and prove that code implementations remain coherent with that intent.
Is my knowledge base data sent to a cloud service?
No, the knowledge base state is stored locally in your repository's .kb/ directory and is never sent anywhere.