Kimi Code CLI

Overview

Kimi Code CLI is a next-generation AI coding agent from Moonshot AI, the team behind the Kimi K3 model that achieved state-of-the-art (SoTA) status on agentic benchmarks in mid-2026. Released as an open-source CLI tool, Kimi Code CLI is designed to be a drop-in replacement for existing terminal-based coding agents like Claude Code and Codex, offering a purpose-built terminal UI (TUI) optimized for long, focused agent sessions.

With over 4,900 GitHub stars and a launch star velocity of 1,600+ stars per day, Kimi Code CLI has rapidly become one of the most talked-about additions to the AI coding agent landscape. It represents Moonshot's strategic push from pure model provider into the agent tooling layer — bridging the gap between world-class model capabilities and everyday developer workflows.

Kimi Code CLI is part of a broader Kimi ecosystem, including Kimi Code (the coding agent), Kimi Work (the enterprise workspace), and Kimi K3 (the underlying model). The CLI runs in any terminal, requires no Node.js setup for end users (single binary distribution), and integrates with major IDEs including JetBrains and Zed via the Agent Client Protocol (ACP).

Features

• Single-binary distribution: Install with one command; no Node.js or Python environment needed for end users
• Purpose-built TUI: Terminal UI optimized for long agent sessions with streaming responses and interactive feedback
• Kimi-native model access: Ships with Moonshot's Kimi K3 as the default backbone, with support for external LLM providers
• Video input: Accept screen recordings and demo clips as context input — agents can "watch" code walkthroughs
• AI-native MCP configuration: Manage Model Context Protocol servers conversationally with /mcp-config — no JSON editing required
• Subagent dispatch: Spawn built-in coder, explore, and plan subagents in isolated contexts for parallel task execution
• Plugin ecosystem: Install skills, MCP servers, and data sources from a marketplace or directly from GitHub repositories
• Lifecycle hooks: Run local commands at key agent lifecycle points for auditing, notifications, or automation
• IDE integration via ACP: Native integration with JetBrains and Zed through the Agent Client Protocol
• Context preservation: Maintains session context across conversations with intelligent summarization
• Fast startup: TUI ready in milliseconds, significantly faster than many JavaScript/TypeScript-based agent CLIs

Installation

macOS / Linux (single binary):

curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash

Development (from source):

git clone https://github.com/MoonshotAI/kimi-code
cd kimi-code
pnpm install
pnpm build

Requirements (for development only):

• Node.js ≥ 24.15.0
• pnpm 10.33.0

Windows users: The CLI is primarily designed for macOS and Linux. Windows users can run it via WSL2.

Quick Start

# Install
curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash

# Authenticate with Kimi Code OAuth or Moonshot API key
cd ~/code/my-project
kimi

# On first launch, use /login to authenticate
# Then start a session:
# How do I refactor this codebase?

Core Concepts

The TUI (Terminal User Interface)

Kimi Code CLI's terminal UI is built on top of the open-source pi-tui library and is designed for long-duration agent sessions. Unlike chat-first CLIs, Kimi's TUI features:

• Persistent session history visible at a glance
• Streaming tool outputs shown inline with response text
• Subagent status indicators showing parallel task progress
• MCP server status dashboard showing connected tools and their state

Subagents

Kimi Code supports three built-in subagent types:

• coder: Focused code generation and refactoring agent
• explore: Codebase exploration and research agent
• plan: Planning and task decomposition agent

Subagents run in isolated contexts, meaning they have their own tool set, file access scope, and memory — preventing them from polluting the main session's state.

MCP Configuration

The /mcp-config command lets you add, remove, and configure MCP servers conversationally:

/mcp-config add github
/mcp-config remove filesystem
/mcp-config list

This removes the need to manually edit JSON configuration files, lowering the barrier to adopting MCP tools.

Advanced Features

Lifecycle Hooks

Kimi Code supports lifecycle hooks that run local commands at agent lifecycle events:

{
  "lifecycleHooks": {
    "onSessionStart": "echo 'Agent session started at $(date)' >> /var/log/agents.log",
    "onToolCall": "audit-log --tool-call",
    "onSessionEnd": "notify-slack --summary"
  }
}

Plugin Marketplace

The plugin ecosystem allows developers to extend Kimi Code with:

• Custom skills: Reusable prompt templates and tool definitions
• MCP server integrations: Pre-configured MCP server bundles
• Data source connectors: Direct integrations with databases, APIs, and file stores

IDE Integration (ACP)

Kimi Code integrates with JetBrains and Zed via the Agent Client Protocol (ACP):

Zed configuration (~/.config/zed/settings.json):

{
  "agent_servers": {
    "Kimi Code CLI": {
      "type": "custom",
      "command": "kimi",
      "args": ["acp"]
    }
  }
}

JetBrains: Available via ACP-compatible plugins that connect to Kimi Code's agent server.

Video Input

A distinctive feature of Kimi Code CLI is the ability to accept video input:

kimi video --input demo-recording.mp4 --query "What improvements would you make to this approach?"

This allows developers to share screen recordings, code walkthroughs, or demo videos as context, and have the agent analyze them — bridging a gap that text-only agents cannot fill.

Examples

Example 1: Refactor a codebase

> Find all TODO comments in this repo and suggest refactors
[agent analyzes codebase]
> /subagent coder "Implement refactor for src/main.py"
[coder subagent runs in isolated context]

Example 2: Set up MCP tools

> /mcp-config add github
> /mcp-config add fetch
> List all MCP tools available
[agent enumerates available tools]

Example 3: Video analysis

> /video ./architecture-review.mp4
[agent watches video]
> Based on the architecture review, what should we change in the service layer?

Example 4: Multi-agent exploration

> /subagent explore "Map the architecture of this monorepo"
[explore subagent analyzes codebase structure]
> /subagent plan "Break down the migration into tasks"
[plan subagent creates task list]

Pros

• ✅ Backed by a world-class model: Kimi K3's SoTA agentic benchmark performance (690 points on HN)
• ✅ Single-binary install: Zero runtime dependency friction for end users
• ✅ Purpose-built TUI: Optimized for long coding sessions, not just chat
• ✅ Subagent architecture: Clean isolation for parallel task execution
• ✅ Conversationally configured MCP: /mcp-config removes JSON editing friction
• ✅ IDE integration via ACP: Native JetBrains and Zed support
• ✅ Video input: Unique capability among terminal coding agents
• ✅ Lifecycle hooks: Enterprise-ready audit and automation support
• ✅ Fast startup: TUI ready in milliseconds

Cons

• ❌ Chinese-developed: May raise data residency or compliance concerns for some enterprises
• ❌ Kimi model dependency: Best experience requires Moonshot's Kimi models (API tiered pricing)
• ❌ Limited cross-platform support: macOS/Linux primary; Windows requires WSL
• ❌ Very new project: Ecosystem, documentation, and community are still maturing
• ❌ Niche plugin marketplace: Far smaller than Claude Code skills or Cursor extensions
• ❌ Documentation gaps: Still evolving with some areas incomplete
• ❌ Language: Some documentation and support may be primarily in Chinese

When to Use

• Developers wanting to evaluate Kimi K3 in practice: Kimi Code CLI is the most direct way to experience Kimi's agentic capabilities
• Teams looking for Claude Code alternatives: Especially in regions where Kimi offers competitive pricing
• Projects needing video/context-rich input: The video input feature is unmatched by competitors
• JetBrains/Zed users wanting agent integration: ACP-native integration is cleaner than web-based alternatives
• Organizations needing enterprise audit hooks: Lifecycle hooks provide a path to compliance

Comparison with Competitors

Feature	Kimi Code CLI	Claude Code	GitHub Copilot
Language	Rust + Node	TypeScript	Python
Install	Single binary	CLI install	VS Code extension
TUI	Purpose-built	Terminal	N/A (IDE-only)
Video Input	✅	❌	❌
Subagents	coder/explore/plan	Task-based	Limited
MCP Config	/mcp-config	JSON editing	—
IDE Integration	JetBrains, Zed (ACP)	VS Code	VS Code, JetBrains
Default Model	Kimi K3	Claude	GPT/Codex

Resources

• Official Website
• GitHub Repository
• Kimi K3 Model
• Kimi Work (Enterprise)
• Agent Client Protocol (ACP)

Related Projects

• MoonshotAI/kimi-cli — Kimi Code CLI (Python variant, 10.7K stars)
• OmniRoute — Multi-provider AI gateway with Kimi support
• AgentWatch — Local MCP proxy for agent data security