Frequently Asked Questions

KaKeKiKoKu Studio (Knowledge Engine) keeps the reasoning behind your project — decisions, intent, rejected alternatives, the traps you only learn the hard way — in structured files that live beside your work, so your AI starts every session already knowing the project. Three ideas make it work:

• Knowledge survives between sessions. The “why” is captured next to your files, not lost in a chat that disappears. Every new session — and every future AI — inherits it instead of starting blind.
• Knowledge lives in bounded blocks, not walls of text. Each unit is a small block with its own identity, and relations connect block to block. That limit is the strength: an AI reasons cleanly about a bounded block; a 50-page document it can only summarize.
• Your AI opens the project with an always-fresh map. It gets each block’s description up front and drills in on demand — spending context on what matters, not re-reading everything. KaKeKiKoKu detects drift and the AI keeps the map in sync.

Used mostly for software, but it works for any project with knowledge worth keeping. Core engine free forever.

KaKeKiKoKu runs locally on your machine as a lightweight server. It connects to your AI through the MCP (Model Context Protocol) standard. When you open a project, KaKeKiKoKu delivers the full knowledge structure to your AI. As you work, it monitors your files for changes, detects when knowledge falls out of sync, and notifies your AI to update the documentation.

You interact with KaKeKiKoKu through two interfaces: a web UI (for browsing, editing, and managing knowledge visually) and your AI's chat (for commands like sync, read, edit, and search). The AI does most of the documentation work. You review and validate.

No. KaKeKiKoKu works with any type of project — software, screenplays, research, travel planning, anything with files and knowledge worth preserving. You do need to be comfortable working with an AI assistant, since KaKeKiKoKu operates through AI interaction, but no programming knowledge is required.

Each of those is good at its job. None of them is where project knowledge should live.

Context files (CLAUDE.md, AGENTS.md) live in the repo, which is the right instinct — but they are flat documents, injected whole every session, updated by hand, and they go stale in silence. Nobody verifies them against reality.

Built-in AI memory is the least portable persistence there is: it lives in your machine and your tool, it is invisible and unstructured, it does not travel with the repo, and it does not transfer to any other AI.

Skills and rule files carry reusable procedures — how to do things. They are genuinely useful, and they are complementary to KaKeKiKoKu. But they do not carry your project’s decisions, constraints, and state.

KaKeKiKoKu is a structured, living system in your repo. Purpose-built sections capture what exists, what was decided, what was rejected and why, what can break. Intelligent summaries keep token cost low; the AI drills deeper only when needed. Real-time monitoring detects when knowledge falls out of date. And — this is the part the others simply do not do — KaKeKiKoKu actively makes the AI capture what would otherwise be lost, working as a knowledge archivist while it works on your tasks.

The difference is the gap between a sticky note and a knowledge management system.

There is a full, honest comparison — including when each of the others is enough — at Where should your AI’s project memory live?

Absolutely. KaKeKiKoKu does not know or care what your files are. It works at the knowledge level, not the syntax level. Software, novels, doctoral theses, screenplays, travel plans, business documentation — if it lives in a folder and has knowledge worth preserving, KaKeKiKoKu can manage it.

KaKeKiKoKu documents itself using its own system. The entire KaKeKiKoKu codebase has sidecar files that capture the decisions, architecture, rules, and traps of each component. Every AI session that works on KaKeKiKoKu starts with full knowledge of the project. This is called dogfooding — using your own product to build it — and it is the strongest validation that the tool works.

Fully compatible. KaKeKiKoKu files are plain text, designed to live alongside your project files and be version-controlled normally. Commit them and your knowledge evolves with your code — every decision, every rejected alternative, tracked in your repository history.

If you prefer to keep knowledge files out of your repository, add *.wuniq and .wuniq/ to your .gitignore. Both approaches work. I recommend including them — your project's knowledge is as valuable as its code.

It is the opposite of a problem. It is a deliberate design choice.

KaKeKiKoKu serves two types of users: humans and AIs. The AI works actively with KaKeKiKoKu — it reads knowledge, writes knowledge, synchronizes, detects issues, updates documentation. If the tool was designed only from a human perspective, the AI's experience would suffer, and that would degrade the results for everyone.

Claude Opus was used extensively throughout KaKeKiKoKu’s development. It tested every feature from the AI side, surfaced friction points, and helped validate that the structured knowledge format works in practice. Later validation with Codex and Antigravity broadened the same idea beyond the original agent. The result is a product that understands what an AI needs to do its best work — not because someone guessed, but because AIs were part of the design process.

This is not AI replacing human judgment. It is a human and an AI designing a product together for both of them. That is exactly what KaKeKiKoKu is about.

No. KaKeKiKoKu is independent. It uses MCP, an open standard originally created by Anthropic, because MCP is the cleanest way for an AI client to connect to local project tools.

