KaKeKiKoKu Studio

Knowledge is the project.
The result is a byproduct.

Working with AI quietly changes what you’re building. You create; your AI brings intelligence and execution. You build in cycles — work, review, refine, accumulate — and each cycle generates knowledge: decisions, constraints, intention. That knowledge is what you’re really building. Code, chapters and plans are how it shows.

Without a place of its own, that knowledge resets every session. It stays in a conversation, in one provider’s memory, in your head. Your review has no context, and nothing accumulates.

Forgetting also has a price tag. Resume a long conversation days later and your AI re-reads its entire past at full cost — the provider caches that made it cheap expire minutes after you leave. A fresh session with KaKeKiKoKu loads the map and only the knowledge it needs: continuity for a fraction of the tokens.

And it scales with you: work across many projects at once — code, documentation, research — and pick the exact slice the AI sees each session. You decide what it gets to see; it does the work.

KaKeKiKoKu Studio exists to give that knowledge a home.

Continuity, by design The session ends.
The knowledge stays. Different conversations.
One accumulating body of knowledge.

Session 01 Decide
Choose the direction.

Agree that the project keeps its data local.
A decision takes shape

The AI records the decision
Project knowledge
- Keep data local
Session 02 Build
Start with the why.

Use that decision to build the storage layer.
Reads the previous decision

The AI adds a rule
Knowledge accumulates
- Keep data local
- No external requests
Session 03 Refine
Continue with context.

Improve the implementation within its constraints.
Reads the decision and the rule

The AI updates the file context
Ready for the next session
- Keep data local
- No external requests
- storage.py · implementation

The Problem

With AI you can build fast. What it doesn’t do on its own is keep the knowledge behind your project: why things are the way they are, what was ruled out, what must not break.

A metaphor for the traditional workflow: the work moves forward, while its knowledge stays scattered and falls behind. With AI, the knowledge behind a project matters as much as the project itself.

Three separate archives with interrupted copper connections and loose pages between them — Lost decisionsUnreported issuesOut-of-date context

Your decisions stay in the conversation.

When you work with your AI, the conversation fills up with decisions, constraints, nuances, discarded alternatives. That is the knowledge of your project — but it lives in a chat, not in the project. The AI treats it as input for its answer; once your request is resolved, the reasoning is gone. The result stays, the why does not.

Context windows are finite and conversations end. Your provider may offer summaries or memory — useful, but kept in the provider’s storage and shaped for the conversation, not structured knowledge that belongs to your project. The result: every session you start worse than you finished, repeating context, decisions and even mistakes you had already solved.

You can mitigate this by writing context documents yourself, or asking your AI to generate them. But that costs time, and handcrafted docs are all-or-nothing: either the AI gets the full text burning tokens, or it gets nothing.

Problems get buried in the output.

AIs are built to resolve your request. When they find a secondary problem — a bug, an inconsistency, a design flaw — they weigh it against that goal. If it does not block them, it gets a line in passing.

Nobody is failing here: the AI is doing exactly what it was built to do. But the faster the work goes, the less you see. Real problems end up buried in long outputs, and, let’s be honest, you read AI output like compiler logs: the first lines and the last. If a problem sits in the middle, you never get to decide about it.

You change your project and knowledge falls behind.

This is the oldest pain in any project. You move forward — write, restructure, fix, iterate — and the knowledge around the work rots. You know it should be updated. You will do it later. Later never comes.

With AI it is worse. Your AI generates changes faster than any human can add context to them. So you create a master document — a single file with all the context. It works for a day. Then reality moves on, the document falls behind, and now you have something worse than no documentation: documentation that lies. Your AI reads it, trusts it, and makes decisions based on yesterday’s truth.

The Solution

Your AI starts oriented, not lost.

Open a project and your AI gets its bearings in one step: the root context with the project’s purpose and rules, the top level of the project with a description of each item, and the resources you marked as important, which it reads before anything else.

It doesn’t swallow the whole project. It starts from that map, then drills into specific resources on demand — the right level of depth at the right time, at minimal token cost. See what it reads first

