moonbridge
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.
Check readiness and inventory (free):
kimi_statusverifies the Kimi CLI, authentication, version, and resolved defaults;kimi_capabilitieslists tools/tiers/contracts;kimi_modelslists available model aliases and reasoning efforts.Consult Kimi (paid):
kimi_consult/_asyncruns read-only Q&A or second opinions under a restricted agent profile with no shell or write tools.Review git changes (paid):
kimi_review_changes/_asyncreviews working-tree, branch, or commit changes and returns structured findings, coverage, and a verdict.Delegate coding tasks (paid):
kimi_delegate/_asyncimplements a task in a throwaway git worktree and returns a reviewable diff that is never applied automatically.Preview before spending (free):
kimi_dry_runandkimi_delegate_dry_runshow scope, prompt size, redactions, truncation, and deadline advisories without calling Kimi.Manage background jobs (free):
kimi_job_status,kimi_job_result,kimi_job_consume_result,kimi_job_cancel, andkimi_job_listlet you poll, recover, fetch, consume, cancel, and list long-running work.Configure behavior: environment variables control timeouts, default model/effort, isolation, input/diff size limits, job TTL/max/count, logging, and supported Kimi versions.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@moonbridge Get Kimi's second opinion on this approach."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Moonbridge
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.
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 on0.35.0and0.39.1; other patch releases in those minors are assumed compatible, not verifiedPython ≥ 3.11,
uv, andgitmacOS 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 configSee 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@moonbridgeStart 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@moonbridgeOther 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 callGet 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 declaringRead, Glob, Grepreports 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:
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.
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.
Kimi loads context you did not mention. It auto-loads the workspace's
AGENTS.mdand discovers skills from its own user/project directories and from theextra_skill_dirsentries in itsconfig.toml, which may point anywhere on disk. Its built-in skills always load. Theisolationsetting 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 |
| free | readiness, version, provider configuration, resolved defaults |
| free | full inventory, schemas, per-tool error codes |
| free | model aliases from your |
| paid | read-only Q&A |
| paid | structured review of |
| paid | returns a reviewable diff, never applied |
| free | preview scope, diff size, redactions before spending |
| free | background job lifecycle |
Two details prevent surprising runs:
modeltakes an alias, not a provider model id — whatever you defined as[models."<alias>"]inconfig.toml. An unknown alias is rejected asinvalid_model.reasoning_effortis 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 |
| 300 | per-call wall clock, clamped 10–600 |
| unset | default model alias |
| unset | default effort |
|
|
|
| 200000 | bound on gathered context |
| 200000 | bound on a returned diff |
| 86400 / 1800 / 50 | background job limits |
|
| job records |
|
| logging |
|
| supported |
| 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 CLIThe 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@moonbridgeIn 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-mcpIn 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
kimiCLI 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
kimiversion.Releasing — the ordered release runbook.
Changelog · Architecture decision records — decision history, not current policy.
Available Tools
16 toolskimi_capabilitiesList server capabilities (free)ARead-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)ARead-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)ARead-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)AIdempotent
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)ARead-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)ARead-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)ARead-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)ARead-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)ARead-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
Scored across 16 tools
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.
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.
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.
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
Related MCP Connectors
Query your team's AI coding history and act on HypAware recommendations from any MCP client.
A paid remote MCP for OpenAI Codex agent coordination MCP, built to return verdicts, receipts, usage
Use AI models for chat, image, and video generation from Claude Code and other MCP hosts.
A paid remote MCP for CodeG, built to return verdicts, receipts, usage logs, and audit-ready JSON.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn 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 npm2MIT
- AlicenseAqualityDmaintenanceBridges Claude Code to Kimi Code via MCP, enabling task delegation with file and command execution.3MIT
- AlicenseAqualityDmaintenanceBridges 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.14116 npm1MIT
- AlicenseNot gradedqualityAmaintenanceEnables 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 npmMIT