Claude Code currently has the deepest integration because it is the only client with channels today. That is not a KaKeKiKoKu limitation; it is the current state of AI clients. KaKeKiKoKu also works with Codex, Antigravity, Claude Desktop, and generic MCP clients in Precise mode.

Because your AI client already has the chat. KaKeKiKoKu is the knowledge layer and MCP tool server: it gives the AI structured project memory, sync, search, sidecars, and context.

Adding another chat would add cost, complexity, and provider lock-in. KaKeKiKoKu is designed to complement the AI environments you already use, not replace them.

It is not a limit. It is a design bet.

KaKeKiKoKu stores knowledge in bounded atomic units: each section and subsection holds up to 4,000 characters, and every folder sidecar, file sidecar, or entity holds up to 52,000 characters of prose. A resource can contain up to 30 top-level sections (including _description) and 60 subsections in total. Relations don’t eat into the prose allowance: they carry a budget of their own — up to 12 outgoing per resource, with 200-character descriptions. Inside those caps, you compose freely. Outside them, you don’t — on purpose.

The reason: bounded blocks are what your AI handles cleanly. A wall of free-form text overflows attention, burns tokens, and dilutes signal. Atomic blocks with their own identity travel better, get reused, get linked, and let the AI reason about them one at a time.

The corollary is uncomfortable and useful: if your plan doesn’t fit in a block, the plan is poorly split — not KaKeKiKoKu running out of room. The size cap becomes a canary that tells you when a section is hiding two sections, or when an entity is covering two topics. The discipline pays off.

This is the same idea behind the Markdown editor that works block-by-block, the relations that point to blocks (not to paragraphs or words) and are bounded themselves — twelve meaningful links beat forty vague ones — and the images with their own sidecars (knowledge) versus Markdown-embedded images (decoration). See the user manual for details.

KaKeKiKoKu is compatible with MCP-capable AI clients and works best with frontier models that use tools reliably and reason well over large projects. The exact best model will change. KaKeKiKoKu’s job is to preserve the project knowledge so capable agents can use it.

Claude Code has the richest automatic flow today because it is the only client with channels. Codex, Antigravity, Claude Desktop, and generic MCP clients work in Precise mode with the same structured knowledge.

Yes. Because knowledge lives in the project, not in a conversation, any AI that opens the same folder can read the same decisions, constraints, rules, and pending issues. You can move between Claude Code, Codex, Antigravity, or another MCP client without throwing away the project memory.

The practical advice is simple: let one AI finish a coherent batch of work, run sync, then let the next AI pick up from that updated knowledge. KaKeKiKoKu is the shared memory layer; the agents still need disciplined handoff.

KaKeKiKoKu handles large projects efficiently. When the AI opens a project, it receives a structured overview with intelligent summaries — not the full content of every file. The budget system controls how much information is delivered, ensuring the AI gets the big picture without overwhelming its context window. It can then drill deeper into specific files as needed.

You can also configure excluded patterns (like node_modules, build folders, etc.) so KaKeKiKoKu only tracks what matters.

No. KaKeKiKoKu is progressive context, not a context dump. The AI gets a structured map first and reads detailed sidecars only when needed. A traditional context document is all-or-nothing: either the AI reads the entire file or it gets nothing.

There is a deeper point. Without project memory, every session starts with the AI excavating — blind searches, wrong files, re-reading what it already read yesterday. That spend repeats every session and leaves nothing behind. Documenting knowledge with KaKeKiKoKu is also work for the AI, but it is an investment that stays in the project instead of a toll paid over and over. On large, long-lived projects the difference is substantial — and an oriented AI takes fewer wrong turns, which is the cheapest token of all: the work you never redo.

System: Windows, and Linux through the Snap Store. macOS is planned — no date committed yet.

AI: use a frontier model with strong reasoning, reliable tool use, and a large context window. Claude Opus is excellent, ChatGPT/Codex is validated in real use, and models from Asian labs have improved enough to work well with KaKeKiKoKu too. Any of them reaches KaKeKiKoKu through an MCP-capable environment.

AI client: Claude Code gives the deepest automatic integration today because it is the only client with channels support. Claude Desktop Code tab, Codex, Antigravity, and generic MCP clients work in Precise mode.

Setup: Install KaKeKiKoKu, register it as an MCP server in your AI client, choose Automatic or Precise sync mode, and follow the Quick Start for your client.

KaKeKiKoKu is designed to never touch your project files on its own. It only creates and manages knowledge files: sidecars alongside your files, plus its own configuration folder. You can configure excluded patterns to tell KaKeKiKoKu to ignore specific folders or file types. You can also dismiss individual files that do not need documentation.