See how it all connects.

Relations in KaKeKiKoKu don’t point at words — they point at blocks with identity: a section, a file, a decision. Draw them by dragging one block onto another; follow them as arrows across the panels.

The tree lists the relations of every resource and block, incoming first, then outgoing, and takes you to the knowledge at the other end with one click or from the keyboard. When you only want to read it, click the relation in the editor, or Alt+click it in the tree: the block opens read-only under the text you’re editing, and you keep your place. Switch to the project map and the whole graph becomes visible: what connects to what, and why. It’s the same map your AI navigates — now in front of you.

KaKeKiKoKu Studio with a decision open in the editor and the navigation tree listing its incoming and outgoing relations in place, with arrows from the tree to the related blocks — The tree lists each resource’s relations in place, incoming first, then outgoing. The arrows follow them to the blocks in the editor.

The map first. Then the meaning.A relation connects identified blocks.

01 Get oriented

See the structure before opening the detail.

Project mapStructure · descriptions · state

Productroadmap.mdresearch.md
Datastorage.pyschema.json
Interfacedashboard.tsxtheme.css

The taskImprove local storageFollow the connected knowledge

02 Follow the relevant route

ProjectThe living index
What exists, where it lives, what matters.
orients the AI
DecisionKeep data local
The reason behind a design choice.
sets a constraint
RuleNo external requests
The boundary that the work must respect.
applies to a file
Filestorage.py
The real resource, with its own context.
read with understanding

03 Read the blocks you need

The decision, the rule, and the file context — ready for this task.

DecisionRuleFile context

An illustrative path through project knowledge.

Decisions no longer get lost.

While the AI works, KaKeKiKoKu guides it to capture what matters: why it was done this way, what was rejected, what must not break. Knowledge lives in the project, not in a conversation that disappears.

Design decisions land in _soul. Rejected alternatives in _whyNot. Invariants in _rules, traps in _careful. Next session — same AI or a different one — the reasoning is right there.

KaKeKiKoKu Studio in a light theme, rendering a release plan as a Markdown table with the reason for each feature and a checklist, and, underneath, the consult area showing the principle the plan follows — A plan written as knowledge: what ships and **why it matters**. Underneath, the consult area shows the principle it follows, read-only, without leaving the plan.

Your AI reports what it finds.

KaKeKiKoKu asks the AI to stop and report the problems it noticed while working, instead of burying them in output. That includes what only felt off or fragile, before it has a clear reason, and the loose ends you left behind: an unfinished idea, a decision still hanging.

The knowledge gets the same treatment: ghost contexts, files without context, broken references, out-of-date context. Your AI finds them when it runs sync and resolves them as part of its work. The sync panel shows each one as it appears, so you can see what is going on, and if you get there first, one click prepares the request for your AI.

Knowledge that keeps up with your project.

KaKeKiKoKu watches your project in real time, so you see the moment files and knowledge diverge. Your AI isn’t interrupted for every change: it works in batches, and when it finishes one, it runs sync and brings the knowledge up to date in one go. It won’t make documentation fun, but it will tell you when it starts lying.

Changes made outside the conversation, by you or by another tool, wait in the panel. By default you decide when your AI deals with them, and KaKeKiKoKu prepares the request. With Claude Code you can turn on Automatic mode, and KaKeKiKoKu tells your AI itself. A clean sync means files and knowledge are in step, not that every sentence is true. Live counters in the status bar show the health of your project at a glance.

Files change. Meaning stays connected.

01
The file changes
The project moves forward.
02
Sync detects out-of-date context
A difference becomes visible.
03
The AI revisits the context
At the end of its batch, not mid-task.
04
You see the result
And decide what only you can.

The next session starts from here.

KaKeKiKoKu Studio with a changed source file open under an out-of-date notice, and the Synchronization panel on the right listing a broken relation, out-of-date context, a recent file without context and a ghost context — On the right, the **SYNCHRONIZATION** panel lists what slipped through: out-of-date context, a ghost, a file without context and a broken relation, each one ready to resolve. Above the open file, a notice says its context is out of date.

