Skip to main content
Glama

Moonbridge

License: MIT

Moonbridge is a local MCP server that lets compatible MCP clients invoke Kimi Code for independent second opinions, structured code reviews, and delegated coding tasks.

It gives your primary coding agent another model to ask—one that can challenge a plan, inspect a diff, or try an implementation while you keep control of the result. Moonbridge ships plugin integrations for Claude Code and Codex; other clients can use its local stdio server.

WARNING

Deprecated. Moonbridge is superseded by amicus, which calls Kimi (backend="kimi") and other backends (Codex, Claude Code) through one MCP server. 0.4.0 is the final release. The repository is archived after it ships: installed versions keep running, but get no fixes or releases. New users should install amicus. Each tool's deprecation marker (in its _meta and its kimi_capabilities entry) names its amicus successor.

Contents: Why Moonbridge? · Requirements · Quick start · Safety model · Tools · Configuration · Development · Documentation

Why Moonbridge?

Different models notice different things. Moonbridge lets one coding agent bring Kimi into the conversation without making you switch tools or manually shuttle context between terminals.

Workflow

What Kimi does

What you get

Consult

Reasons under a read-only agent profile

An answer or independent second opinion

Review

Inspects your git changes without shell or write tools

Structured findings with coverage and verdict

Delegate

Implements a task inside a throwaway worktree

A reviewable diff that is never applied automatically

Every workflow returns a structured result to the calling client. Long-running work can run in the background and be recovered after a dropped connection.

Before using Moonbridge with sensitive code, read the safety model. The Kimi CLI has no sandbox or approval prompts, and a throwaway worktree is not a security boundary.

Related MCP server: kimi-acp-mcp

Requirements

  • kimi (Kimi Code) 0.35.x or 0.39.x — the supported minors. Probed on 0.35.0 and 0.39.1; other patch releases in those minors are assumed compatible, not verified

  • Python ≥ 3.11, uv, and git

  • macOS or Linux

  • Claude Code, Codex, or another MCP client that can launch a local stdio server

Make sure Kimi is installed and has at least one configured provider and model alias:

kimi --version
kimi doctor config

See the Kimi Code documentation for CLI installation and authentication.

Quick start

No clone is required. The plugin integrations launch the server from the release tag pinned in .mcp.json.

Codex

codex plugin marketplace add briandconnelly/moonbridge
codex plugin add moonbridge@moonbridge

Start a new Codex session so it loads the bundled skill and tools.

Claude Code

Run these commands inside Claude Code:

/plugin marketplace add briandconnelly/moonbridge
/plugin install moonbridge@moonbridge

Other MCP clients

Moonbridge can work with another client if it supports local stdio servers. Adapt the moonbridge entry in .mcp.json to that client's configuration format. Claude Code and Codex are the integrations currently packaged and documented by this project.

Try it

Ask your coding agent:

  • Check whether Kimi is ready. — a free readiness check with no model call

  • Get Kimi's second opinion on this approach.

  • Have Kimi review my current changes.

  • Delegate this task to Kimi and show me the proposed diff.

Claude Code also provides /kimi:status, /kimi:consult, /kimi:review, and /kimi:delegate shortcuts. In Codex, /plugins lets you browse, enable, or disable the installed plugin.

Safety model

Read this before pointing it at anything sensitive. Every statement below was verified by running kimi-code 0.35.0 and again on 0.39.1, not inferred from its documentation.

The kimi CLI has no sandbox and no approval prompts. Prompt mode (kimi -p) forces autonomous mode and runs shell commands and file writes with your own user's privileges. Unlike Codex, there is no --sandbox flag to hand it. So this server constrains runs itself:

  • consult and review get an agent profile whose tools: list omits every shell and write tool. This is the real control, and it works: an agent declaring Read, Glob, Grep reports exactly those three, and a shell write attempt produces nothing.

  • every run uses a throwaway git worktree. This is defense in depth, not a boundary — asked to write outside its working directory, Kimi will do it. Treat the worktree as keeping honest runs tidy, not as containment.

