Kimi Code CLI: Terminal-Based Coding Agent

A terminal-based agent for code tasks

Kimi Code CLI is an AI coding agent that runs as a single executable in your terminal. It can read and edit code, run shell commands, search files, fetch web pages, and choose its next step based on feedback. It works out of the box with Moonshot AI's Kimi models (which the documentation describes as capable of handling long contexts and complex reasoning for code tasks) and supports configuration to use other compatible LLM providers.

Unlike browser-based AI assistants or IDEs with AI plugins, Kimi Code CLI is a command-line tool. You open a project folder and type `kimi` to start a session. The agent then operates in that directory, reading files, running git commands, executing npm or build scripts, and iterating on code based on your feedback. The terminal UI displays the agent's reasoning process, error messages, and tool calls in real time, so you see exactly what the agent is doing and can interrupt or redirect it at any point.

The README describes several distinguishing features: a single-binary distribution (no Node.js, no dependency hell), blazing-fast startup (the terminal UI is ready in milliseconds), a purpose-built text user interface optimized for long focused sessions, support for video input (you can drop a screen recording or demo clip and the agent watches it), and AI-native MCP (Model Context Protocol) configuration. This combination is designed for developers who spend most of their time in a terminal and prefer not to switch contexts between editor, browser, and chat interface.

Installation and first-time login

Install with one command. On macOS or Linux:

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

On Windows (PowerShell):

irm https://code.kimi.com/kimi-code/install.ps1 | iex

The installer downloads a prebuilt binary. No Node.js, no npm, no build step. On Windows, you must install Git for Windows first because Kimi Code CLI uses the bundled Git Bash as its shell environment. If Git Bash is installed in a non-standard location, set `KIMI_SHELL_PATH` to the absolute path of bash.exe.

After installation, verify it works by running `kimi --version`. To start a session, navigate to a project folder and run `kimi`. On first launch, you will be prompted to run `/login`, which lets you authenticate with either Kimi Code OAuth or a Moonshot AI Open Platform API key. After login, try your first task, such as "Take a look at this project and explain its main directories." The installer also supports npm-based installation, upgrade, and uninstall paths documented in the Getting Started guide.

Subagents, lifecycle hooks, and MCP configuration

Kimi Code CLI dispatches built-in subagents for focused work. The `coder` subagent specializes in writing and editing code. The `explore` subagent navigates and searches the codebase. The `plan` subagent creates implementation plans. Each subagent runs in an isolated context, keeping the main conversation thread clean and allowing parallel work on different aspects of a task.

Lifecycle hooks let you run local commands at key points in the agent's decision-making: before it makes a risky tool call (like running `rm -rf`), to audit decisions, to trigger desktop notifications when the agent completes a task, or to connect to your own automation systems. This is useful for enforcing security policies or integrating Kimi Code CLI with your development workflow.

Model Context Protocol (MCP) servers extend Kimi Code CLI with new capabilities. Instead of hand-editing a JSON config file, you use `/mcp-config` conversationally to add, edit, and authenticate MCP servers. A rich plugin ecosystem lets you install skills, MCP servers, and data sources from the marketplace or any GitHub repo. When you install a plugin, the CLI surfaces the trust level (official, community, untrusted) up front.

IDE integration via Agent Client Protocol

Kimi Code CLI speaks the Agent Client Protocol (ACP), a standard that allows editors and IDEs to drive coding agents over standard input/output. ACP-compatible editors include Zed and JetBrains IDEs (IntelliJ, PyCharm, WebStorm).

Instead of launching Kimi Code CLI in a separate terminal, you can configure your IDE to drive a Kimi session directly from the editor. Log in once at the CLI level, then point your IDE at the `kimi acp` subcommand. For Zed, add this to ~/.config/zed/settings.json:

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

Then open a new conversation in Zed's Agent panel. The repository provides detailed setup instructions for JetBrains and documents the full capability matrix (which tools and features are available in ACP mode).

Active development and version release cycle

Recent releases include @moonshot-ai/[email protected] (2026-09-24), @moonshot-ai/[email protected] (2026-09-23), and @moonshot-ai/[email protected] (2026-09-19). The last push to the repository was on 2026-09-25, four days ago, indicating the project is actively maintained.

The repository includes comprehensive documentation covering getting started, interaction and approvals, sessions, IDE integration, configuration, and command reference. Development requires Node.js 24.15.0 or newer and pnpm 10.33.0 (a fast npm alternative). The build process uses Make: `pnpm build` compiles all packages, `pnpm dev:cli` runs the CLI in development mode, and `pnpm test` runs the test suite.

The project has 1471 open issues (as of the material's creation date), which likely reflects both active development and a large user base reporting edge cases. The license is MIT.

Configuration, environment, and LLM provider options

Kimi Code CLI is preconfigured to use Moonshot AI's Kimi models, which the documentation highlights for long-context reasoning. You can also configure it to use other LLM providers by editing configuration files (documented in the Configuration section of the README). This allows teams to use internal models, other cloud providers, or locally hosted inference servers.

The repository structure separates concerns into multiple packages. The core app lives in `apps/kimi-code`. Supporting packages handle TUI rendering, agent logic, and integration layers. Tests run via `pnpm test`, type checking via `pnpm typecheck`, and linting via oxlint (`pnpm lint`). The project uses Node.js modules throughout; TypeScript types are checked during the build phase. Configuration files live in `~/.config/kimi/` on Unix systems, allowing per-user settings alongside global overrides.

The documentation references a CONTRIBUTING guide, which explains how to extend the CLI with new tools or modify agent behavior. A SECURITY.md file documents how to report vulnerabilities. The README links to a full command reference for `kimi` and to platform-specific setup guides.

Command-line examples from the README show typical usage: `cd your-project && kimi` starts a session, `/login` authenticates, and then you give the agent tasks in natural language. For automation, you can pass a prompt via stdin or use the API if you integrate Kimi Code CLI into a larger system. The 1471 open issues suggest edge cases and feature requests that the team is actively triaging. The MIT license allows modification and redistribution.

Editorial conclusion

Kimi Code CLI is for developers who prefer command-line workflows and want an AI assistant integrated into their terminal. Use it if you work primarily in terminals, prefer dispatching work to subagents, need lifecycle hooks for custom automation, or want to drive sessions from IDE via the Agent Client Protocol. Skip it if you require a graphical interface, cannot use Moonshot AI's Kimi models or compatible providers, or if you expect offline operation. Verify first that your development environment can reach the Moonshot API, that you have API quota, and test whether video input works with your screen recording format if you plan to use that feature.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes