Kimi Code CLI: A Terminal Agent with a Purpose-Built TUI and ACP Support

What Kimi Code CLI Solves and Who It Targets

Kimi Code CLI is an AI coding agent that runs inside your terminal. It can read and edit code, run shell commands, search files, fetch web pages, and decide the next action based on the feedback it receives. The target user is a developer who wants an agent that lives where they already work, without leaving the terminal for a separate editor or web interface. The README positions it as "The Starting Point for Next-Gen Agents," which is a broad claim, but the concrete value is in the packaging: a single binary that installs with one command, no Node.js required. That matters for teams who have struggled with npm-based agent tools that pollute the global environment or require specific runtime versions. It works out of the box with Moonshot AI's Kimi models, and the configuration can be extended to other compatible providers. This makes it a viable option for developers who are already using Kimi, and a candidate for those who want a provider-agnostic terminal agent, provided their provider speaks the same API dialect.

How the Agent Works: Tools, Subagents, and Lifecycle Hooks

The agent's mechanism is visible in the feature list: it reads and edits code, runs shell commands, searches files, and fetches web pages. The core loop is that the model chooses the next step based on feedback from those actions. The README does not detail the internal architecture, but the repository layout and features suggest a modular design. Subagents are a key mechanism: built-in `coder`, `explore`, and `plan` subagents run in isolated contexts, keeping the main conversation clean while allowing parallel work. That isolation is a real design choice, because it prevents the main context from being polluted by exploratory commands or focused coding tasks. Lifecycle hooks let you run local commands at key points, which can gate risky tool calls, audit decisions, or trigger desktop notifications. This is a practical way to add a safety layer without modifying the agent's core. The TUI is built on top of `pi-tui`, an acknowledged third-party library, which suggests the team optimized the interface for long, focused sessions rather than building from scratch. The README claims "blazing-fast startup" with the TUI ready in milliseconds, but no benchmark is provided, so treat that as a marketing statement until you run it yourself.

Installation and First Run: Single Binary, No Node.js

Installation is straightforward. On macOS or Linux, run the official script: `curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash`. On Windows PowerShell, use `irm https://code.kimi.com/kimi-code/install.ps1 | iex`. No Node.js is required, which is a significant advantage over many agent tools that depend on a specific runtime. On Windows, you must install Git for Windows first, because the CLI uses bundled Git Bash as its shell environment. If Git Bash is in a custom location, set the `KIMI_SHELL_PATH` environment variable to the absolute path of `bash.exe`. After installation, verify with `kimi --version`. To start, navigate to a project and run `kimi`. On first launch, use the `/login` command inside the CLI and choose either Kimi Code OAuth or a Moonshot AI Open Platform API key. After login, you can issue a task like "Take a look at this project and explain its main directories." The README does not show how to configure alternative providers, but it states that this is possible, so you will need to consult the configuration docs for the exact keys.

Video Input: A Differentiator with Unclear Boundaries

One feature that stands out is video input. You can drop a screen recording or demo clip into the chat, and the agent watches it. The README gives examples: turning a reference clip into a LUT, condensing a long video, or turning a screen recording into working code. This is not a common feature among terminal AI agents, which typically handle text and images only. The mechanism is not described, so it is unclear whether the video is processed frame-by-frame, summarized by a vision model, or handled by a separate pipeline. That lack of detail is a limitation: you cannot predict how well it handles long videos, complex motion, or audio. The feature could be a genuine advantage for developers who need to work from demo videos, but it also carries a risk of being a gimmick if the underlying model does not interpret video well. The documentation does not mention supported video formats, file size limits, or performance implications, so verify those details before relying on it for real work.

MCP Configuration and Plugin Ecosystem: Conversational Setup

Kimi Code CLI handles Model Context Protocol (MCP) configuration conversationally. The `/mcp-config` command lets you add, edit, and authenticate MCP servers without hand-editing JSON. That is a usability win, because MCP configuration often involves fiddly JSON files and token management. The plugin ecosystem is broad: you can install skills, MCP servers, and data sources from a marketplace or any GitHub repo, with each install's trust level surfaced up front. Surfacing trust level is a sensible security measure, given that plugins can execute code. The README does not explain how trust levels are determined or whether they are enforced, so you should review the documentation before installing third-party plugins. The combination of conversational MCP setup and a plugin marketplace makes the tool approachable for users who are not comfortable editing config files, but it also introduces a dependency on the marketplace's availability and the quality of third-party plugins.

