Skip to content
Agentmart
Submit a tool

Kawa Code

Team-aware memory: intent, decisions, real-time conflicts for AI coding assistants.

Connector by kawacode.aiOfficial · Domain verified by the MCP Registry

IndexedLicense unknownLocal (stdio)
Write a review

Install

Works with Claude Code, Codex, VS Code, Cursor, Windsurf, Claude Desktop. Read the repository before you give any tool access to your data.

npx agentmarket install connector/kawacode-ai-mcp

Asks which of your tools to add it to (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude Desktop) and shows the change first. See https://agentmart.dev/cli.

Get the weekly diff

The weekly diff: one email a week with new agent tools, notable updates and grade changes, plus security alerts for tools you follow. Double opt-in, one-click unsubscribe.

We use your email only for this newsletter. Privacy

About

Team-aware memory: intent, decisions, real-time conflicts for AI coding assistants.

Reviews

Write a review

No reviews yet. Installed it? Reviews come from verified installers only. How reviews work

Permissions

What this server can do and what it asks for, from its tool list and install config. Checked Oct 25, 2026.

Tools
12 read · 9 write · 1 delete · 3 not yet classified
Secrets
None asked for
Install scripts
None found
Runs as
Node.js package

Tools by what they do 25

Read from the source code; the running server may list different tools.

Read 12 · Look things up without changing anything.

  • check_active_intent
  • detect_intent_conflicts
  • get_decision_detail
  • get_intent_changes
  • get_intents_for_file
  • get_intents_for_lines
  • get_project_decisions
  • get_relevant_context
  • get_resolution_context
  • get_session_decisions
  • infer_history
  • list_team_intents

Write 9 · Create, change, send or run things.

  • arbiter_apply
  • arbiter_resolve
  • complete_intent
  • create_and_activate_intent
  • pre_edit_acknowledge
  • pre_edit_decision_check
  • record_decision
  • update_features
  • update_intent

Delete 1 · Delete, drop, revoke or wipe things.

  • edit_session_decision

Not yet classified 3 · We could not tell from the name and description.

  • activate_intent
  • evolve_decisions
  • log_work

Tools (25)

