kimi-swarm-bridge
Summary: This MCP server delegates tasks to Kimi Code (with native AgentSwarm) and lets you track, recover, review, cancel, and configure that work from an MCP client.
Delegate async work (
kimi_delegate_task): start or continue a task, return immediately with durablejobId,sessionId,promptId, status, andwebUrl.Delegate and wait (
kimi_delegate_and_wait): run a task and block until idle/blocked/failed/aborted or your timeout, returning handoff and review data plus structured swarm evidence.Continue a session (
kimi_continue_task): send follow-ups, corrections, or extra work while preserving prior context.Wait/poll (
kimi_wait_until_idle): poll an owned session until idle, awaiting approval or a question, failed, aborted, or timeout.Get results (
kimi_get_handoff): read the final assistant result, changed files, committed/working-tree changes, Git baseline evidence, and a freshswarmEvidencesnapshot.Review evidence (
kimi_review_package): build a reviewer-oriented snapshot with change stats and review checklist; get exact patch content per file withkimi_get_diff.Cancel work (
kimi_abort): stop a running owned session and persist an aborted state.Recover after timeout/disconnect/restart: list connector-owned durable jobs (
kimi_recent_jobs) or fall back to raw session discovery (kimi_recent_sessions,kimi_find_recent_session).Diagnose the bridge (
kimi_bridge_status): check readiness, auth, backend/version metadata, and suggested next actions without running an LLM task.Run native AgentSwarm: set
swarmMode=true(verified before submission) and passplan,task,acceptanceCriteria,depth,thinking, andmodel.Tune swarm agents (
kimi_swarm_settings): read or raise/lower the per-task worker ceiling and set theofferKimipreference (ask/auto/off).Choose models (
kimi_model_settings): list available ai& models with prices and set coordinator and/or worker models (includingdefaultandsame).
Reports Git repository state for delegation handoffs, including committed changes, working-tree changes, and pre-existing dirty paths.
Kimi AgentSwarm Bridge for ai&
An open-source MCP bridge for running Kimi Code — including native AgentSwarm — with inference provided through ai&.
This fork is built around one runtime policy:
inference always goes through
https://api.aiand.com/v1credentials are supplied with
AIAND_API_KEYthe model is configurable with
KIMI_MODEL_NAMEthe default model is
zai-org/glm-5.3(moonshotai/kimi-k3is also tested); users can switch models from chatKimi Code's REST API stays loopback-only
the externally exposed interface is MCP
The project began as a fork of ximenchuifeng/codex-kimi-bridge and remains available under the MIT License.
Organization deployment
To give every employee Kimi Swarm in Claude — per-employee isolated workspaces, sign-in through your identity provider, file upload/download, and persistence — deploy the Cloudflare edition: see docs/cloudflare-deploy.md. Share docs/using-kimi-swarm.md with employees. Also share the Kimi Swarm skill (kimi-swarm.zip on each release; Team and Enterprise owners can add it for everyone). With it, Claude offers to hand big, independent parts of a request to Kimi without being asked.
Related MCP server: firepass-mcp
Benchmarks
Web research briefs, with Kimi Swarm (GLM-5.3 on ai&) and Claude (Claude Code, Opus) given the same brief at the same time. Measured 2026-09-25 on the Cloudflare deployment. The number of agents is Kimi's own choice, up to the cap.
Brief | Kimi agents | Kimi time | Claude time | Empty cells ³ (Kimi / Claude) | Cost (Kimi / Claude) |
12 platforms, 7 fields | 4 | 3m49s | 1m00s | — | $0.78 / — |
12 platforms, 7 fields | 12 | 2m05s | 1m39s ¹ | — | $0.92 / — |
30 managed Postgres providers | 10 | 3m46s | 1m31s | 11 / 13 | — / — |
30 email APIs, with cost calculations | — | 4m46s | 1m59s | 7 / 45 | $1.42 / — |
30 vector databases, every cell required | 15 | 4m26s | 3m56s | 17 / 14 | $2.30 / ~$3–5 ² |
Same brief, after the v0.5.0 speed changes | 15 | 4m24s | 3m56s | 7 / 14 | $1.63 / ~$3–5 ² |
¹ Separate run of the same brief; Claude's simultaneous rerun reused its earlier work (28s), so it isn't a fair comparison. ² Measured from the account's usage before and after. That session carried a long context, which raises Claude's cost. ³ Table cells marked n/d, not documented, not published, not found or unknown, counted the same way in both reports. Accuracy was not graded against a reference.
What the numbers show:
Short briefs: Claude is faster. Kimi has a fixed overhead of about 2 minutes (starting the swarm and merging results) that small jobs can't hide.
Completeness: in normal runs Kimi left far fewer cells empty (7 vs 45 on the email brief, 11 vs 13 on Postgres), because each worker keeps searching its own items. When both were told to fill every cell, the first run finished about level (17 vs 14 empty cells out of 150); after the v0.5.0 changes Kimi left 7.
Large, complete briefs: the speed gap closes. Claude's extra checks ran one after another while Kimi's ran across 15 agents in parallel: 4m24s vs 3m56s, with Kimi costing about half ($1.63).
Background work: Kimi runs in its own sandbox, so Claude stays free for other work while a swarm runs.
Scaling beyond these tests: The agent cap goes up to 128 and can be raised live with no restart (POST /admin/sandboxes/<id>/limits); parallelism is set by SWARM_CONCURRENCY (20 here), which takes effect when the container restarts. The limit in practice is ai&'s per-organization limit on requests in flight at once, shared by every key in the org (100 on a new account, 1000 after the first payment at the time of writing). The Worker keeps the whole deployment under AIAND_CONCURRENCY_LIMIT so a busy organization queues briefly instead of hitting errors; a 20-worker run peaked at about 70 requests in flight. We expect Kimi to pull ahead on longer, wider jobs, but that is a projection, not yet measured.
Moonshot's own results for Agent Swarm (Kimi K2.5, not these tests) point the same way. In wide-search tasks, the swarm needed 3–4.5× fewer critical steps than a single Kimi agent, which Moonshot reports as up to 4.5× less wall-clock time. It also scored higher than Claude Opus 4.5 on BrowseComp and WideSearch, which measure accuracy rather than speed (Kimi K2.5 tech blog). Those runs used Moonshot's model and harness, with up to 100 sub-agents; this bridge defaults to GLM-5.3 and a cap of 20.
Model choice per task
By default Claude picks a model tier for each task it hands to Kimi, and the user can pin specific models instead ("use GLM-5.3 for everything"):
Tier | Coordinator / workers | Use for |
economy (default) | GLM-5.3 / DeepSeek V4 Flash | most research and data collection, checking a list against criteria, extraction, formatting |
balanced | GLM-5.3 / GLM-5.3 | complex comparison or synthesis that needs nuanced judgment |
premium | GLM-5.3 / GLM-5.3, deep research | high-stakes work where accuracy matters more than time and cost |
The tiers come from running the 30-vector-database brief once per ai& model on 2026-10-01: each model as the workers under a GLM-5.3 coordinator, which is how a tier uses it. Model costs are Kimi's ai& token costs; Brave searches and page reading are extra and similar across runs. Agreement is the share of comparable cells (max dimensions, hybrid search, license, cheapest price) that match the GLM-5.3 report; neither report was graded against a reference, so it measures consistency, not accuracy.
Workers (GLM-5.3 coordinator) | Time | Model cost | Empty cells (of 150) | Agreement with GLM-5.3 |
GLM-5.3 (reference) | 3m52s | ~$1.63 ¹ | 13 | — |
DeepSeek V4 Flash | 3m40s | $0.90 | 9 | 89% |
Gemma 4 31B | 5m24s | $0.49 | 18 | 91% ² |
Qwen3.6 27B | 3m39s | $1.34 | 14 | 83% |
GLM-5.2 | 3m13s | $2.11 ³ | 14 | 85% |
Qwen3.8 27B | 6m32s | $1.38 | 17 | 76% |
gpt-oss-120b | not finished in 8 min | — | — | — |
Motif 3 | not finished in 8 min | — | — | — |
Kimi K2.7 Code | not finished in 8 min | — | — | — |
DeepSeek V4 Pro | not finished in 8 min | — | — | — |
¹ Earlier run of the same brief (v0.5.0); the reference report is the later 3m52s run. ² Much shorter report (28 KB vs 90–136 KB); the coordinator gave each worker two vendors. ³ The coordinator launched the swarm twice.
What else the runs showed:
Coordinator role: DeepSeek V4 Flash as coordinator did not finish in 12 minutes (its workers looped), and gpt-oss-120b wrote the swarm call as text until the prompt said plainly that it must be a real tool call. Kimi K3 as coordinator stalled while writing the report (ai& sent no response to its largest requests for minutes), so premium uses deeper research rather than K3 by default. The coordinator stays on the deployment model in every tier.
Why some workers did not finish: gpt-oss-120b scraped Bing and DuckDuckGo with shell commands instead of using the web tools; Kimi K2.7 Code barely searched; Motif 3 and DeepSeek V4 Pro kept working past the time budget.
Price per token is not cost per task: Qwen3.6 costs a third of GLM-5.3 per input token but caches at $0.20 per million, so its run cost about the same.
Economy is the default because it matched GLM-5.3 on the benchmark at about half the model cost and gave correct verdicts on a 43-company criteria check (spot-checked against the live sites). With Flash workers each worker gets exactly one item, so long lists run in batches of up to the agent ceiling (43 items took about 12 minutes).
Admins can change the tiers with KIMI_MODEL_TIERS and the default tier with KIMI_DEFAULT_MODEL_TIER (see docs/cloudflare-deploy.md).
What it provides
The bridge exposes Kimi Code through MCP with support for:
task delegation
synchronous delegate-and-wait workflows
continuation of existing Kimi sessions
waiting and polling
handoff retrieval
cancellation
review packages
recent-session discovery
native Kimi Code
AgentSwarmauthenticated Streamable HTTP MCP
persistent Kimi and bridge state under
/data
The hosted container runs:
MCP client
|
v
Streamable HTTP MCP :3000
|
v
Kimi bridge
|
v
Kimi Code server 127.0.0.1:58627
|
v
ai& https://api.aiand.com/v1
|
v
selected ai& modelKimi's administrative REST API is intentionally not published outside the container.
Requirements
For development:
Git
Node.js 22.19 or newer
pnpm 10.x
The Docker image pins:
Node.js 22.19
@moonshot-ai/kimi-code@0.42.0pnpm 10.34.5
ai& configuration
AIAND_API_KEY is required by the official runtime.
The following inference settings are enforced:
Provider protocol: OpenAI-compatible
Base URL: https://api.aiand.com/v1
Credential source: AIAND_API_KEYThe model remains configurable:
export KIMI_MODEL_NAME="moonshotai/kimi-k3"If KIMI_MODEL_NAME is not set, the bridge defaults to:
zai-org/glm-5.3Other models exposed by ai& may work, but native AgentSwarm compatibility should be verified per model. zai-org/glm-5.3 is the default and moonshotai/kimi-k3 is also tested.
Native AgentSwarm
Swarm execution uses Kimi Code's native session profile and native AgentSwarm tool.
The bridge does not implement a custom swarm layer.
For a swarm task it:
creates or uses a Kimi session
updates the session profile with
swarm_mode=trueverifies swarm activation through Kimi status
submits the prompt
lets Kimi invoke its native
AgentSwarmtoolwaits for the coordinator to synthesize worker results
The Docker image defaults to 4 concurrent workers (KIMI_CODE_AGENT_SWARM_MAX_CONCURRENCY=4). The Cloudflare edition defaults to 20 (SWARM_CONCURRENCY) and lets Kimi choose how many agents to use, up to a ceiling of 20 that an admin can change live.
Docker
Build:
docker build -t kimi-swarm-bridge .Generate an MCP bearer token:
export KIMI_MCP_AUTH_TOKEN="$(openssl rand -hex 32)"Set your ai& API key in the environment:
export AIAND_API_KEY="..."Run:
docker run -d \
--name kimi-swarm-bridge \
-p 127.0.0.1:3000:3000 \
-e AIAND_API_KEY \
-e KIMI_MCP_AUTH_TOKEN \
-v kimi-swarm-data:/data \
kimi-swarm-bridgeOnly MCP port 3000 should be published. Kimi remains on loopback inside the container.
HTTP MCP
The Streamable HTTP endpoint is:
POST /mcp
GET /mcp
DELETE /mcpAuthentication:
Authorization: Bearer <KIMI_MCP_AUTH_TOKEN>Health endpoints:
GET /healthz
GET /ping/ping exists for managed-host health checks.
TLS is expected to be terminated by the hosting platform or reverse proxy.
Runtime environment variables
Required:
AIAND_API_KEY
KIMI_MCP_AUTH_TOKEN when HTTP transport is usedCommon optional settings:
KIMI_MODEL_NAME
KIMI_CODE_AGENT_SWARM_MAX_CONCURRENCY
KIMI_THINKING
KIMI_PERMISSION_MODE
KIMI_MCP_TRANSPORT
KIMI_MCP_HTTP_HOST
KIMI_MCP_HTTP_PORT
PORTThe official runtime intentionally overrides attempts to redirect KIMI_MODEL_BASE_URL, KIMI_MODEL_PROVIDER_TYPE, or KIMI_MODEL_API_KEY away from ai&.
Persistent data
The container uses:
/data
├── kimi-code/
├── jobs/
└── state/Mount /data on persistent storage for hosted deployments.
Handoff change metadata
Delegation handoffs report Git state using three separate fields:
committedChanges— changes committed during the delegated Kimi session.workingTreeChanges— uncommitted changes currently present in the worktree.initialDirtyPaths— paths that were already modified before delegation began.
Keeping these fields separate lets an MCP client distinguish work produced by the delegated task from pre-existing local changes.
Local development
Install dependencies:
pnpm install --frozen-lockfileType-check:
pnpm typecheckBuild:
pnpm buildRun tests:
pnpm testThe optional local Codex plugin validator test is skipped when the external Codex plugin-creator validator is not installed.
Claude Desktop with a self-hosted bridge
The Cloudflare edition is added as a connector in Claude (web and Desktop); no local setup is needed.
For a self-hosted Docker bridge, scripts/claude-desktop/ has a small stdio wrapper that forwards Claude Desktop to your bridge over Streamable HTTP. It reads the bearer token from the macOS Keychain, so the token stays out of Claude's config:
read -s KIMI_MCP_AUTH_TOKEN
/usr/bin/security add-generic-password -a "$(/usr/bin/id -un)" -s kimi-swarm-mcp -w "$KIMI_MCP_AUTH_TOKEN" -U
unset KIMI_MCP_AUTH_TOKEN
mkdir -p ~/.claude/bin
cp scripts/claude-desktop/kimi-mcp-bridge.py scripts/claude-desktop/kimi-mcp-desktop.sh ~/.claude/bin/
chmod 700 ~/.claude/bin/kimi-mcp-*Then merge this entry into mcpServers in ~/Library/Application Support/Claude/claude_desktop_config.json and restart Claude Desktop:
{
"mcpServers": {
"kimi-swarm": {
"command": "/Users/YOUR_USERNAME/.claude/bin/kimi-mcp-desktop.sh",
"env": { "KIMI_MCP_URL": "https://your-bridge.example.com/mcp" }
}
}
}Hosted delegations run in the container, so use cwd: /workspace; local macOS paths are not visible there.
Long jobs, recovery and AgentSwarm evidence
For long-running work, prefer the asynchronous sequence:
Call
kimi_delegate_task.Keep the returned
jobIdandsessionIdwhen available.Call
kimi_wait_until_idlewith that session ID.When the job is
idle, callkimi_get_handofforkimi_review_package.
kimi_delegate_and_wait remains convenient for work expected to finish while
the caller stays connected. Its wait may time out, and an MCP/client transport
may also disconnect before the tool response is delivered. Neither condition
means the underlying Kimi job should be submitted again.
When durable jobs are configured, recovery should start with
kimi_recent_jobs. The registry is persistent and connector-owned, so after a
client timeout, reconnect, or bridge restart it can recover the durable
jobId, bound Kimi sessionId, prompt ID, last known status, and cached
result/error data without relying on raw session-title guessing. After
recovering the session ID, continue with kimi_wait_until_idle and then
kimi_get_handoff.
The durable registry is an ownership and recovery index; Kimi remains the
source of truth for the live session and transcript. A direct
kimi_get_handoff refreshes the authoritative Kimi session status and
reconciles the durable job record.
Durable jobs are enabled only when both variables are configured:
KIMI_ORGANIZATION_ID=<customer-or-organization-id>
KIMI_CONNECTOR_INSTANCE_ID=<stable-connector-instance-id>The default SQLite database is:
/data/kimi-swarm-bridge/jobs.sqliteKIMI_JOB_DB_PATH can override that path. Hosted deployments should place the
database on persistent storage. Each Docker runtime serves one
organization; possession of a
job ID or Kimi session ID is not treated as authorization.
For native AgentSwarm acceptance, the final kimi_get_handoff includes a
fresh structured swarmEvidence snapshot. Verify values such as:
swarmEvidence.available: true
swarmEvidence.nativeAgentSwarmObserved: true
swarmEvidence.agentSwarmCallCount: 1
swarmEvidence.requestedWorkerCount >= 3
swarmEvidence.completedWorkerCount >= 3The evidence is derived from Kimi wire/session records rather than from the model's prose self-report.
stdio MCP
The original stdio transport remains available:
node dist/index.jsThe container defaults to Streamable HTTP transport for hosted use.
Security notes
Never commit
AIAND_API_KEY.Never commit
KIMI_MCP_AUTH_TOKEN.Kimi's REST API should remain bound to
127.0.0.1.Expose the MCP endpoint through HTTPS in hosted environments.
Durable job ownership requires both
KIMI_ORGANIZATION_IDandKIMI_CONNECTOR_INSTANCE_ID; job IDs and Kimi session IDs are not authorization credentials.Persistent MCP job/session state does not by itself provide hardened multi-tenant isolation. The Docker image is meant for one connector/runtime per organization; for many employees use the Cloudflare edition, which gives each signed-in employee their own container and keeps API keys out of containers.
Status
Validated so far:
ordinary Kimi inference through ai&
zai-org/glm-5.3(default) andmoonshotai/kimi-k3native Kimi AgentSwarm
up to 20 concurrent native workers in a single swarm (one per researched item)
coordinator and workers all using ai&
cancellation
authenticated Streamable HTTP MCP
MCP disconnect/reconnect with job recovery
Docker runtime (HTTP and stdio transports)
persistent Kimi state
managed-host-compatible
/pingandPORThandling
Validated on the Cloudflare edition (docs/cloudflare-deploy.md):
per-employee sign-in (Cloudflare Access OIDC) and isolated containers
files in and out of Claude chats through signed, single-use links
persistence of jobs, sessions and workspace files across container restarts
ai& and Brave Search keys held by the Worker, never inside containers
web research via Brave Search and a page reader that returns only relevant facts
per-employee daily ai& request budget and optional outbound logging/allowlist
per-employee agent ceiling set from chat
connector handshake and tool list served without waking a sleeping container
research, repository, download and coding tasks with web access
organization-wide ai& concurrency limit, changeable live
per-worker research time budget, so one slow worker doesn't hold up a swarm
the Kimi Swarm skill in the Claude desktop app: Claude offered Kimi for the independent half of a request, delegated on "yes" and combined both parts (the 20-item half took Kimi 2m44s)
See CHANGELOG.md for release notes.
Upstream and license
This repository is derived from:
ximenchuifeng/codex-kimi-bridge
The original copyright and MIT license are preserved in LICENSE.
Modifications in this fork are maintained by ryanameier.
MIT License.
Available Tools
14 toolskimi_abortAbort Kimi SessionADestructive
Abort an owned Kimi session that should no longer continue running. Use only after confirming the intended session because this interrupts in-flight delegated work and changes session state. When durable jobs are configured, a successful abort is persisted as aborted. Returns the sessionId and explicit abort confirmation. Session history may remain available after the abort.
Inputs: sessionId (required).
kimi_bridge_statusCheck Kimi Bridge StatusARead-onlyIdempotent
Check bridge and private Kimi-runtime readiness without submitting an LLM task. Use before delegation or when diagnosing connectivity, authentication, backend, or runtime problems. Returns health and auth status, safe Kimi backend/version metadata, diagnostics, and suggested next actions. It does not start a session, run AgentSwarm, expose credentials, or modify workspace content.
Inputs: no named parameters.
kimi_continue_taskContinue Kimi SessionADestructive
Submit follow-up instructions to an owned existing Kimi session while preserving prior context. Use for corrections, additional work, or deliberate continuation of a recovered job instead of creating a duplicate session. Returns the new promptId and running status; when durable jobs are configured, the registry is updated to the new prompt and running state. The continuation may execute commands and modify files, and optional model, thinking, and swarm settings apply to the new prompt.
Inputs: task (required), sessionId (required), plan, depth, +4 more.
kimi_delegate_and_waitDelegate Kimi Task and WaitADestructive
Start a Kimi task and wait until it becomes idle, blocked, failed, aborted, or the caller wait times out. Use this when the caller can remain connected for the expected task duration; prefer kimi_delegate_task for long-running work so the durable jobId is returned immediately. When durable jobs are configured, the result includes jobId. Idle results include handoff and review data; timeout does not abort the underlying Kimi session. After a client-side timeout or disconnect, use kimi_recent_jobs to recover the existing job rather than submitting the task again.
Inputs: cwd (required), plan (required), task (required), acceptanceCriteria (required), +7 more.
kimi_delegate_taskDelegate Kimi TaskADestructive
Start or continue a Kimi task and return immediately. Use this for long-running or asynchronous work where the caller should receive identifiers before completion. Returns a durable jobId when durable jobs are configured, plus sessionId, promptId, status, and webUrl. After a disconnect or client timeout, recover with kimi_recent_jobs, then use kimi_wait_until_idle and kimi_get_handoff instead of submitting a duplicate prompt. The task may execute commands and modify files in cwd. With swarmMode=true the bridge verifies Kimi swarm mode before submission; final AgentSwarm execution evidence is available from the handoff. Also consider it when the user did not mention Kimi: if part of a request is substantial (would take you several minutes, e.g. researching or comparing many items, reading many documents, building a report or file) and independent of the rest, offer to hand that part to Kimi so it runs while you do the rest; ask first unless kimi_swarm_settings shows offerKimi auto (off: only when asked). If the user agrees, send a self-contained brief here first, then do your part.
Inputs: cwd (required), plan (required), task (required), acceptanceCriteria (required), +5 more.
kimi_find_recent_sessionFind Recent Kimi SessionARead-onlyIdempotent
Find raw Kimi sessions whose titles contain a requested substring, optionally filtered by status and working directory. Use this only when the exact session is unknown and durable recovery through kimi_recent_jobs is unavailable or insufficient. Once a session is identified, prefer sessionId-based tools. Discovery does not grant ownership; session-oriented tools still enforce durable ownership when configured. This tool does not create or modify a session.
Inputs: titleContains (required), cwd, status, pageSize, +4 more.
kimi_get_diffGet Kimi File DiffARead-onlyIdempotent
Read the diff for one file in an owned Kimi session workspace. Use after kimi_get_handoff or kimi_review_package identifies a changed path and exact patch content is needed. Returns the requested path and diff content. This tool is read-only and does not modify the file, session, or durable job state.
Inputs: path (required), sessionId (required).
kimi_get_handoffGet Kimi HandoffARead-onlyIdempotent
Read the current or final handoff for an owned Kimi session. Use after kimi_wait_until_idle reports idle, or directly during recovery when the authoritative Kimi status and result need to be refreshed. Returns the assistant result, changed files, committed and working-tree changes, Git baseline evidence, and a fresh structured swarmEvidence snapshot. When durable jobs are configured, the bridge reconciles the durable status and caches the returned handoff. This tool does not submit another prompt or modify workspace content.
Inputs: sessionId (required).
kimi_model_settingsKimi Swarm ModelsAIdempotent
Show or change which ai& models Kimi uses. The coordinator plans the task, delegates to AgentSwarm workers and writes the result; the workers do the parallel work, and most of a swarm's tokens are theirs, so a cheaper worker model cuts cost the most. Call with no arguments to list the available models with prices (USD per million tokens) and the current choice. Call with coordinatorModel and/or workerModel (model ids from the list) when the user asks to switch models; use "default" to return the coordinator to the deployment default and "same" to make workers use the coordinator model. Changes apply to tasks started afterwards; the setting is per user and persists.
Inputs: workerModel, coordinatorModel.
kimi_recent_jobsList Recent Durable JobsARead-onlyIdempotent
List recent connector-owned durable jobs from the persistent bridge registry. Use this first after a client timeout, disconnect, bridge restart, or lost response to recover the existing jobId and bound Kimi sessionId without guessing or submitting a duplicate task. Returns status, prompt/session identifiers, workspace, swarm mode, cached result or error data, and timestamps. It does not contact Kimi, so registry recovery remains available when the Kimi runtime is temporarily unavailable. This tool is read-only.
Inputs: status, pageSize.
kimi_recent_sessionsList Recent Kimi SessionsARead-onlyIdempotent
List recent raw Kimi sessions with identifiers, statuses, titles, web links, and workspace metadata. Use this as a discovery fallback when durable job recovery is unavailable; when durable jobs are configured, prefer kimi_recent_jobs because it is connector-owned and persistent. Raw session discovery is not authorization: session-oriented tools still enforce durable ownership when configured. This tool only queries Kimi session metadata.
Inputs: status, pageSize, excludeEmpty, includeArchive.
kimi_review_packageBuild Kimi Review PackageARead-onlyIdempotent
Build a reviewer-oriented snapshot for an owned Kimi session from its handoff, changed files, Git statistics, and review checklist. Use after delegated implementation work when concise review evidence is needed, or when a fresh review snapshot is required after recovery. If kimi_delegate_and_wait already returned reviewPackage, reuse that unless newer evidence is needed. When durable jobs are configured, the package is cached in the job registry. This tool does not modify the session or workspace.
Inputs: sessionId (required).
kimi_swarm_settingsKimi Swarm SettingsAIdempotent
Show or change how many AgentSwarm workers Kimi may use per task. maxAgents is a ceiling: Kimi still decides how many workers each task needs and uses fewer for small tasks. Call with maxAgents when the user asks to raise or lower the agent limit (for example "increase the limit to 20"); call with no arguments to report the current settings. Values above the deployment cap are reduced to the cap. The response also reports concurrency, the number of workers that run at the same time (set by the deployment admin); extra workers queue, which keeps simultaneous ai& requests bounded, and Kimi backs off automatically if ai& rate-limits. offerKimi is the user's preference for Kimi taking independent parts of requests they did not send to Kimi: ask (default: offer and wait for a yes), auto (hand them over and say so) or off (only when the user asks for Kimi); read it before your first offer in a conversation, and save it when the user says to always do it or to stop asking.
Inputs: maxAgents, offerKimi.
kimi_wait_until_idleWait for Kimi SessionARead-onlyIdempotent
Poll an owned Kimi session until it is idle, awaiting approval, awaiting a question, failed, aborted, or the caller wait times out. Use the sessionId returned by delegation or recovered through kimi_recent_jobs. Returns normalized status and pending approval/question data when applicable. A timeout only ends this wait attempt; it does not abort the Kimi session or mark the durable job timed out. This tool does not modify workspace content.
Inputs: sessionId (required), timeoutMs.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 14 tools
Tools have largely distinct purposes, but there is some overlap between discovery tools (kimi_find_recent_session vs kimi_recent_sessions) and between delegation variants (kimi_delegate_task vs kimi_delegate_and_wait). The descriptions clarify the differences and intended usage, so selection should be reliable with careful reading.
All tool names follow the consistent 'kimi_' prefix + snake_case verb_noun pattern, such as kimi_delegate_task, kimi_get_handoff, and kimi_swarm_settings. No mixed conventions or inconsistent verb styles are present.
With 14 tools, the server is well-scoped for its bridge role, covering status, delegation, monitoring, recovery, settings, and finalization. Each tool serves a distinct operational need without redundancy or bloat.
The surface covers the full lifecycle of delegating to Kimi: check readiness, delegate (async/sync), wait, retrieve handoff, review, recover after disconnect, continue, and abort. Minor gaps like a separate 'list all sessions with filtering' beyond the raw find are mitigated by kimi_recent_jobs and kimi_recent_sessions.
Maintenance
Related MCP Connectors
- aXDeprecatedio.github.ax-platform
Agent-native collaboration network: orchestrate a team of long-running agents from any MCP client.
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
Remote MCP server for The Colony — a social network for AI agents (posts, DMs, search, marketplace).
Remote MCP server exposing your Node Command fleet (files, shell, processes, browser) to AI hosts.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server for cross-platform agent onboarding. Registers external agents, translates intents from LangChain, CrewAI, AutoGen, and A2A formats, and proxies cross-ecosystem transactions.MIT
- AlicenseAqualityCmaintenanceMCP server that turns Kimi K2.6 Turbo into an agentic coding assistant with tools for file operations, shell commands, and code search.429 PyPI2MIT
- AlicenseAqualityDmaintenanceBridges any MCP client (like Claude Code, Zed, VS Code) to any ACP coding agent, enabling multi-agent orchestration from a single chat interface.24627 npm12Apache 2.0
- AlicenseDqualityDmaintenanceEnables Codex to delegate implementation tasks to Kimi Code while managing server lifecycle and authentication automatically.111MIT