Editor Integration via ACP: A Concrete Path for Zed and JetBrains

Kimi Code CLI speaks the Agent Client Protocol (ACP), which allows ACP-compatible editors to drive a session over stdio. This is a concrete integration path: log in once, then point your editor at the `kimi acp` subcommand. For Zed, the README provides a JSON snippet to add to `~/.config/zed/settings.json`, setting up an agent server with `command: "kimi"` and `args: ["acp"]`. JetBrains setup is referenced in the docs but not detailed in the README. This is a meaningful advantage over agents that only work in their own TUI, because it lets you stay in your editor for certain workflows while still using the CLI for others. The ACP protocol is an open standard, so any editor that supports it can potentially use Kimi Code CLI. The README mentions a "full capability matrix" in the `kimi acp` reference, but does not list the capabilities, so you will need to check that page to see which features are available in editor mode versus the TUI. That distinction matters because some features, like video input, may not translate well to an editor context.

Development and Maintenance: Node.js Required for Contributors

If you want to contribute, the requirements are Node.js >= 24.15.0 and pnpm 10.33.0. The development workflow is standard: clone the repo, run `pnpm install`, then use `pnpm dev:cli` to run the CLI in dev mode, `pnpm test` for tests, `pnpm typecheck` for TypeScript checking, `pnpm lint` for oxlint, and `pnpm build` to build all packages. The project is written in TypeScript and licensed under MIT, which is permissive for commercial use. The release cadence is active: versions 0.38.0, 0.39.0, and 0.39.1 were pushed within a week of each other in late August 2026. That frequency suggests rapid iteration, but it also means you should expect breaking changes between minor versions, especially in a pre-1.0 project. The maintenance cost for an adopter is low if you use the single-binary install, because updates are likely handled by the same script, but the README does not describe an update mechanism. For contributors, the Node.js requirement is a barrier if you are used to the no-runtime install, but that is normal for a TypeScript project.

Limitations and the Wrong Tool Cases

The most obvious limitation is provider compatibility. The README says it can be configured to use other compatible providers, but it does not specify which providers or what "compatible" means. Given that Kimi models are Anthropic-compatible (as implied by the API key option), it is likely that any provider supporting the Anthropic API format will work, but that is an inference, not a fact from the README. If you rely on a provider that uses a different API shape, such as OpenAI's or Google's native formats, you may need a translation layer, which adds complexity. Another limitation is the Windows experience: you must install Git for Windows, and if it is in a custom location, you must set `KIMI_SHELL_PATH`. That is an extra step that could trip up less experienced users. The video input feature is undocumented in terms of format and limits, so it is not safe to assume it will handle your specific use case. Finally, the project is pre-1.0, so the CLI interface and configuration may change without warning. For teams that need a stable, long-term tool, this could be a reason to wait or to pin a specific version.

Alternatives and How They Differ

The most direct alternative is Claude Code, Anthropic's terminal agent. Claude Code is also a terminal-based AI coding agent that reads and edits code, runs commands, and supports subagents. The key difference is that Claude Code is tightly coupled to Anthropic's Claude models, while Kimi Code CLI is designed to work with Moonshot AI's Kimi models and can be configured for other providers. If you are already a Claude user, Claude Code is the natural choice because of its integration with Anthropic's ecosystem. If you prefer Kimi or want a provider-agnostic tool, Kimi Code CLI is a better fit. Another alternative is Aider, which is a Python-based terminal agent that works with multiple models, but it does not have a purpose-built TUI in the same way, and it does not support video input or ACP integration out of the box. Aider is more focused on pair programming with git integration, while Kimi Code CLI is a broader agent with a plugin ecosystem. The choice comes down to which model provider you trust and which features you value: video input and ACP support are unique to Kimi Code CLI among these options.

Editorial conclusion

Adopt Kimi Code CLI if you want a terminal-first AI agent that works immediately with Moonshot AI's Kimi models, or if you prefer a single-binary install over a Node.js-based toolchain. Skip it if your workflow depends on a provider that is not compatible with the Anthropic API format, or if you need a GUI-based agent. Before committing, verify that your preferred provider is supported by checking the configuration docs, and test the video input feature on a sample clip to confirm it meets your needs. The project is under active development with frequent releases, so be prepared for changes in behavior and configuration.

Official sources

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