Read from the source code; the running server may differ. Descriptions are the server’s own words; hidden characters are shown as [U+…].

  • activate_intent

    Activate an existing intent by ID — sets it as THIS session's current focus. Use this to: - Switch your current focus to a different intent found via list_team_intents or get_relevant_context - Re-activate an intent that was deactivated (e.g., to complete it) - Resume work on a previously created intent - Resume an "abandoned" intent (see below) Accepts both cloud IDs (from get_relevant_context / API) and local UUIDs (from list_team_intents). Multi-active model: activating an intent only moves YOUR session's current pointer. Many intents can be active on a repo at once (one current per sess…

  • arbiter_apply

    Resolve live code overlaps and AUTO-APPLY the safe tier. Kawa judges → adversarially verifies → and, for the trivial tier only (high-confidence single-range merge that passes verify), writes the merge to your worktree, records a decision, and republishes. Writes happen ONLY in an agent-owned worktree (a linked git worktree); on a human checkout — or when a peer holds the file-set lock — it behaves like arbiter_resolve (suggest-only, no writes). Returns per-overlap outcomes { tier, applied, announcement, verifyIssue?, verdict }. Call it when you are ready to incorporate the result, then RE-READ…

  • arbiter_resolve

    Get Kawa Code's AI verdict for live code overlaps with peers — SUGGEST-ONLY, never writes. For each overlap ({peerUid, filePath, ranges} from the Stop collision report), Kawa decrypts the peer's version locally (zero-knowledge) and judges it compatible / auto_resolvable / conflict, with confidence, a perf/security risk read, and a tier (0 no-op · 1 trivially auto-appliable · 2 draft-and-confirm · 3 conflict). Use it to understand a forming conflict before acting. For a surfaced tier-2/3 overlap, call get_resolution_context to read the peer's actual code. To actually apply the safe tier, use ar…

  • check_active_intent

    REQUIRED: Call this tool BEFORE writing any code. Returns THIS session's current intent (`intent` / `hasActiveIntent`) if one is set. If not, ask the user to confirm intent details and then call create_and_activate_intent. Multi-active model: the active intent is PER SESSION. Many intents can be active on a repo at once — your current is independent of other sessions'/teammates'. The response also includes `activeIntents`: the repo's full active set (every session's current intent, with id/title/status/createdBy/author) for awareness and orchestration. `hasActiveIntent` reflects only YOUR se…

  • complete_intent

    Mark the active intent as completed and clear it. Call this after a successful git commit to: 1. Update the intent status (committed/pushed/done/abandoned) 2. Store the commit SHA for tracking 3. Clear the active intent so a new one can be started Status values: - "committed": Code is committed locally (default) - "pushed": Code has been pushed to remote - "done": Work is fully complete - "abandoned": Work was discarded without committing REQUIRED: Inspect the response after calling this tool. Three outcomes: 1. response.success === true: The task is complete. Briefly acknowledge the co…

  • create_and_activate_intent

    Create a new intent from the user's request and mark it as active for THIS session. Call this when check_active_intent returns no active intent for your session. Before calling: 1. Summarize what the user is asking for 2. Ask the user to confirm the intent details (title, description, type) 3. Then call this tool with the confirmed details This ensures all AI-generated code gets properly tracked and attributed. Multi-active model: many intents can be active on a repo at once (one per session/teammate). Creating + activating one only sets YOUR session's current focus — it never blocks or dis…

  • detect_intent_conflicts

    Find intents from other team members that potentially conflict with the active intent. When to use: - Before committing, to surface overlapping team work so the user can coordinate before merging. Inputs of note: - `intentId`: the active intent to check against. - `minScore` (optional): minimum match score to include in results. Returns scored conflict candidates with: - `score`: how strongly the candidate matches (higher = more likely conflict). - `overlappingFiles`: files affected by both intents. - `decisions`: decisions attached to the conflicting intent. - `author`: who is working on t…

  • edit_session_decision

    Edit or delete a decision in the current session. Use this when reviewing decisions before commit: - action: "update" - Modify the decision fields - action: "delete" - Remove the decision entirely Only ephemeral (in-flight) session decisions are editable. Once a decision is synced to Kawa Code, it is immutable — refine it instead by recording a new decision with `supersedes: [<id>]`. This allows users to curate their decision history before it's persisted.

  • evolve_decisions

    Curate a set of previously extracted stories so that only the decisions still worth keeping are persisted. When to use: - After running `infer_history` in story-only mode (rare — `infer_history` already chains this step automatically). - When you have a pre-existing set of stories you want to re-curate without re-running history extraction. Inputs: - `stories`: array of story objects from a previous `infer_history` run. - `repoPath` (optional): when provided, curated results are persisted as intents and decisions for the repo after curation finishes. - `model` (optional): Anthropic model use…

  • get_decision_detail

    Expand one decision to its full detail. Recall surfaces (get_relevant_context, get_project_decisions, get_session_decisions) return decisions summary-only to keep context lean. Use this to pull the full reasoning for a single decision you want to open — pay for detail only where you ask for it. Inputs: - `decisionId`: the decision to expand (the `id` / `decisionId` from a recall result). Returns the decision's `rationale`, `context`, `consequences`, `alternatives`, `symptom`, `appliesWhen`, and related metadata. `found: false` when the id is unknown in this repo.

  • get_intent_changes

    Get uncommitted changes in the repository along with the active intent info. Use this tool before prompting the user about committing to show: - The active intent title and description - Number of modified, added, and untracked files - Any warnings (e.g., pre-existing changes from before intent activation) This helps you construct an informative commit prompt like: "You have uncommitted work on '[intent title]' (N files changed)..."

  • get_intents_for_file

    Get all intents that have code blocks in this file. Use this before modifying a file to: - See what work is already in progress - Identify potential conflicts with team members - Understand the context of existing code changes Returns intent details including author, status, and specific line ranges.

  • get_intents_for_lines

    Get intents covering a specific line range. Use this before modifying specific lines to check for conflicts: - Warns if the lines overlap with another team member's active intent - Shows the exact overlap range - Helps avoid merge conflicts and duplicate work Returns overlap details so you can work around or coordinate with team members.

  • get_project_decisions

    Get all decisions recorded for a project across all intents. Use this to review the project's decision history: - See what architectural decisions have been made - Understand past trade-offs and their rationale - Find decisions affecting specific files - Review constraint violations that were avoided Returns: - decisions: Array of decisions with their intent context - count: Total number of decisions Each decision includes (summary-only, to keep context lean — call get_decision_detail(decisionId) for full rationale/context/consequences/alternatives): - intentIds: The intents this decision b…

  • get_relevant_context

    Find past intents and decisions relevant to the current user request. When to use: - After you have done a quick initial exploration of the user's request and know which files are involved. Calling earlier with only a vague prompt gives weak results. - To pull task-specific context instead of dumping all recent activity — preferred for large projects. Inputs of note: - `prompt`: the user request, in their words or your paraphrase. - `activeFiles` (recommended): files you have identified as relevant to the request. Significantly improves relevance. - `maxIntents`, `maxDecisions`, `minRelevanc…

Show 10 more tools
  • get_resolution_context

    Resolve a live code collision with a peer BEFORE you write (Layer C resolution handoff). Call this when the Stop hook's collision report (or complete_intent's resolution_required gate) surfaced a live peer (a teammate or AI agent editing the same lines). Pass that collision's uid as peerUid and its overlapping ranges. You get back: - peerSnippet — the peer's actual (decrypted) code at the overlapping lines, so you can see what they wrote. - decisions — recorded reasoning attached to this file (region context). - guardrail — the policy you must follow when resolving: • Never overwrite a peer…

  • get_session_decisions

    Get all decisions recorded in the current session for an intent. Use this before committing to review what decisions were captured during development. Decisions are presented for user review and can be edited or removed before being persisted. Returns: - intentId: The intent these decisions belong to - decisions: Array of decision points (summary-only — call get_decision_detail(decisionId) for full rationale/context/consequences/alternatives) - count: Number of decisions recorded

  • infer_history

    Analyze a repository's git commit history and produce structured development knowledge (intents and decisions) for the repo. When to use: - To bootstrap a repository that has no recorded intents/decisions yet. - To extend coverage for new commits since the last run (resumes automatically when no `commits` value is provided). Inputs of note: - `estimateOnly` (default true): returns a token/cost estimate without running. Call with `estimateOnly: true` first to preview cost, then re-call with `estimateOnly: false` to run. - `commits` (optional): how many recent commits to analyze. Omit to resum…

  • list_team_intents

    List intents from team members for this repository. Use this to: - See what your team is working on - Check for potential overlapping work before starting a new task - Review the status of various features/refactors in progress Filtering (status, author, date range) and pagination are applied server-side across the full result set (default: 50 per page; use limit/offset to page). `count` is the total number of matching intents, not just the returned page.

  • log_work

    DEPRECATED — trivial changes (typos, one-line fixes, obvious bugs, doc updates, config changes) should skip the intent workflow entirely: just make the change and commit, no intent needed. Do not call this tool. Kept available for backwards compatibility only and will be removed in a future release.

  • pre_edit_acknowledge

    Mark decisions as consciously overridden for the rest of this session. Phase 3's PreToolUse hook calls this when the agent passes `force: true` on an Edit tool call to bypass a pre_edit_decision_check block. Adds the surfaced decision IDs to an in-memory session cache; subsequent pre_edit_decision_check fires filter those IDs out so the same block doesn't re-fire. The cache resets when the MCP server process exits (= the agent session ends). For persistent override across sessions, record a fork decision via `record_decision(type: "fork", supersedes: [<id>])` instead. Returns: - acknowledge…

  • pre_edit_decision_check

    Check whether the line range about to be edited has prior recorded reasoning attached. Call this BEFORE editing code in a kawa-indexed repo. Surfaces: - Tier 1a — overlapping intents whose blocks cover these lines (line-precise team coordination + intent-scoped decisions) - Tier 1b — repo decisions whose relatedFiles include this file (file-coarse, catches infer_history-extracted constraints) (Live-collaborator code-collision awareness is no longer reported here — it now arrives once per turn at the Stop hook. This tool is purely the semantic, decision-based check.) Decisions already overri…

  • record_decision

    Silently record a decision point during development. Call this tool when you: - Choose between multiple alternatives (type: fork) - Try an approach that fails or is rejected (type: abandoned) - Find unexpected behavior or limitations (type: discovery) - Identify a hard constraint that must be respected (type: constraint) - Make an explicit trade-off between competing concerns (type: tradeoff) - Select an external library or dependency (type: dependency) Decisions can be **intent-scoped** (tied to a specific work unit) or **repo-scoped** (general knowledge like discoveries and constraints). O…

  • update_features

    Update the project's feature catalog from its recorded intents. Additively groups any intents that are not yet assigned to a feature into the running catalog (an incremental "extend"), without disturbing existing features. The feature catalog is the high-level "what does this project actually do?" view, derived from the repo's intents. When to use: - After recording or completing intents, to keep the feature list current. - On demand, when you want the catalog refreshed with recent work. Behavior: - Additive only — never deletes or re-derives existing features. - Intents already assigned to…

  • update_intent

    Update an active intent's title, description, scope, or constraints. Use this to reformulate an intent as understanding evolves during work. Intents are living documents — they should be updated to reflect what the work actually became, not left as the initial guess. Common triggers for reformulation: - The real problem turned out to be different from the initial hypothesis - Scope expanded or narrowed during investigation - The approach changed after discovering constraints If no intentId is provided, the currently active intent is updated.

Signals

Stars
0
Forks
0
Open issues
0
Weekly downloads
102
Last commit
Jul 15, 2026 (3 months ago)
Last release
Oct 21, 2026 (7 days ago)
Last package publish
Oct 21, 2026 (7 days ago)

From GitHub (fetched Oct 24, 2026) and the package registry.

Details

Registry name
ai.kawacode/mcp
Version
10.0.0
Auth
No auth
Packages
npm @kawacode/mcp
License
License unknown
Repository
github.com/kawacode-ai/kawa.mcp
Website
kawacode.ai
First seen
Oct 24, 2026
Last checked
Oct 24, 2026
Source
Official MCP Registrygithub-graphql
Cite this page

Kawa Code MCP server. Agent Mart. https://agentmart.dev/connectors/kawacode-ai-mcp (last updated 2026-10-24)