Frequently Asked Questions

KaKeKiKoKu Studio is a knowledge system for projects you build with AI. A project is its knowledge — decisions, intent, rejected alternatives, the traps you only learn the hard way. You shape it with your AI, any AI, and Studio keeps it in structured files beside your work, connected and in sync, so every session starts 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.

It is built for professionals with complex, long-lived projects: software and engineering first, and also research, technical documentation and other demanding work. Core engine free forever.

KaKeKiKoKu runs locally on your computer. Your AI connects through local HTTP using a startup instruction file, or through MCP. Opening a project returns its root context and a resource map; the AI reads more as needed. Studio detects file changes and reports knowledge that needs review. Background delivery to the AI requires MCP channels; with HTTP, use Precise mode and ask the AI to run sync.

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). You and your AI shape the knowledge together: the AI does most of the writing, and you review, adjust, 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.

They can work together. Instruction files hold working rules, client memory retains information according to that client's design, and skills carry reusable procedures. Their structure, visibility, and portability vary by implementation. KaKeKiKoKu holds something different: the project’s own knowledge, which belongs to the project and to you rather than to any AI client.

KaKeKiKoKu keeps structured knowledge beside project resources, connects it with explicit relations, and detects changes that need review. You and your AI maintain its meaning; sync does not certify every statement as true.

See Where should your AI’s project memory live? for the detailed comparison, including Obsidian and cases where simpler tools are enough.

Yes. KaKeKiKoKu does not know or care what your files are: it works at the knowledge level, not the syntax level. Research papers, scientific studies, doctoral theses, legal cases, technical documentation, worldbuilding: if the work runs for months and its decisions depend on each other, it fits. What matters is size and duration, not the kind of file. On a short, simple project the bookkeeping costs more than it saves.

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.

KaKeKiKoKu is developed by its creator with both Claude (Anthropic) and ChatGPT/Codex (OpenAI) as complementary tools. Both contribute to building and improving the product, with project knowledge shared through KaKeKiKoKu itself.

That collaboration matters because KaKeKiKoKu serves humans and AIs. Working with different AIs helps test ideas, find friction, and understand what each needs to use the knowledge effectively. The creator sets the direction, reviews the work, and makes the final decisions.

The development process is open to other capable AIs joining alongside them in the future. The knowledge stays with the project, so another AI can build on what previous sessions have learned.

No. KaKeKiKoKu is an independent product, with no commercial, organizational, or development affiliation to Anthropic, OpenAI, or any other AI provider. Using their tools during development does not imply a partnership or endorsement.

The quickest way to start, best for a first look at a small project, uses one instruction file and local HTTP. For everyday work, and because over HTTP the AI takes more steps and can use somewhat more tokens, we recommend MCP, an open standard that gives your AI a dedicated KaKeKiKoKu tool and can start Studio when needed. Your project knowledge remains in your files and uses the same command language through either connection.

Because your AI client already has the chat. KaKeKiKoKu is the knowledge system: it keeps your project’s knowledge structured, connected, searchable, and in sync, and gives it to whichever AI you use.

What the web UI does have is Talk to AI: a 🤖 button and context-menu action on a file, folder, section, or subsection. It prepares a request that includes the context of what you are viewing and hands it to your AI client — sent directly in Automatic mode, or copied to your clipboard in Precise mode so you paste it when you decide. The conversation itself stays in your client.

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 20 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 — twenty 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.

A local AI client needs to load startup instructions and make HTTP requests from your computer, or support MCP. Choose a model that reasons well and uses tools reliably. The common guide explains the requirements and first-use check; an instruction filename alone does not prove compatibility.

Supported clients use the same structured project knowledge. The interaction depends on the client’s capabilities: Automatic mode requires a supported interactive channel; Precise mode lets you explicitly request operations. The integration guides describe the available workflow for each client.

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 compatible client without throwing away the project’s knowledge.

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 holds the shared knowledge; 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 knowledge, 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. Recording 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 capable model with strong reasoning, reliable tool use, and enough context for your project. Claude and ChatGPT/Codex are both used in KaKeKiKoKu’s development; other capable models can work through a local client with HTTP tools or MCP too.

AI client: use a local coding agent with a shell or another tool that can reach Studio over HTTP. MCP is recommended for everyday work. Automatic mode requires an MCP client that delivers channels; use Precise mode for HTTP.

Setup: install and open Studio, make your project available, and add the shared instructions to your client’s startup file. Start a new conversation. The Quick Start covers the complete route.

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.

KaKeKiKoKu does not autonomously edit your project work. Its knowledge commands manage context. In the Web UI, you can explicitly create, duplicate, move, rename, or delete resources and edit real Markdown or text files. Your AI client can also change project files through its own tools. Review the results of actions you request.

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 context, 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.

Studio serves requested context locally to your AI client through HTTP or MCP. If that client uses a hosted model, it may send the context to its provider under that provider’s privacy policy. Studio does not route it through a KaKeKiKoKu cloud service.

The introductory help and every help <topic> response for workflow, commands, product, Web app, format, and rules are published verbatim at The KaKeKiKoKu AI Guide. The page identifies its version and capture date. Your installation's help is the reference for its available commands; tool descriptions, command results, and your own project context also guide the AI.

KaKeKiKoKu’s core — knowledge management, context, structured sections, synchronization, relations, local HTTP and MCP integration — is free.

KaKeKiKoKu includes built-in contextual help, a user manual, and this FAQ. For additional support, you can reach out via email.

Yes. KaKeKiKoKu is ready to rely on for everyday work. Occasional bugs can still occur, which is why it remains in Beta.

Stability always comes first. Whenever a bug is found, fixing it takes priority over developing new features.

Your help makes a difference. If you encounter unexpected or faulty behavior, please report it by email. Every report and request will be considered.

I actively develop KaKeKiKoKu because I enjoy it. Building it is a pleasure, and exploring what it can become is fun. I do not depend on income from the project or on anyone funding it, so I have the freedom to keep developing something I believe in.

There have been many difficulties along the way, and there will be more. They do not take away the enjoyment that keeps me working on it. I am committed to many more years of ideas, improvements, and development: KaKeKiKoKu is moving forward, and it will keep moving forward.

The goal is to help people keep their project knowledge useful and connected as they work with AI. You can explore the ideas taking shape in the public roadmap.

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.