This is a fundamental design rule of KaKeKiKoKu. It only creates, reads, and modifies knowledge files, and it never edits your work on its own. The AI that works with KaKeKiKoKu may modify your project files (that is its job), and a few explicit Web actions you trigger yourself — such as creating a Markdown file or duplicating a resource together with its context — create real files as conveniences. KaKeKiKoKu itself only manages knowledge.

KaKeKiKoKu files are plain text and fully compatible with Git. You can version-control your knowledge alongside your code — in fact, this is recommended. If your organization prefers not to include knowledge files in the repository, simply add *.wuniq and .wuniq/ to your .gitignore file. Either way works perfectly.

The basics take minutes, and KaKeKiKoKu itself teaches them. It ships with the Learning Lab: a real KaKeKiKoKu project built to be explored as an interactive tutorial. When you choose your working folder, KaKeKiKoKu offers to set it up — in your language, one click. Ten stops cover files with memory, folders with rules, entities, relations, and sync, plus a playground with guided exercises where breaking things is part of the lesson. It even works before you connect an AI.

Beyond that, contextual help dialogs appear the first time you use each feature, so you learn as you go rather than reading a manual upfront. Getting the most out of KaKeKiKoKu takes a few days of regular use.

KaKeKiKoKu runs entirely on your machine. It stores all data on your filesystem and has no accounts, no telemetry, no analytics, and no ads. Your knowledge files are plain text files on your disk that you fully own and control.

The only network communication is between KaKeKiKoKu and your AI (through your IDE’s MCP connection), which uses your existing AI subscription. When your AI reads project knowledge, that data is processed by your AI provider according to their privacy policy — not by KaKeKiKoKu.

Yes. The complete addressable guide KaKeKiKoKu gives to AI agents — the introductory help plus every detailed help <topic> response for workflow, commands, product, Web app, format, and rules — is published verbatim at The KaKeKiKoKu AI Guide. No hidden prompts. It is regenerated with every release, so what you read there is exactly what your AI can retrieve.

KaKeKiKoKu’s core — knowledge management, context, structured sections, synchronization, relations, all MCP integration — is free, with no plans to change this.

In the future, advanced plugins, deep OS integrations, and specialized IDE connectors will be offered as premium extensions to support development. But the rule is clear: if it affects the base knowledge engine or the standard MCP connection, it remains free. Always.

KaKeKiKoKu includes built-in contextual help, a user manual, and this FAQ. For additional support, you can reach out via email. Community support through forums and discussion channels is planned as the user base grows.

Here is the honest arc. KaKeKiKoKu has been in continuous development for a year and shipping since April 2026. The early releases were alphas with rough edges — they worked, but they had only been tested against KaKeKiKoKu’s own codebase. The real turning point came when KaKeKiKoKu was taken outside its own box: fresh AIs using it blind on unfamiliar projects, real work on projects that were not KaKeKiKoKu itself. That round surfaced dozens of bugs, they were fixed one by one, and that is when KaKeKiKoKu earned the Beta label — not before.

The current release is a deliberate stabilization point: feature work is paused in favor of polish and stability updates. And whatever happens, your knowledge is plain text in your own repo — readable with or without KaKeKiKoKu.

The core is complete and in Beta: local structured knowledge, MCP integration, automatic sync where channels exist, and Precise mode everywhere else. The current focus is stability and polish rather than new features — a deliberate pause after a year of continuous development, with a long list of ideas waiting for their turn.

As the MCP ecosystem matures, more clients will gain deeper automation, and KaKeKiKoKu is built to take advantage of it. The goal has not changed: to make structured knowledge management the standard way professionals work with AI.

Your knowledge is safe regardless. Knowledge files are plain text files stored in your project directory. They are human-readable and can be opened with any text editor. Your knowledge is never locked inside a proprietary format or a cloud service. Even without KaKeKiKoKu, the files remain useful as structured documentation.

Additionally, the creator of KaKeKiKoKu makes a public commitment: if the project is ever abandoned and no one is assigned to continue it, the intention is to publish the source code as an open platform, with the sole restriction that no one may appropriate the KaKeKiKoKu brand or release products under its name. The source code is documented within KaKeKiKoKu itself and maintained through AI-assisted workflows — which means any capable AI connected through KaKeKiKoKu can continue developing and maintaining it. You would not even need to know how to program to do so, since KaKeKiKoKu is a demonstration of its own power.

They stay in your project as plain text files. You can read them, edit them, or feed them to any AI manually. They are structured text with clear section headers — perfectly readable without KaKeKiKoKu. There is no vendor lock-in. Your knowledge belongs to you.

KaKeKiKoKu also includes a one-click Export Knowledge feature that converts your entire project’s knowledge into a single standard Markdown file — readable by any tool, anywhere. Since KaKeKiKoKu is free, you can always come back whenever you want.