Wuniq is growing into KaKeKiKoKu. You may see both names during the transition. Read why →

The tree takes you, the center shows you

A card that looked finished, the feeling that something didn’t fit, and a simple rule that changed how relations work in KaKeKiKoKu Studio 1.20.

A cartoon of a man at his desk reading an open document while a second, linked page slides out beneath it like a drawer, lit by a small robot holding a lamp. Behind him, a tree made of folders points the way, and a crumpled floating card lies in the wastepaper basket.

A small version, on purpose

We’re coming off a long run: a new name, the knowledge system, navigating by relations, reviewing relations. In 1.18, too many changes at once let a serious bug through: the web application wasn’t saving the text of a new relation. So 1.20 is small by decision: a few things, done well and well tested.

If this post feels long for a small version, that’s the other half of the story. In 1.20 we’re following written work procedures: the reason behind each change is written down while the work is being done, and every AI that finishes a piece of work leaves its own notes for this post. So you get the detail of everything that changed, down to the small fixes, with the reason for each one. The version isn’t bigger than the previous ones; it’s explained in more detail, because we want to be fully transparent about what changes and why. I wrote about that process in I question everything, even how I work.

The problem

Since 1.19, when something changes, Studio asks you to review what’s connected to it. Reviewing means reading the other side, and to read it you had to leave: abandon the resource you were editing, with your place in it and whatever you had half done, and come back later. The more relations, the more trips back and forth.

I wanted to read connected knowledge without losing my place.

The first answer: a card

The first version was a floating card. You clicked an icon on the relation and it appeared over the editor with the content of the other end. It worked: you could chain it, it refreshed itself if the AI changed the target, and it warned you if the target no longer existed.

When I tried it, I didn’t like it. If I moved to another resource, the card stayed there, floating over a document that had nothing to do with it, and it wasn’t clear whose it was. And it didn’t allow what I really wanted: to stop and compare.

Looking at how others do it

We looked at how other tools solve it. There are quick peeks that appear when you hover and vanish on their own: useful for a fact, not for thinking. There are equal split panes, two editors side by side: powerful, but today they would be a tangle, both in the code and in use. And there are separate reference areas, where you open what you’re consulting.

We kept the last one, with a twist: what you consult is paired with what you edit.

The consult area

Now, when you click a relation, its other end appears below the editor, in a consult area: the whole resource, opened on the block the relation points to, so you read it in place. It reads just like the editor — the same headers, the same colours, the same Markdown — but you can’t edit it. You can follow its own relations inside the area: the header names the hop you just took, and Back takes you to the previous step, just where you left it. You set its height with the divider, and Studio remembers it.

If you want to edit what you’re consulting, Swap turns them around: the bottom goes up and the top goes down. If you navigate to the resource you were consulting, the same thing happens. If you navigate somewhere else, the consult area closes: the pair is broken, and nothing is left floating behind. And the eye next to the robot, above the editor, consults the very resource you’re editing: one part of a long document stays in view while you write in another.

From the tree you can consult any resource, block or relation without leaving your place: every row has an eye next to the button that opens it in a new tab, and Alt+click or Consult in its menu do the same. In the tree, relations are now in italics, so they never pass for the resources they point to, and every context menu starts with what you use most. And if the resource you’re editing has reviews waiting or has fallen out of date, a discreet notice in the central panel tells you, without having to look at another panel, and lets you consult the other end from there.

One rule

While thinking all this through, something I had never liked came up. Clicking a relation in the center took you away from where you were, and clicking the rest of the relation edited it. Two similar gestures with very different effects.

The rule that came out of it is simple: the tree takes you; the center shows you. In the tree, clicking means going. In the center, clicking a relation means consulting it. Wherever you are, the other action is one visible step away, with the same eye in both panels. To edit a relation there’s its pencil, and to go to its target, its menu or Ctrl+click.

And your AI knows

If you tell your AI “look at what I have below”, it can know what you mean: when it asks what you’re viewing, the answer now includes what you’re consulting too.

A guide from Anthropic, and what we made of it

In July, Anthropic published a guide on how to give context to its Claude 5 generation of models. Its conclusion stands out: they removed more than 80% of Claude Code’s system instructions without losing quality in their tests. The problem wasn’t too little context, but too many restrictions and instructions that contradict each other.

