TL;DR

Kimi Code CLI is MoonshotAI’s terminal AI coding agent — the same team behind the Kimi K2 model family. It reads and edits code, runs shell commands, searches files, fetches web pages, and plans its own next steps, all from your terminal. It ships as an MIT-licensed single binary (no Node.js required), speaks the Agent Client Protocol (ACP) so editors like Zed and JetBrains can drive it, supports MCP servers, and can dispatch isolated subagents for parallel work.

It’s the successor to kimi-cli (10K+ stars), which is being wound down in its favor. The default model is Kimi K2.7 Code, which Moonshot claims cuts reasoning-token usage ~30% versus K2.6 while posting strong agentic-coding numbers.

Key facts:

  • MIT-licensed, open source, actively developed by MoonshotAI
  • Single-binary install — one curl | bash (macOS/Linux) or PowerShell one-liner (Windows), no npm/PATH gymnastics
  • Model-agnostic — defaults to Kimi K2.7 Code, but can point at Anthropic, OpenAI, or Google via config
  • ACP + MCP + subagents + lifecycle hooks + video input — a genuinely modern feature set
  • Successor to kimi-cli (10K+ ⭐); installing Kimi Code auto-migrates your old config and sessions

This review covers what it is, how to install it, what the K2.7 Code model actually scores, honest limitations, and how it stacks up against Claude Code and Codex.

What Kimi Code CLI actually is

If you’ve used Claude Code or OpenAI’s Codex CLI, the shape is familiar: a persistent terminal agent that lives inside your project directory. You describe a task in plain language, and instead of copy-pasting code between a chat window and your editor, the agent does the loop for you — reads the relevant files, edits them, runs commands, reads the output, and decides what to do next.

Kimi Code CLI’s distinguishing bet is terminal-first ergonomics plus openness. It’s a single compiled binary with a purpose-built TUI that starts in milliseconds, it’s MIT-licensed, and it’s model-agnostic. Moonshot obviously wants you on Kimi K2.7 Code (their own model), but nothing stops you from wiring it to Claude or GPT.

The lineage matters. The original kimi-cli was a Python package on PyPI that grew past 10,000 stars. Moonshot has now folded that effort into Kimi Code CLI, a rewrite distributed as a single binary. Per the old repo’s own README: “Kimi CLI is evolving into Kimi Code CLI… installing Kimi Code CLI automatically migrates your configuration and sessions. This project will be gradually wound down.” So if you’re evaluating it today, go straight to kimi-code.

Installation and first run

There’s no Node.js requirement — a nice change from the npm-global-install dance most CLI agents demand.

macOS or Linux:

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

Windows (PowerShell):

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

On Windows you’ll want Git for Windows installed first, because Kimi Code uses the bundled Git Bash as its shell environment. If Git Bash lives somewhere non-standard, set KIMI_SHELL_PATH to the absolute path of bash.exe.

Verify the install in a fresh shell:

kimi --version

Then open a project and start the interactive UI:

cd your-project
kimi

On first launch, run /login inside the TUI and pick either Kimi Code OAuth or a Moonshot AI Open Platform API key. After that, your first task is as simple as typing:

Take a look at this project and explain its main directories.

The agent will explore the tree, read key files, and report back — a good low-risk way to sanity-check that tool calls and file access work before you let it edit anything.

The feature set that stands out

Kimi Code CLI ships with a surprisingly complete set of modern agent features:

  • Single-binary distribution. One command installs it; no Node setup, no global-module conflicts.
  • Blazing-fast TUI. Startup is in the millisecond range, so short sessions don’t feel heavy.
  • Video input. You can drop a screen recording or demo clip into the chat and have the agent watch it — turning a reference video into working code, or a screen capture into a bug repro, without describing every frame in words.
  • AI-native MCP configuration. Instead of hand-editing JSON, you add and authenticate Model Context Protocol servers conversationally with /mcp-config.
  • Subagents. Built-in coder, explore, and plan subagents run in isolated contexts, so you can farm out focused work in parallel while keeping the main conversation clean.
  • Lifecycle hooks. Run local commands at key decision points — gate risky tool calls, audit decisions, fire desktop notifications, or hook into your own automation.
  • Plugin marketplace. Install skills, MCP servers, and data sources from a marketplace or any GitHub repo, with each install’s trust level surfaced up front.
  • Editor/IDE integration via ACP. Drive a session straight from Zed, JetBrains, or any Agent Client Protocol client.