Three limits that follow, stated plainly because they are easy to assume away:

  1. Read-only prevents modification, not disclosure. Kimi's Read tool accepts absolute paths, so a prompt-injected repository can make a consult read files elsewhere on your machine and send them to your provider. Do not point any workflow at a workspace whose contents you would not hand to that provider.

  2. Delegate is not network-isolated. A delegated task can push, fetch, install dependencies, and call out. The returned diff shows what changed in the worktree — not everything the run did.

  3. Kimi loads context you did not mention. It auto-loads the workspace's AGENTS.md and discovers skills from its own user/project directories and from the extra_skill_dirs entries in its config.toml, which may point anywhere on disk. Its built-in skills always load. The isolation setting reduces this but cannot eliminate it.

Secret redaction covers gathered diffs and Kimi's returned output. It does not cover what you type, or files Kimi reads for itself.

For the complete threat model and disclosure policy, see SECURITY.md and COMPATIBILITY.md.

Tools

“Paid” means the tool makes a Kimi model call and consumes quota from your configured provider; Moonbridge itself is not a paid service.

Tool

Cost

Notes

kimi_status

free

readiness, version, provider configuration, resolved defaults

kimi_capabilities

free

full inventory, schemas, per-tool error codes

kimi_models

free

model aliases from your config.toml, with each alias's declared efforts

kimi_consult / _async

paid

read-only Q&A

kimi_review_changes / _async

paid

structured review of working_tree, branch, or commit

kimi_delegate / _async

paid

returns a reviewable diff, never applied

kimi_dry_run, kimi_delegate_dry_run

free

preview scope, diff size, redactions before spending

kimi_job_{status,result,consume_result,cancel,list}

free

background job lifecycle

Two details prevent surprising runs:

  • model takes an alias, not a provider model id — whatever you defined as [models."<alias>"] in config.toml. An unknown alias is rejected as invalid_model.

  • reasoning_effort is validated locally. Kimi silently ignores an effort it does not recognize rather than rejecting it, so this server refuses one the alias does not declare — a run that quietly used the default while reporting your requested effort would be worse than an error.

Configuration

Environment variables, all prefixed MOONBRIDGE_:

Variable

Default

Meaning

TIMEOUT_SECONDS

300

per-call wall clock, clamped 10–600

MODEL

unset

default model alias

REASONING_EFFORT

unset

default effort

ISOLATION

inherit

inherit or ignore-skills

MAX_INPUT_BYTES

200000

bound on gathered context

MAX_DELEGATE_DIFF_BYTES

200000

bound on a returned diff

JOB_TTL / JOB_MAX_SECONDS / JOB_MAX_COUNT

86400 / 1800 / 50

background job limits

STATE_DIR

~/.cache/moonbridge/jobs

job records

LOG_LEVEL / LOG_FILE

WARNING / unset

logging

SUPPORTED_VERSIONS

0.35,0.39

supported kimi minors (probed at 0.35.0, 0.39.1)

EXTRA_ARGS

unset

no safe passthrough exists — any value is refused, see below

MOONBRIDGE_EXTRA_ARGS accepts nothing today, deliberately. Kimi exposes no config-override, profile, or feature flags, and reuses two short flags for other purposes: -p is prompt and -c is continue. Passing them through would override the run's real instructions or resume an unrelated session, so the allowlist is empty and a configured value fails loudly rather than being silently ignored.

Development

Set up the project and run the focused test suites from the repository root:

uv sync
uv run pytest
uv run pytest -m integration --no-cov  # optional: calls the real Kimi CLI

The authoritative quality gate and contribution workflow live in AGENTS.md and CONTRIBUTING.md.

To exercise the plugin manifest from a checkout, register that checkout as a marketplace:

codex plugin marketplace add <path to this checkout>
codex plugin add moonbridge@moonbridge

In Claude Code, run /plugin marketplace add <path to this checkout>, then install as above. This tests the plugin files in your checkout, but the MCP server still comes from the released tag pinned in .mcp.json; Python edits in the checkout do not affect it.

To run the working tree in Codex, register a separate development server:

codex mcp add moonbridge-dev -- uv run --directory <path to this checkout> moonbridge-mcp

In Claude Code, override the server in the consuming project's own .mcp.json:

{
  "mcpServers": {
    "moonbridge": {
      "command": "uv",
      "args": ["run", "--directory", "<path to this checkout>", "moonbridge-mcp"]
    }
  }
}

