kimi-cli

name: kimi-cli description: Delegate coding tasks to Kimi CLI (Moonshot AI's coding agent). Use for building features, fixing bugs, refactoring, PR reviews, and batch processing. Supports non-interactive print mode, session management, and subagents. Requires kimi-cli installed and authenticated. version: 1.0.0 author: tmdgusya license: MIT metadata: hermes: tags: [Coding-Agent, Kimi, Moonshot-AI, Code-Review, Refactoring] related_skills: [claude-code, codex, hermes-agent]

Kimi CLI

Delegate coding tasks to Kimi Code CLI via the Hermes terminal. Kimi CLI is Moonshot AI's autonomous coding agent — it can read/edit code, execute shell commands, search/fetch web pages, and autonomously plan and adjust actions.

Prerequisites

• Kimi CLI installed via uv: uv tool install --python 3.13 kimi-cli
  • See official install guide for alternatives
• Authenticated: run kimi once, then enter /login to configure platform and API key
• Verify: kimi --version

One-Shot Tasks (Non-Interactive, Recommended)

Use --print -p for one-shot tasks. Print mode is non-interactive, auto-approves all actions (implicitly enables --yolo), and outputs the result to stdout.

# Foreground — simple task
terminal(command="kimi --print -p 'Add error handling to the API calls'", workdir="/path/to/project")

# Foreground — quiet mode (final answer only, no intermediate steps)
terminal(command="kimi --quiet -p 'Explain what this project does'", workdir="/path/to/project")

# Background — long coding task
terminal(command="kimi --print -p 'Refactor the auth module to use JWT tokens'", workdir="/path/to/project", background=true, timeout=600)

Print mode details

• --print — non-interactive, auto-approves all operations, exits when done
• --quiet — shorthand for --print --output-format text --final-message-only (only the final answer)
• --final-message-only — skip intermediate tool call output, print only the final message
• --output-format stream-json — JSONL output for programmatic parsing
• --input-format stream-json — JSONL input via stdin

Exit codes (for scripting/CI)

Background Mode (Long Tasks)

# Start in background
terminal(command="kimi --print -p 'Implement the feature described in plan.md'", workdir="~/project", background=true)
# Returns session_id

# Monitor progress
process(action="poll", session_id="<id>")
process(action="log", session_id="<id>")

# Kill if needed
process(action="kill", session_id="<id>")

Interactive Mode (PTY)

For tasks that need back-and-forth interaction:

terminal(command="kimi", workdir="~/project", pty=true)

In interactive mode, use these slash commands:

• /help — show available commands
• /new — create new session
• /sessions — list and switch sessions
• /compact — compress context to free tokens
• /clear — clear conversation context
• /export — export session as Markdown
• /model — switch model or thinking mode
• /login — configure API platform and key

Session Management

# Continue most recent session
terminal(command="kimi --continue --print -p 'Continue where we left off'", workdir="~/project")

# Resume specific session
terminal(command="kimi --session abc123 --print -p 'Pick up this session'", workdir="~/project")

Model and Thinking Control

# Use a specific model
terminal(command="kimi --print -m kimi-k2-thinking-turbo -p 'Solve this hard problem'", workdir="~/project")

# Disable thinking mode (faster, less reasoning)
terminal(command="kimi --no-thinking --print -p 'Quick formatting fix'", workdir="~/project")

# Enable thinking mode explicitly
terminal(command="kimi --thinking --print -p 'Analyze the architecture tradeoffs'", workdir="~/project")

PR Reviews

# In the PR branch, review against main
terminal(command="gh pr checkout 42", workdir="~/project")
terminal(command="kimi --print -p 'Review this PR against main. Check for bugs, security issues, and code style.'", workdir="~/project")

Or with git worktrees:

terminal(command="git worktree add /tmp/pr-42 pr-42-branch", workdir="~/project")
terminal(command="kimi --print -p 'Review the changes in this branch vs main'", workdir="/tmp/pr-42")

Parallel Work

Spawn multiple Kimi CLI instances for independent tasks:

# Using worktrees for isolation
terminal(command="git worktree add -b fix/issue-78 /tmp/issue-78 main", workdir="~/project")
terminal(command="git worktree add -b fix/issue-99 /tmp/issue-99 main", workdir="~/project")

# Launch in parallel
terminal(command="kimi --print -p 'Fix issue #78: <description>. Commit when done.'", workdir="/tmp/issue-78", background=true)
terminal(command="kimi --print -p 'Fix issue #99: <description>. Commit when done.'", workdir="/tmp/issue-99", background=true)

# Monitor all
process(action="list")

# Cleanup
terminal(command="git worktree remove /tmp/issue-78", workdir="~/project")

Key Flags

Subcommands

Built-in Tools

Kimi CLI has these built-in tools available to the agent:

Built-in Subagents

Configuration

Default config location: ~/.kimi/config.toml

Key config items:

• default_model — model name (e.g., kimi-code/kimi-for-coding)
• default_thinking — enable thinking by default
• default_yolo — auto-approve by default
• loop_control.max_steps_per_turn — max agent steps (default: 100)
• loop_control.max_retries_per_step — max retries (default: 3)

Kimi CLI supports multiple providers: Kimi, OpenAI, Anthropic, Gemini, VertexAI. See providers docs.

Pitfalls

Command name varies by install method

Depending on how it was installed, the command may be kimi or kimi-cli. Check with which kimi 2>/dev/null || which kimi-cli. The skill uses kimi as default — adjust if your system uses kimi-cli.

No git repo required

Unlike Codex, Kimi CLI does NOT require a git repository. It works in any directory.

Print mode is the safest non-interactive option

Avoid using PTY mode with background=true — prompts may not get submitted correctly. Use --print mode instead, which is designed for non-interactive execution.

Exit code 75 means retry

Exit code 75 indicates transient errors (rate limits, server errors, timeouts). Implement retry logic in scripts:

kimi --print -p "Run task"
code=$?
if [ $code -eq 75 ]; then
  sleep 10
  kimi --print -p "Run task"
fi

Context compaction

With 262K context, Kimi CLI auto-compacts when context usage reaches ~85%. For very long sessions, consider using /compact or starting fresh sessions.

File truncation on multi-file generation

Like other coding agents, Kimi CLI may silently truncate files when generating many files at once. Always verify with import checks after bulk generation:

python3 -c "import sys; sys.path.insert(0, 'src'); from pkg import module_a, module_b; print('OK')"

Rules

1. Use --print mode for all automated tasks — it's non-interactive and auto-approves
2. Use --quiet for simple queries — only the final answer, no intermediate noise
3. Use workdir — keep the agent focused on the right directory
4. Background for long tasks — use background=true and monitor with process tool
5. Don't interfere — monitor with poll/log, be patient with long-running tasks
6. Parallel is fine — run multiple Kimi CLI processes for independent tasks
7. Check exit codes — 0=success, 1=fail, 75=retry
8. No git repo needed — works in any directory, unlike Codex
9. Verify multi-file output — run import checks after bulk file generation