KaKeKiKoKu Studio is precisely a context system, so I asked an AI to compare the product with that guide on two levels: how Studio documents itself, and what Studio does with its users’ knowledge. The first answer was reassuring: there’s no contradiction at heart. The guide doesn’t advise against having a lot of knowledge, but against loading it all at once, and Studio already delivers it in pieces: an index, the blocks that are needed and help by topic.

But there was work in the details, and also some thinking the guide couldn’t do for us.

A calmer tone. The instructions Studio gives the AI had capital letters and lists of “non-negotiables”, the style that models from not so long ago needed. Today’s models, the small ones and those from other companies included, are rigorous, and Studio already enforces the mechanical part by rejecting what isn’t allowed. So we speak more clearly and shout less.

The repetition that wasn’t. Studio seemed to repeat its start-up instruction five times. On closer look, each copy turned out to be the only one that arrives by some route: with or without an instruction file, through MCP or HTTP, after the AI compacts the conversation, or when one AI hands work to a smaller one. They stay. The reminders in responses, on the other hand, now appear the first time they apply on each connection; after that come the facts, the warnings and the exact commands. A new connection still gets its instructions, and the help comes back complete whenever it’s asked for. We also found a gap: after compacting, the AI didn’t always know it had to read the help again. Now every piece that survives compaction tells it.

Save conclusions, not speculation. The rule said “record decisions immediately”. But sometimes I want to think out loud with the AI without anything being written down. Now the AI records what we decide and conclude; what we’re only exploring isn’t knowledge until I settle it. If I ask it not to save, it doesn’t; and if it’s unsure, it asks, as many times as needed.

The AI’s own memory, better turned off. Many AIs have their own memory. With Studio, that creates two copies of the knowledge that end up drifting apart, and the AI may follow the wrong one. The manual now says it plainly: the project’s knowledge lives in Studio and, if your client allows it, it’s worth turning off its automatic memory in those projects.

Check coherence now and then. Sync notices that a file changed, but not that two contexts contradict each other. The manual explains how to ask for a dedicated review and how to make it cheap: a small model reads everything and writes a report without touching anything, and you, or a more capable AI, decide.

Rules with their reason. When an AI gets something wrong, the natural move is to add “never do X”. Those prohibitions pile up and clash. The manual and the AI’s help now ask for rules to be written as a standard with its reason, so they also apply well to what nobody foresaw.

See what your AI receives

That same conversation raised an uncomfortable question: what exactly does my AI receive when it opens a project? I knew roughly — the root context, the list of important resources and what those resources say — but I had never seen it whole, nor did I know how much space it took.

And it matters. That text goes with the AI into every session, whether it needs it or not. If it’s clear and well bounded, the AI starts oriented and has room left for the work. If it has slowly filled up with things that only matter now and then, every session starts with noise. Unlike a static instruction file, in Studio that knowledge stays up to date; but being up to date isn’t the same as being essential.

Now you can see it. In the menu of the project root, What the AI receives… shows you the text exactly as any AI gets it: the response when it opens the project and, below, the reading of each important resource, with how much space each part takes. It isn’t an approximation or a summary. It comes from the same functions Studio uses when the AI opens the project, so it can’t tell you anything else.

You can’t edit it there, and that’s on purpose: it isn’t a document, but the sum of several pieces. The root context, the descriptions of what it contains, the resources you’ve marked and a few lines from Studio. The first time, a short help explains where each piece comes from, so you can change it in its place.

It’s the idea that runs through the whole tool: nothing important should be left in the dark. Knowledge is written so that people and AIs can understand it, relations are visible, and when something changes Studio tells you what’s worth reviewing. Now you also see what your AI reads before it starts. Clarity for both sides of the conversation.

One word for each idea

KaKeKiKoKu was born to document code, and its words gave it away: “document”, “pending documentation”, “orphan”. Today it’s a knowledge system for any project, and those words told a different story. Looking at them, we found something worse: in the application, “orphan” meant exactly the opposite of what it meant in the help the AI reads. For the application it was a context left without its file; for the AI, a file that didn’t have a context yet.

In 1.20 each idea has a single word, in all six languages, from the application to the manual. A file without context shows up as just that: without context. A context that lost its file is a ghost. If the file changed afterwards, its context is out of date. And the action that stops a file from being tracked now says what it does: Untrack.