Documentation

  • Tool reference — the full caller-facing contract: envelopes, error codes, detail levels, idempotency, jobs. Read it when calling the MCP tools directly.

  • Compatibility — what the kimi CLI does and does not guarantee, and every deliberate non-guarantee.

  • Security policy — the verified security model, and how to report a vulnerability.

  • Contributing — set up a checkout and prepare a pull request.

  • Agent conventions — the authoritative working rules for humans and agents.

  • Upgrading kimi — the probes to re-run before supporting a new kimi version.

  • Releasing — the ordered release runbook.

  • Changelog · Architecture decision records — decision history, not current policy.

Available Tools

16 tools
kimi_capabilitiesList server capabilities (free)A
Read-only

List this server's tools, tiers, and the result fingerprint. Free — no model call. Clients can cache by the fingerprint.

detail="summary" (default) returns each tool's name, cost, stability, and error_codes — the facts tools/list does not already carry — plus async_lifecycle, but only for the *_async tools. detail="full" adds use_when/returns/required_params/key_optional_params, restating what you already hold. detail="contracts" omits tool_details.

Pass include_schemas to also embed the full 'error-envelope', 'result-meta', 'capabilities-result', and/or 'status-result' schema, and/or the 'parameter-contracts' document (a contract doc, not a JSON Schema) — a tool-reachable fallback to the kimi:// resources for resource-blind clients. It works in any detail mode.

Inputs: detail, include_schemas. Returns: ok

kimi_consultConsult Kimi (paid)A

Ask Kimi (a different model) for a read-only second opinion or answer.

PAID — this spends Kimi quota on every new call; there is no dry-run preview for a consult, so run kimi_status (free) first to confirm the CLI is installed and authenticated.

Runs kimi -p under a generated read-only agent profile — Kimi holds no shell and no write tool, so it never edits files. A STATIC review, not a verify mode: without those tools it cannot run a test/build/lint pass to confirm its claims — treat findings as unvalidated claims you verify yourself. Pass workspace_root (absolute) for a repo-grounded question; omit it for pure Q&A. Returns a result envelope.