MCP setup, the sane way

If you’ve fought with JSON MCP configs elsewhere, Kimi’s sub-command group is refreshingly direct:

# Add a streamable HTTP server:
kimi mcp add --transport http context7 https://mcp.context7.com/mcp \
  --header "CONTEXT7_API_KEY: ctx7sk-your-key"

# Add an HTTP server with OAuth:
kimi mcp add --transport http --auth oauth linear https://mcp.linear.app/mcp

# Add a stdio server:
kimi mcp add --transport stdio chrome-devtools -- npx chrome-devtools-mcp@latest

# List / remove / authorize:
kimi mcp list
kimi mcp remove chrome-devtools
kimi mcp auth linear

It also accepts an ad-hoc config file in the standard mcpServers format via kimi --mcp-config-file /path/to/mcp.json, so you can share MCP setups across tools.

Using it inside your editor (ACP)

Kimi Code speaks the Agent Client Protocol, which means an ACP-capable editor can drive a session over stdio. Log in once in the terminal, then point your editor at kimi acp. For Zed, add this to ~/.config/zed/settings.json:

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

Open a new conversation in Zed’s Agent panel and you’re talking to Kimi Code without leaving the editor. JetBrains works the same way via its bring-your-own-agent support.

The K2.7 Code model: benchmarks and caveats

The CLI is only half the story — most of the value comes from Kimi K2.7 Code, Moonshot’s agentic coding model and the CLI’s default.

Moonshot’s headline numbers compare K2.7-Code against its predecessor K2.6 on its own benchmark suite: +21.8% on Kimi Code Bench v2, +11.0% on Program Bench, +31.5% on MLS Bench Lite, and roughly 30% fewer reasoning tokens for the same class of task. That last figure is the interesting one — fewer reasoning tokens means lower cost and latency per task if the accuracy holds.

On tool-use and agent workflows, reported third-party figures put K2.7 at 81.1% on MCPMark Verified, ahead of Claude Opus 4.8’s reported 76.4% on the same benchmark. MCPMark measures tool usage and external-integration workflows rather than raw code generation, so it’s a fair proxy for how a coding agent (not just a model) behaves.

The honest caveat: as of late June 2026, K2.7 Code had not been submitted to independent suites like SWE-bench Verified, SWE-bench Pro, or Terminal-Bench. Most of the eye-catching numbers are vendor-published or comparisons where the competing model was run in a different harness (e.g., GPT-5.5 in Codex, Opus 4.8 in Claude Code). Treat them as directional, not as head-to-head gospel. The base Kimi K2 model scores around 53.7 on LiveCodeBench v6, which is competitive but not a runaway leader.

What about pricing?

Kimi K2.7 Code is served through Moonshot’s Open Platform. Third-party trackers report the standard variant around $1.90 input / $8.00 output per 1M tokens with a low cache-hit rate (~$0.38). Moonshot’s flagship Kimi K3 lists at roughly $3 input / $15 output per 1M with open weights released July 27, 2026.

Pricing note: these figures move fast and vary by model variant and region. Always confirm against Moonshot’s official pricing page before budgeting a workload — don’t take any published third-party number (including this one) as final.

The practical read: K2.7 Code is meaningfully cheaper than frontier models like Claude Opus for output-heavy agent loops, which is a big part of its appeal for people running long autonomous sessions.

Community reactions

Kimi Code CLI has been climbing GitHub Trending, and the wider Kimi K2.7 launch generated a wave of “free/cheap Claude Code alternative” write-ups across dev blogs, Medium, and dev.to. The recurring themes in community coverage:

  • “Finally, no Node.js.” The single-binary install is genuinely appreciated by people burned by npm-global breakage.
  • Breadth over depth. In Moonshot’s own case study refactoring the Kimi web app, the team found K2.7 and the CLI “most useful in parts of the project where breadth mattered more than complexity” — many small, consistent changes across a system, rather than gnarly algorithmic problems.
  • Skepticism on benchmarks. Experienced engineers keep flagging that the standout scores are vendor-run and that independent SWE-bench-style verification is still missing.
  • Cost is the hook. For hobbyists and heavy users, the pitch that lands hardest is “Claude-Code-style workflow at a fraction of the token cost.”