The AI keeps the status names it already knows, like orphan or drift, because for it they work almost like a protocol; what changes is how things are explained to it. The table of words is kept as knowledge in Studio’s own project, so that new texts don’t bring the old ones back.

A tutorial that catches up

The Learning Lab is a real KaKeKiKoKu project that teaches KaKeKiKoKu from the inside, in six languages. It had fallen behind: it didn’t teach the most important things from the latest versions, following relations and reviewing them when something changes, and it spoke with the old words.

In 1.20 we brought it up to date. It now teaches you to follow relations from the tree, to consult them without leaving what you’re editing, to review them and give your conformity when something changes, and to see what your AI receives when it opens the project. It uses the new vocabulary and the real names of the interface. It’s still a first tour, not a manual: the advanced material is in the documentation.

If you already had it open, Studio doesn’t overwrite it. Rename or delete its folder and open it again from the welcome screen.

One shared file, Claude included

If you use Claude Code, update your client. In the Code tab of Claude Desktop or in the terminal, recent versions can now read AGENTS.md, the same instruction file other AIs use. Support starts in Claude Code 2.1.277; we recommend a current version because of later fixes.

That lets you share Studio’s short start-up instructions between several clients and keep them in one place. We’ve reviewed the integration guides and the website’s entry points to recommend AGENTS.md for a new setup.

In Desktop, update the app and open a new Local session; /status shows the version of its Claude Code engine. The claude update command updates the terminal CLI, which is distributed separately: updating one doesn’t update the other. The Desktop guide and the CLI guide explain the steps.

If you already have Claude instructions, keep them. Claude’s own files take priority by default, and you can also import AGENTS.md or use a dedicated rule. The common guide explains what it takes for the AI to load the file you choose without losing your rules or duplicating the start-up.

Twenty relations in the same space

A resource could have twelve outgoing relations. Today’s models can handle more, and since 1.19 the AI declares relations when it creates context, so the limit was starting to show. We wanted to reach fifteen or, better, twenty.

Before touching anything, we looked at what the AI agents that use KaKeKiKoKu accept. What a tool returns can’t be as large as you like: Claude Code warns above a certain size and, further up, saves the response to a separate file; Codex cuts out the middle. KaKeKiKoKu already delivered responses of up to 30,000 characters, just below those limits, so there was no room to grow.

The solution was to separate the two things that limit relations: how many there are and how much space they take. The number goes up from twelve to twenty, and the space they share stays the same. More connections, as long as they’re concise; what your AI receives doesn’t grow. The counter in the central panel shows it: the number tells you how many you have and the bar, how much space they take. Whichever fills up first is the one that stops you. Earlier versions keep the limit of twelve, so if you work on several computers, update all of them.

Built for AI coding agents

Studying those limits made it clear who KaKeKiKoKu is built for: agents like Claude Code, Codex, Antigravity or OpenCode, and the projects you build with them, code or not. Editors with a built-in assistant can connect through MCP, but they aren’t the target. The guides now say so clearly, the HTTP connection warns that some clients cut long terminal output (if that happens to you, use MCP), and the extension for a code editor leaves the roadmap. If you use Claude Code or Codex inside VS Code, nothing changes: what counts is the agent.

HTTP for a first look, MCP for work

There are two ways to connect your AI to KaKeKiKoKu. The quickest is an instruction file and local HTTP: you set nothing up, and it’s enough to see what the application is about with a small project. For everyday work, MCP. With HTTP your AI writes a terminal command for each request, many clients ask you to approve it, and those extra steps can use a few more tokens. We measured it in an internal test and the difference is real, although we don’t give figures: they depend on the client and the task.

What matters most to us is something else: some clients cut long terminal output. We checked it with Antigravity 2.22.0. A response of about 27,000 characters arrived whole through MCP; over HTTP, the server delivered it complete and the client’s terminal cut it, keeping only the last lines. The limitation belongs to the client, not to the model you use in it. That’s why the guides now present HTTP as a first look and MCP as the connection for real work. Switching means replacing one block of the instruction file with the MCP one; your knowledge doesn’t change.

Fixes

1.20 is small, and I like it that way. The next batch of work is one you won’t see: more automated tests, so that small versions stay safe ones.

Get 1.20Download KaKeKiKoKu Studio

The consult areaReading connected knowledge

What comes nextRoadmap

The previous stepLost, with two AIs on board