Delegate a coding task (paid)
kimi_delegateOffload coding tasks to Kimi in a throwaway git worktree and receive a reviewable diff. Inspect the changes, then apply them to your repository only after review.
Instructions
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.
Input Schema
| Name | Required | Description | Default |
|---|---|---|---|
| task | Yes | The coding task for Kimi to implement inside a throwaway git worktree; the resulting diff is returned for review, not applied to your tree. Must be non-blank: empty or whitespace-only is rejected before any model call. | |
| model | No | Override the Kimi model slug for this call; defaults to the server/Kimi default when unset. | |
| detail | No | Response verbosity: 'summary' (default) omits the raw model text; 'full' includes it. | summary |
| isolation | No | Which skills Kimi loads: 'inherit' (own user/project discovery) or 'ignore-skills' (empty dir). Built-ins load either way; this reduces loading, not isolation. Default: server-configured, per kimi_status. More: kimi://params. | |
| workspace_root | No | Absolute path to the target repo root — pass it to target the intended repo (MCP roots are unavailable); otherwise the call falls back to the server's own cwd and sets meta.workspace_warning. | |
| idempotency_key | No | Optional dedup key scoped to THIS tool + workspace. Same key + same args replays the prior result with no new spend; different args are refused (idempotency_conflict). Sync and _async are separate tools and never share a key. Omit for none; retention is bounded. Lifecycle: kimi://params. | |
| timeout_seconds | No | Per-call wall-clock timeout in seconds, clamped to 10..600 (out-of-range values are coerced, not rejected). Defaults to the server's configured timeout. | |
| reasoning_effort | No | Override the Kimi reasoning effort for this call (a model_reasoning_effort override); omit or pass null for the server default (MOONBRIDGE_REASONING_EFFORT) or Kimi's own resolution. An open, per-model string the backend validates at run time — commonly minimal|low|medium|high|xhigh; kimi_models lists each model's advertised set (advisory). Rejection and bounds detail: kimi://params. |
Output Schema
| Name | Required | Description | Default |
|---|---|---|---|
| ok | Yes |