Data egress: this sends your question and extra_context to your configured Kimi provider via the kimi CLI. Kimi always runs with a resolved working directory (workspace_root, else the server's cwd as a fallback — MCP roots are unavailable), so it may read files there and Kimi auto-loads the resolved workspace's AGENTS.md and discovers skills from its own config (including extra_skill_dirs, which may point outside the workspace). Skill names and descriptions are exposed to the model up front, so that content can be sent even if your prompt never mentions it. The isolation setting does not suppress any of it: kimi's built-in skills always load, and AGENTS.md is read regardless.

Your inputs are sent raw and unredacted. Secret redaction is best-effort and covers the gathered diff and Kimi's returned output — not what you type, and not the files Kimi reads for itself.

Progress & recovery: blocks up to the resolved deadline (timeout_seconds, clamped 10-600s; when omitted, the server-configured value, built-in default 300s). If that deadline expires the run is terminated and its partial output is not recoverable or resumable, so for a high-reasoning_effort or broad repo-grounded consult that may exceed it, prefer kimi_consult_async (a background job, built-in default 1800s deadline; poll kimi_job_status). Coarse notifications/progress streams while it blocks when your client requests it; some MCP clients background a long call before the deadline, so timeout_seconds bounds the run, not necessarily the inline wait — either way the detached run (meta.job_id) is recoverable via kimi_job_list→kimi_job_status→kimi_job_result.

Inputs: question (required), model, detail, isolation, +5 more. Returns: ok

kimi_consult_asyncConsult Kimi in background (paid)A

Ask Kimi for a read-only second opinion in the background; get a job_id back immediately instead of blocking.

PAID — this spends Kimi quota on every new call; there is no dry-run preview for a consult, so run kimi_status (free) first to confirm the CLI is installed and authenticated.

Same read-only behavior as kimi_consult (Kimi never edits files), but detached — prefer it for a high-reasoning_effort or broad repo-grounded consult that can exceed the synchronous deadline (built-in default 300s), since a sync run whose deadline expires loses its partial work; this job's own deadline is separately configured (built-in default 1800s). Starting a job commits to spend (it runs to completion or its wall-clock deadline even if you never poll). Poll kimi_job_status; read/consume the consult envelope with kimi_job_result/kimi_job_consume_result; stop with kimi_job_cancel.

Data egress: same as kimi_consult — sends your question and extra_context (raw, unredacted) to your configured provider via the kimi CLI, plus files Kimi reads from its resolved working directory (workspace_root, else the server cwd — MCP roots are unavailable). Kimi auto-loads the resolved workspace's AGENTS.md and discovers skills from its own config (including extra_skill_dirs, which may point outside the workspace).

Your inputs are sent raw and unredacted. Secret redaction is best-effort and covers the gathered diff and Kimi's returned output — not what you type, and not the files Kimi reads for itself.

Inputs: question (required), model, isolation, extra_context, +3 more. Returns: ok

kimi_delegateDelegate a coding task (paid)A

Delegate a coding task to Kimi (a different model) in an isolated git worktree, and get back a reviewable diff that is NOT applied to your tree.

PAID — this spends Kimi quota on every new call; use kimi_delegate_dry_run or kimi_status (both free) first if you only need to check scope or readiness.

Kimi edits files with workspace-write, but only inside a throwaway worktree seeded from your current tracked state. The returned diff is Kimi's changes; review it, then apply it yourself if you want it. Requires a git repo with at least one commit. Pass workspace_root (absolute).

NETWORK IS NOT BLOCKED: kimi has no sandbox, so a delegated task CAN reach the network — it may git push/fetch, run gh, curl, publish, or install dependencies, and it runs shell commands with your own user's privileges. Scope tasks accordingly and review the returned diff before applying it; the diff shows what changed in the worktree, not what else the run did. The Kimi model call also sends your task to your configured provider and lets Kimi read tracked files in the worktree and send their content. Kimi auto-loads the resolved workspace's AGENTS.md and discovers skills from its own config (including extra_skill_dirs, which may point outside the workspace). Skill names and descriptions are exposed to the model up front, so that content can be sent even if your prompt never mentions it. The isolation setting does not suppress any of it: kimi's built-in skills always load, and AGENTS.md is read regardless.

Your inputs are sent raw and unredacted. Secret redaction is best-effort and covers the gathered diff and Kimi's returned output — not what you type, and not the files Kimi reads for itself.

Progress & recovery: blocks up to the resolved deadline (timeout_seconds, clamped 10-600s; when omitted, the server-configured value, built-in default 300s). If that deadline expires the run is terminated and its partial output is not recoverable or resumable, so for a substantial or multi-file task that may exceed it, prefer kimi_delegate_async (a background job, built-in default 1800s deadline; poll kimi_job_status). Coarse notifications/progress streams while it blocks when your client requests it; some MCP clients background a long call before the deadline, so timeout_seconds bounds the run, not necessarily the inline wait — either way the detached run (meta.job_id) is recoverable via kimi_job_list→kimi_job_status→kimi_job_result.

Inputs: task (required), model, detail, isolation, +4 more. Returns: ok

kimi_delegate_asyncDelegate in background (paid)A

Delegate a coding task to Kimi in the background and get a job_id back immediately (does not block on the run).

PAID — this spends Kimi quota on every new call; use kimi_delegate_dry_run or kimi_status (both free) first if you only need to check scope or readiness.

Same propose-tier behavior as kimi_delegate — Kimi works in a throwaway git worktree and the result carries a reviewable diff that is NOT applied — but detached; prefer it for a substantial or multi-file implementation task that can exceed the synchronous deadline (built-in default 300s), since a sync run whose deadline expires loses its partial work (this job's own deadline is separately configured, built-in default 1800s). Starting a job commits to spend (it runs to completion or its wall-clock deadline even if you never poll). Poll kimi_job_status; read/consume with kimi_job_result/kimi_job_consume_result; stop with kimi_job_cancel. Requires a git repo with at least one commit; pass workspace_root (absolute).

NETWORK IS NOT BLOCKED: like kimi_delegate, this has no sandbox — a delegated task CAN push, fetch, install dependencies, or call out, running with your own user's privileges. Scope tasks accordingly and review the returned diff before applying it. The Kimi model call also sends your task (raw) to your configured provider and lets Kimi read tracked files in the worktree and send their content.

Kimi auto-loads the resolved workspace's AGENTS.md and discovers skills from its own config (including extra_skill_dirs, which may point outside the workspace).

Secret redaction is best-effort and does not cover your task or the files Kimi reads for itself.

Inputs: task (required), model, isolation, workspace_root, +2 more. Returns: ok

kimi_delegate_dry_runPreview a delegate (free)A
Read-only

Preview what a kimi_delegate/kimi_delegate_async call would do — the baseline it seeds from (HEAD commit, tracked file count/size, uncommitted and untracked counts), the prompt size that would be sent, and the resolved workspace/isolation. Free — no model call, no spend, no worktree created.

Use it before delegating to confirm scope and repo before committing to cost, exactly as kimi_dry_run previews kimi_review_changes. Mirrors the real delegate's zero-spend validation (workspace, isolation, task size, git repo), so a failure here is a failure the paid call would also hit. The returned tier/sandbox describe the previewed propose run, not this read-only preview; the result echoes the effective model/reasoning_effort overrides the paid call would send (unvalidated). deadline_advisory is non-null when size or reasoning effort risks the synchronous deadline and names kimi_delegate_async verbatim — the async counterpart of the previewed call, not of this dry-run tool. A hint, not a refusal.

Inputs: task (required), model, isolation, workspace_root, +1 more. Returns: ok

kimi_dry_runPreview a review (free)A
Read-only

Preview what a kimi_review_changes call would send — scope, diff size, redactions, truncation. Free — no model call, no spend. Use it before a review to inspect the scope and the reported redactions; redaction is best-effort, so treat the preview as a check on scope, not as confirmation that no secret remains. Pass the same extra_context and untracked policy you would give the review so the preview matches it. would_call_model reports whether the paid call would actually run the model (False on an empty diff, where prompt_bytes is 0), and coverage discloses omitted untracked files just as the review would. The result echoes the effective model/reasoning_effort overrides the paid call would send (unvalidated). deadline_advisory is non-null when size or effort risks the synchronous deadline (null whenever would_call_model is False) and names kimi_review_changes_async verbatim — the async counterpart of the previewed call, not of this dry-run tool. A hint, not a refusal.

Inputs: base, model, paths, scope, +6 more. Returns: ok

kimi_job_cancelCancel a job (free)A
Idempotent

Cancel a running background Kimi job.

Asks the worker to shut down gracefully so it tears down its throwaway worktree, then force-kills it if it overstays, and marks the job cancelled (cancelled jobs cannot be resumed). If the worktree could not be removed, cleanup_warnings names the leftover path. Already-terminal jobs are returned unchanged, so cancel is idempotent — a retry after a lost response is safe. Free — no model call.

Inputs: job_id (required), workspace_root. Returns: ok

kimi_job_consume_resultFetch and delete job result (free)A

Fetch a finished background Kimi job's result and delete the stored record.

Same envelope as kimi_job_result (matching the job's kind — branch on tool), then removes completed job state — but only once the stored result has been read intact and validated (a success or the job's own error envelope): a stored result this release cannot read (job_result_incompatible or a corruption internal_error) is NOT deleted, so it stays inspectable via kimi_job_result. Deletion precedes the response, so a response lost in transit does not restore the record; a failed removal retains the record until its TTL (kimi_job_status still shows it). Use only when you no longer need to poll or re-read the job. Non-done jobs are not deleted. Free — no model call.

detail works as in kimi_job_result (#56).

Inputs: job_id (required), detail, workspace_root. Returns: ok

kimi_job_listList background jobs (free)A
Read-only

List the background jobs known for this workspace, newest first.

Free — no model call. Use to recover job_ids lost across context compaction or interruption. Returns each job's id, kind, status, start time, result_available, result_ok (a done job's outcome — true/false/null; see kimi_job_status), and expiry, so a stored failure is triageable without fetching each result.

Returns every retained job by default; pass limit (1-1000) or status to narrow. They narrow independently — omitting limit returns every job matching status, not every job. Only an explicit limit truncates: when more jobs match, the response sets truncated: true with a truncation_hint — the extra rows are dropped, not paged, so omit limit to get them all rather than looking for a cursor.

Read a job's result promptly — a finished record can silently drop off. This list is not permanent storage: terminal records expire after the TTL (default 24h), and a per-workspace soft cap (default 50, clamped 1-1000) evicts the oldest terminal records as new jobs start, so a finished job can disappear even before its expires_at. Running jobs are never evicted, so a busy workspace can hold more than the cap — and more than limit's 1000 ceiling. Includes sync-originated records (any sync consult/review/delegate call); the cap/TTL eviction covers both.

Inputs: limit, status, workspace_root. Returns: ok

kimi_job_resultFetch job result (free)A
Read-only

Fetch a finished background Kimi job's result WITHOUT deleting the record.

Works for any async job or sync consult/review/delegate (whose meta.job_id names its record) — kimi_delegate_async (a diff), kimi_consult_async (a consult answer), or kimi_review_changes_async (a review with verdict). Use when kimi_job_status reports result_available=true; the envelope matches the job's kind, so branch on tool. meta.job_id is set. A still-running/cancelled/timed- out/failed job returns an error envelope — as does a done job whose stored result this release cannot read (job_result_incompatible). To fetch and delete, use kimi_job_consume_result. Free — no model call.

detail="summary" (default) omits the raw model text; pass detail="full" for the complete raw output and metadata (#56).

Inputs: job_id (required), detail, workspace_root. Returns: ok

kimi_job_statusCheck job status (free)A
Read-only

Check a background job's lifecycle state without fetching the full result.

Use after any *_async call (kimi_delegate_async, kimi_consult_async, kimi_review_changes_async) or any sync consult/review/delegate (whose meta.job_id names its record). Returns status, elapsed time, expiry, and result_available; when it is true, call kimi_job_result. result_ok reports a done job's producer-declared outcome — true (success), false (a stored error envelope), or null (running, no stored envelope, an unclassifiable payload, or a record finalized before this field) — so you can spot a stored FAILURE without fetching it. It does not guarantee the payload is still fetchable; a cross-release record may report an outcome yet fail kimi_job_result with job_result_incompatible. Free — no model call.

Honor poll_after_ms between polls — for a running job it GROWS with elapsed runtime (bounded), so following it backs you off instead of tight-looping (a delegate often runs ~20s). expires_at is null while running and is set once the job finishes; results are then retained ttl_seconds past that completion.

Inputs: job_id (required), workspace_root. Returns: ok

kimi_modelsList Kimi models (free)A
Read-only

List Kimi model slugs you can pass as model, with each model's advertised reasoning-effort set for reasoning_effort. Free — no model call.

Advisory discovery only: read from Kimi's on-disk cache when present, else a bundled fallback (source says which; the fallback carries no effort data). The kimi CLI validates the real slug and the backend validates the real effort, so an unlisted value may still work and a listed one may be unavailable to your account. Same payload as the kimi://models resource. Not fingerprint-stable — do not cache it by the capabilities fingerprint.

Inputs: no named parameters. Returns: ok

kimi_review_changesReview git changes (paid)A

Ask Kimi (a different model) to review your git changes for an independent second opinion.

PAID — this spends Kimi quota on every new call; use kimi_dry_run or kimi_status (both free) first if you only need to check scope or readiness.

scope: working_tree (tracked changes vs HEAD — untracked files follow the untracked policy and are NOT reviewed by default), branch (needs base, reviews base...HEAD), or commit (needs a commit SHA). The diff is gathered, secret- redacted, and bounded by this server; Kimi reviews it read-only and returns structured findings. Pass workspace_root (absolute) for the right repo. Optional extra_context (author intent, bounded like the diff) cuts false positives.

The result's top-level review_status and coverage disclose whether the model actually ran and what it was shown: a pass over partial coverage is surfaced as unknown, and a tree with nothing reviewable returns not_run, never a pass.

STATIC review, not a verify mode: the read-only agent profile gives Kimi no shell and no write tool, so it cannot run the project's checks to confirm its findings — treat them as unvalidated claims you verify yourself before acting.

Data egress: this sends the gathered diff to your configured provider via the kimi CLI. The diff is secret-redacted (best-effort), but your extra_context is sent raw (unredacted), Kimi auto-loads the resolved workspace's AGENTS.md and discovers skills from its own config (including extra_skill_dirs, which may point outside the workspace). Skill names and descriptions are exposed to the model up front, so that content can be sent even if your prompt never mentions it. The isolation setting does not suppress any of it: kimi's built-in skills always load, and AGENTS.md is read regardless.

Your inputs are sent raw and unredacted. Secret redaction is best-effort and covers the gathered diff and Kimi's returned output — not what you type, and not the files Kimi reads for itself.

Progress & recovery: blocks up to the resolved deadline (timeout_seconds, clamped 10-600s; when omitted, the server-configured value, built-in default 300s). If that deadline expires the run is terminated and its partial output is not recoverable or resumable, so for a multi-file or whole-branch review that may exceed it, prefer kimi_review_changes_async (a background job, built-in default 1800s deadline; poll kimi_job_status). Coarse notifications/progress streams while it blocks when your client requests it; some MCP clients background a long call before the deadline, so timeout_seconds bounds the run, not necessarily the inline wait — either way the detached run (meta.job_id) is recoverable via kimi_job_list→kimi_job_status→kimi_job_result.

Inputs: base, model, paths, scope, +9 more. Returns: ok

kimi_review_changes_asyncReview git changes in background (paid)A

Review your git changes in the background; get a job_id back immediately.

PAID — this spends Kimi quota on every new call; use kimi_dry_run or kimi_status (both free) first if you only need to check scope or readiness.

Same read-only behavior as kimi_review_changes (the diff is gathered, secret- redacted, and bounded, then reviewed read-only), but detached — prefer it for a multi-file or whole-branch review that can exceed the synchronous deadline (built-in default 300s), since a sync run whose deadline expires loses its partial work; this job's own deadline is separately configured (built-in default 1800s). The diff is gathered inside the job, so a bad base/commit comes back as the same structured error with zero spend (a bad scope is rejected by MCP input validation before the job starts). Starting a job commits to spend. Poll kimi_job_status; read/consume the review envelope with kimi_job_result/kimi_job_consume_result; stop with kimi_job_cancel. Pass workspace_root (absolute).

Data egress: same as kimi_review_changes — sends the secret-redacted diff plus your raw (unredacted) extra_context to your configured provider via the kimi CLI; Kimi may also Kimi auto-loads the resolved workspace's AGENTS.md and discovers skills from its own config (including extra_skill_dirs, which may point outside the workspace).

Your inputs are sent raw and unredacted. Secret redaction is best-effort and covers the gathered diff and Kimi's returned output — not what you type, and not the files Kimi reads for itself.

Inputs: base, model, paths, scope, +7 more. Returns: ok

kimi_statusCheck Kimi readiness (free)A
Read-only

Check that the kimi CLI is installed, authenticated, and a supported version, and report the resolved defaults. Free — no model call. Run it before your first paid call in a session to confirm setup, and again whenever a run fails with a setup error. Spend: do not plan spend around rate_limit — it always reports unavailable, and that is not a failure. kimi exposes no quota-read channel and its provider is user-configured, so there is nothing authoritative to report. The only quota signal this server can give you is the kimi_rate_limited error on a call that was actually throttled; it carries retry_after_ms.

Inputs: no named parameters. Returns: ok

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.4/5.0

    Scored across 16 tools

    Disambiguation5/5

    Each tool has a clearly distinct role: setup introspection, model/capability discovery, three separate paid operation modes, their async counterparts, per-mode dry runs, and job lifecycle management. Even the job tools split cleanly into status, result, consume, cancel, and list functions.

    Naming Consistency5/5

    All tools share the kimi_ prefix and snake_case convention, with predictable suffixes like _async, _dry_run, and kimi_job_*. The naming is uniform and easy to navigate even though discovery tools are noun-style while operation tools are verb-style.

    Tool Count4/5

    At 16 tools, this is slightly above the typical well-scoped range, but the count is justified by the three natural groups: metadata/status, paid operations with dry-run and async variants, and job lifecycle. No tool feels redundant, though the surface is a bit large.

    Completeness5/5

    The tool surface covers the full intended workflow: preflight status, capability and model discovery, three operation modes, dry-run previews, and a complete async job lifecycle from start through list, status, fetch, consume, and cancel. Sync calls also expose job IDs for recovery, leaving no obvious dead ends.

    Maintenance

    ActivitySlowing
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP bridge that enables Claude Code to consult the Kimi AI model in a structured challenge-loop for code review, debugging, and architecture evaluation.
      102 npm
      2
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Bridges Claude Code to Kimi Code via MCP, enabling task delegation with file and command execution.
      3
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Bridges MCP clients to Moonshot AI's Kimi Code CLI, enabling file analysis, brainstorming, batch tasks, code reviews, and session management within editors like Claude Desktop and Cursor.
      14
      116 npm
      1
      MIT
    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables MCP clients such as Claude, Cursor, and VS Code to delegate coding tasks to an OpenCode server, including asking questions, running background jobs, monitoring progress, responding to input/permissions, and reviewing changes across projects.
      22,181 npm
      MIT