Change a decision, and what depends on it gets a second look.

Relations already say which blocks belong together. They also keep track of what each end said when the connection was last accepted. When a decision, a rule or a description changes, KaKeKiKoKu flags the knowledge at the other end of each of its relations, whichever way the relation points, so nothing goes on quietly contradicting it.

In everyday work most reviews come from your AI’s own edits, and your AI settles them as it goes: it reads the other end, edits what no longer holds and gives its conformity to what still does. You see them in the sync panel and in the tree, and take the ones that need your judgment. When you edit connected knowledge yourself, Save asks for a review and Just save is for typos. Edits made outside Studio are caught by sync too. How reviews work

Knowledge changes. Its connections hear about it.

01
A decision changes
Saved as a change that matters.
02
Connected blocks are flagged
Through every relation, incoming or outgoing.
03
Your AI takes a look, or you do
What no longer holds gets edited.
04
Conformity closes the review
What still holds stays as it is.

Fixing a typo? Just save, and nothing gets flagged.

KaKeKiKoKu Studio with an export decision open after a change, and the Synchronization panel listing two relations to review: the guide that describes the decision and the code that follows it — A decision changed. The guide that describes it and the code that follows it, one at each end of its relations, are now waiting under **Relations to review**.

Search, read and edit without leaving the app.

Search shows where every match lives — in the knowledge, in the file content, or in a name — with its section or its line, and takes you there in one click. Source-code matches open at their line, highlighted in the viewer. Put a phrase in quotes to find those words together, and narrow the search to the project you’re in or to names, knowledge or file content.

Quick viewers open your code and documents (.docx, .odt, .pdf) without leaving KaKeKiKoKu. A block-level Markdown editor with a formatting ribbon edits knowledge in place — and whole blocks of knowledge can be moved between resources by dragging them.

KaKeKiKoKu Studio searching file contents for Today: five results on the left, with src/taskStore.ts open in the read-only code viewer, scrolled to the highlighted matching line 47 and showing syntax highlighting and line numbers — Searching file contents for “Today”: opening the result jumps to line 47 and highlights it in the code viewer.

Knowledge that works beyond the AI.

The knowledge you capture is useful outside the chat, too. Export everything to standard Markdown with one click. Generate reports built from your project’s real-time state, then enrich them with AI that has both the report and the full project context.

Your data stays yours: the knowledge format is plain text and publicly documented, so there is nothing to lock you in. The reports are a starting point; you decide what to ask next.

A report is a starting point.

01KaKeKiKoKu generates
A report from the project’s real-time state.
02AI enriches
With the report and the full project context.
03You decide
What to ask next.

Full Export Standard Markdown — zero lock-in

Executive Summary + AI High-level overview for stakeholders

Pending & Drafts + AI What’s incomplete — you set the priorities

The Loop

Your AI changes the files.
KaKeKiKoKu notices, so the knowledge can catch up.

Put together, it works as one cycle, inside the AI client you already use:

The AI changes real files

Code, documents, chapters, research, plans. The output lives in your project, not inside KaKeKiKoKu.

KaKeKiKoKu detects what changed

File changes, missing context, stale knowledge, broken references, resources without context, relations to review.

The AI updates the knowledge

When it finishes a batch of work, it runs sync and records decisions, rules, traps, rejected alternatives and relations, structured for future sessions.

You see where it stands

What the AI knows, what is out of date, what is missing. You step in only where your judgment is needed.

You watch and steer from the web UI. The engine does the bookkeeping between your files, the AI’s work and the knowledge.

What runs underneath.

It looks like one app. Underneath, eight engines keep your files and their knowledge in step.

KnowledgeContexts, entities, sections — knowledge in bounded blocks.

RelationsExplicit connections between blocks. A navigable graph that flags what to review.

SyncReal-time detection of files that changed after their context. Your AI catches up when it finishes a batch.

StatesComplete, without context, ghost, out of date — the project shows its health.