Honest limitations

No tool is a free lunch. Where Kimi Code CLI is rough or unproven:

  • Independent benchmarks are missing. Until K2.7 Code shows up on SWE-bench Verified or Terminal-Bench under a neutral harness, the accuracy claims are Moonshot’s to prove.
  • Ecosystem maturity. Claude Code and Codex have larger communities, more third-party skills, and more battle-tested edge-case handling. Kimi Code is newer, and the transition from kimi-cli means some docs and integrations are still catching up.
  • Built-in shell commands. The old kimi-cli noted that shell built-ins like cd weren’t supported in its shell mode; carry that expectation into the new binary until you’ve tested your workflow.
  • Data-residency considerations. Using the default Kimi models routes your prompts (and any code context) to Moonshot’s platform. For sensitive codebases, either point the CLI at a provider you already trust or run against a self-hosted/compatible endpoint — and read the privacy terms first.
  • Windows friction. The Git Bash dependency and KIMI_SHELL_PATH fiddling add setup steps that macOS/Linux users skip.

How it compares

Kimi Code CLIClaude CodeCodex CLI
LicenseMIT (open)ProprietaryOpen (CLI)
Default modelKimi K2.7 CodeClaude (Opus/Sonnet)GPT-5.x
InstallSingle binary, no Nodenpmnpm
ACP supportYesVia adaptersVia adapters
MCPYes, conversational configYesYes
Subagentscoder/explore/planYesLimited
Cost leverCheapest output tokensPremiumPremium
Ecosystem maturityNewerLargestLarge

The short version: Kimi Code CLI is the best current option if you want an open, cheap, terminal-first agent and you’re comfortable being an early adopter. If you need the deepest ecosystem and the most independently verified model quality, Claude Code and Codex still lead — but they cost more per token, and neither is MIT-licensed.

FAQ

Is Kimi Code CLI free and open source? The CLI itself is MIT-licensed and free to install. You still pay for model usage — either through a Kimi Code OAuth plan or a Moonshot API key (or by pointing it at another provider you already pay for). So the tool is free; the intelligence behind it is metered.

Do I need to use Kimi’s models with it? No. It defaults to Kimi K2.7 Code but is model-agnostic — you can configure it to use Anthropic, OpenAI, or Google-compatible endpoints by editing its config. That flexibility is one of its stronger selling points.

What’s the difference between kimi-cli and Kimi Code CLI? kimi-cli was the original Python/PyPI project (10K+ stars). Kimi Code CLI is the single-binary successor. Moonshot is winding down the old one, and installing the new CLI auto-migrates your configuration and sessions.

How does Kimi K2.7 Code compare to Claude Opus 4.8? On Moonshot’s and third-party MCPMark numbers, K2.7 reportedly edges out Opus 4.8 on tool-use benchmarks (~81% vs ~76%). But those aren’t neutral head-to-head runs, and K2.7 hasn’t been submitted to independent suites like SWE-bench Verified. In practice, Opus still has a maturity and verified-quality edge; Kimi’s advantage is cost and openness.

Can I use it inside VS Code, Zed, or JetBrains? Yes. There’s a dedicated VS Code extension, and via the Agent Client Protocol you can drive Kimi Code from Zed, JetBrains, or any ACP-compatible editor using kimi acp.

Is my code sent to Moonshot? If you use the default Kimi models, yes — prompts and code context go to Moonshot’s platform. For sensitive work, point the CLI at a provider you trust or a compatible self-hosted endpoint, and review the privacy terms before use.

Bottom line

Kimi Code CLI is one of the most complete open terminal agents to land in 2026: MIT-licensed, single-binary, ACP- and MCP-native, with subagents, hooks, video input, and a genuinely cheap default model. The catch is that its headline model numbers are still vendor-run and the ecosystem is younger than Claude Code’s or Codex’s.

If you want a low-cost, hackable, terminal-first coding agent and you don’t mind living slightly ahead of the independent-benchmark curve, it’s well worth an afternoon. Start with a read-only “explain this project” task, wire up an MCP server or two, and see how the K2.7 loop feels on your actual codebase before committing a subscription to it.

Sources