Comprehensive guide covering installation, configuration, and usage of all Kawa Code components.
Open Complete User ManualFirst thing you need in order to work with Kawa Code is to install the desktop application. Kawa Code is a separate application that you can keep open on a separate monitor, showing you context relevant to your work.
The extension communicates with Kawa Code, so please make sure you install the desktop application first. In VSCode, search the marketplace for Kawa Code and install it.
Kawa Code is designed around SOC 2 controls — secure APIs on Google Cloud Platform, robust authentication, encrypted traffic, continuous monitoring, and backups. A third-party audit has not yet been completed; we will update this card once certification is in hand. See our Security page for the full data-flow audit.
For teams who don't want to grant repository access, our non-invasive security model enables collaboration without requesting access to your code repository. Team members are identified through continuously confirmed commit SHA values.
Trunk-based development works because humans code at a predictable pace. When you introduce AI agents pushing code 100x faster, your main branch becomes a bottleneck. Automated tests catch broken syntax after the push, but they can't see conflicting architectural decisions before they collide.
Kawa Code is the real-time Situation Room for human-AI teams. We map the intent and micro-decisions of your developers and agents locally, flagging logical conflicts before they ever hit your repository.
Kawa Code runs in the background — capturing the reasoning behind your changes and handing the relevant pieces back to your agent when they matter. Here are four habits that make that value visible. Try one or two this week.
The single best signal. As soon as your agent finishes a substantial piece of work, ask it to look back — it'll tell you which intents, decisions, and past context it actually leaned on. A specific answer ("I reused the decision about how rate-limiting is handled and avoided a conflict with the migration work") is Kawa Code paying off; a vague one usually just means the project is still early.
"How did Kawa Code help in this session? Which intents, decisions, or past context did you use, and what would have been harder without them?"
At the start of a task, see what Kawa Code already knows about the area you're about to touch — before you write a line. This is the moment it prevents the most expensive mistakes: re-litigating a settled decision, or colliding with work a teammate has in flight.
"What relevant past decisions and intents exist for the part of the codebase I'm about to work on?"
When you hit code you don't recognize — your own from six months ago, or a teammate's — ask for the intent behind it instead of guessing. Getting the reasoning, not just the diff, is the difference between editing safely and editing blind.
"What was the original intent behind this code, and were any decisions recorded about how it should work?"
Open the Orchestration panel in the Kawa Code app every week or two and skim the intents and decisions you and your team have built up. A growing, well-curated body of context — not a noisy dump — is the clearest sign Kawa Code is doing its job.
“But why not just Claude Code + a wiki?”
One agent makes dozens — sometimes hundreds — of micro-decisions per session. No human can write them all down and triage them by hand.
A wiki remembers. Kawa Code reasons with you.
Kawa Code offers long-term goal coherence for you and your AI. Projects drift — not because goals change deliberately, but because day-to-day focus on smaller steps gradually derails the larger vision. Kawa Code captures these decisions across all your branch timelines as they happen and surfaces them when they matter.
Because some kinds of work stop being linear. The Standard plan is designed for one person, one timeline. The Professional plan exists for situations where multiple lines of reasoning run in parallel and decisions need to be coordinated across humans and AI.
No human at Kawa Code can read your source. The desktop app reads your working tree locally to capture the reasoning behind your changes; the diffs and code blocks it captures are encrypted on your machine with a key our servers never receive, so we stay cryptographically blind to your code. The Professional plan changes none of that — it adds team coordination, not code access. See our Security page for the full data-flow model.
The Translation add-on translates code comments, variable names, and documentation into your preferred language directly inside your editor. It uses our hosted LLM service for convenience, but you can configure your own LLM API key instead.
Most AI coding workflows optimize for accumulation: more rules, more chats, more embeddings, more retrieved context. Over time, that creates context bloat — irrelevant information, stale assumptions, and contradictory past decisions competing for the model's attention.
Kawa Code takes a different approach. It captures the why behind architectural and implementation decisions, curates that knowledge over time, and surfaces only the intent relevant to the current task. The result is faster reasoning, more consistent outputs, and AI systems that retain long-term coherence as projects evolve.
AI-assisted development still carries an "English-first" bias. Non-English-speaking engineers must continuously translate ideas, architecture decisions, and prompts into English, creating cognitive overhead and reducing flow-state efficiency. Large Language Models (LLMs) are predominantly trained on English data, which accounts for about 46% of the web. As a result, an "English premium" exists: prompting AI in English yields 15-30% higher code generation accuracy compared to other languages.
Additionally, non-English-speaking engineers must continuously translate ideas, architecture decisions, and prompts into English, creating cognitive overhead and reducing flow-state efficiency. Our estimates indicate this dual process reduces their productivity by 50% or more. Kawa Code eliminates this barrier through "Universal Programming": developers can read and work with code in their native language while the source on disk stays standard, English-compatible code.
Yes, Kawa Code provides a massive impact even for teams or engineers who don't heavily rely on AI code generation.
First, its patented "real-time intersection detection" allows developers to visually see where teammates are working on the same files before changes are committed. This proactive visibility prevents integration friction, code collisions, and the dreaded "merge hell".
Second, Kawa Code persistently records the "intent" (why a change was made) alongside the code itself, preventing the loss of institutional knowledge when team members leave. This cuts code review and deciphering time in half and provides the benefits of pair programming without tying up two developers, significantly accelerating the onboarding and learning cycle of junior engineers.
Yes — at the session level. When Claude Code spawns subagents to parallelize a task, they share their parent session's identity, so any intent they create, activate, or complete is captured and attributed to that session.
One nuance: a subagent's private reasoning lives in its own transcript, so the individual decisions it verbalizes internally aren't captured yet — only the result it returns to the main session. Per-subagent reasoning capture is on our roadmap. For now, if a subagent makes a decision worth keeping, surface it in the main session so it's recorded.
No — the workflow guidance Kawa Code adds to your CLAUDE.md is deliberately light, around 2,000 tokens. It's a small, fixed instruction set that teaches your agent when to recall past reasoning, track intent, and record decisions.
Everything else is pulled on demand: Kawa Code surfaces only the decisions relevant to what you're working on, instead of dumping every rule, chat log, and stored memory into every prompt. The net effect is less context bloat, not more — a small fixed footprint plus precisely-scoped reasoning surfaced at the moment of work.