Auto-repairsSafe cases with one obvious fix get fixed without ceremony.

Live indexThe resource map your AI receives on open.

HTTP + MCPOne instruction file for a first look. MCP for everyday work.

Web UIThe human control room: see, edit, relate, validate.

Design Principle

Small blocks,
on purpose.

KaKeKiKoKu works because knowledge does not live in endless documents. It lives in bounded blocks with identity: sections, contexts, entities, images, and relations. Each block can be read, linked, updated, and understood without swallowing the whole project.

At first, the caps look like a restriction. Then they become a signal. If an idea does not fit inside its block, the idea is probably hiding two ideas. Split it, and the AI reasons more clearly.

Relations follow the same rule. They don’t link words in a document — they link blocks. That is why an AI can follow them without guessing, and why a KaKeKiKoKu project reads like a map instead of a pile of text.

Small pieces are easier to trust, to link and to change.

After a while you stop noticing the app and start thinking in blocks.

Read the bounded blocks manifesto

Isometric bounded knowledge blocks connected into a larger structure

Knowledge lives next to what it describes.

Purpose-built sections capture what a thing does, its rules, its traps, what was discarded and why. Three kinds of knowledge files keep it exactly where it belongs — beside your files, not trapped in a monolith.

Knowledge lives in bounded blocks sized for what an AI can actually use — not walls of text. When a file moves, its context moves with it. When a folder is reorganized, its knowledge stays relevant.

On diskPlain text, beside your files.

Your project folder

my-project/
- .wuniq/config.yamlProject settings. No knowledge lives here.
- my-project.wuniqFolder context of the root: purpose and rules
- decisions.entity.wuniqEntity: standalone knowledge, with no file
- src/
  - src.wuniqFolder context: covers the whole folder
  - storage.pyYour file
  - storage.py.wuniqFile context: travels with its file

Inside storage.py.wuniq

[_description]
Local storage layer. Saves tasks to a JSON file on disk.

[_rules]
No external requests.

[_whyNot]
SQLite: too much for a single-user task list.

Above these blocks sit a few system fields, such as identity, hashes and dates, that Studio keeps for you.

git status --short

 M src/storage.py
 M src/storage.py.wuniq

The code and its knowledge change in the same commit.

Readable anywhere. UTF-8 text: open it in any editor, diff it, review it in a pull request.
Shared like code. Whoever clones the repository gets the knowledge and can read it without the app. Studio is what keeps it maintained.
No hidden folder. Each resource with context gets a small file beside it, and you will see it in git status. That is on purpose: the knowledge moves with the file.
Safe with git. Backups live outside the repository by default. If a merge conflicts, Studio blocks sync and helps you repair it; it never picks a branch for you. Rather keep it out of git? Ignore *.wuniq and .wuniq/.

Local by design, and shared like code. Read the format reference

Control

New in 1.20

See what your AI reads before it starts.

Every time an AI opens your project, it gets the same opening: your root context, a map of what sits at the top, the resources you flagged, and the full context of the important ones. KaKeKiKoKu shows you that text exactly as the AI receives it, piece by piece, with how much space each piece takes.

That opening comes along in every session, whether the AI needs it or not, so it’s worth keeping it clear and short. You can’t edit it there, on purpose: it isn’t a document but the sum of those pieces, and it tells you where each one comes from so you can change it where it lives. You already choose which projects your AI can see; now you can also see what it reads. Right-click the project root and choose What the AI receives… How opening works

The opening, piece by piece.

01
Your root context
The project’s purpose, rules and traps.
02
A map of the top level
Each folder, file and entity, with its description.
03
What you flagged
Important, pending and draft resources, by name.
04
Your important resources
In full, because the opening asks the AI to read them.

The same text for any AI. Nothing hidden.

Alongside your tools

Keep the tools you use.
Give knowledge a place of its own.

Instruction files, client memory and skills each do their job, and they complement KaKeKiKoKu. What none of them is built for is the project’s own knowledge — structured, related, and kept true to your files. Choose where each kind of knowledge belongs.

CLAUDE.md / AGENTS.md

Working instructions

Lives In your repo — good start.
Updates By you or an AI maintaining the instructions.
When the project changes Review depends on your workflow; scope and loading depend on the client.

Built-in AI memory

Memory managed by your client

Lives In storage chosen by the client.
Updates Through the client or AI, with review controls that vary.
When the project changes Check how your client retrieves, updates, and exports project memories.

Skills

Reusable procedures

Lives In a user or project skill folder.
Updates When you update the skill.
When the project changes Review the procedure when its assumptions change; it can consult project knowledge.

The project’s own knowledge

Lives Beside your files, in the repo, structured in bounded blocks.
Updates You and your AI maintain it; KaKeKiKoKu watches for out-of-date context.
When the project changes Review out-of-date context in the panel or receive AI notifications through supported channels.

KaKeKiKoKu brings resource context, relations, selective reading, and sync checks together in a local application.

Read the full, honest comparison — Obsidian vaults included →

Ecosystem

One knowledge layer,
many AI clients.

KaKeKiKoKu connects through local HTTP or MCP, the open standard. The knowledge lives in your project — not in any provider’s cloud — and any capable client can use it.

Claude Code
ChatGPT / Codex
Claude Desktop
Other local AI clients

HTTP / MCP

KaKeKiKoKuKnowledge stored with your project

Decisions
Rules
Context

Read context Record knowledgeOne project. A shared foundation.

Bring a capable model

KaKeKiKoKu works with frontier models that reason deeply, use tools reliably, and handle a large working context. Claude, ChatGPT/Codex, and the models coming out of Asian labs all clear that bar today. The brand matters less than whether the model can handle structured project knowledge.

KaKeKiKoKu keeps that knowledge progressive: the map first, then specific resources on demand with search and read. It is not a brute-force context dump.

Precise by default, automatic if you want

Local AI clients with HTTP tools, and clients configured through MCP, can read context, create knowledge, search, and run sync, which your AI does when it finishes its work. Precise mode is the default with every client: when KaKeKiKoKu needs your AI, it prepares the prompt and copies it to your clipboard, and you paste it when you decide.

With an MCP client that delivers channels, today Claude Code, you can switch to Automatic mode and KaKeKiKoKu pushes live events when knowledge falls out of date. See the Claude Code guide for the recorded channel setup.

New to these terms? Everything is explained step by step in the integration guides.

A few confessions.

Two things I’d rather you hear from me first.

Repeated discovery.
Or knowledge that stays.

KaKeKiKoKu doesn’t do magic with tokens — recording knowledge is new work for your AI, and it takes a little time too: a few extra steps when a task ends, while your AI writes down what it learned. What it removes is the toll: without project knowledge, every session starts with your AI excavating. Blind searches, wrong files, re-reading what it already read yesterday. That spend repeats every single session and leaves nothing behind. With KaKeKiKoKu, it becomes an investment that stays in the project, and the time comes back the first time your AI doesn’t have to go looking.

On large, long-lived projects the difference is big; on day one with a small project, you’ll spend more. Searching finds the code, but not why the code is the way it is: that only exists if someone wrote it down. And the biggest saving never shows on a counter: an oriented AI takes fewer wrong turns — and work you don’t have to redo costs zero tokens. KaKeKiKoKu uses your existing AI subscription, not APIs. What you feel in practice: sessions that stay useful longer.

Start small.
Build familiarity.

Your first day will be bittersweet. KaKeKiKoKu has no context yet, so the AI spends time recording knowledge instead of helping with your “real” work. Start with a small project — the investment pays for itself fast.

After a few days, something changes. Your AI starts to feel like it has awareness of your project. You talk to it like a colleague who knows your work. It records knowledge as it works, catches errors it never caught before, and knowledge flows between sessions, between different AIs, becoming a permanent part of your project.

Knowledge is the project. The result is a byproduct.

Choose the direction.

Start with the why.

Continue with context.

Made for complex projects.

No bureaucracy.

You stay in control.

Your knowledge doesn’t belong to your AI.