Kimi Code CLI: A Free, Open-Source Terminal Coding Agent From Moonshot AI - AI article on gikiewicz.com
AI

Kimi Code CLI: A Free, Open-Source Terminal Coding Agent From Moonshot AI

By Grzegorz Gikiewicz · · 9 min read
#Moonshot AI#Kimi Code CLI#Open Source#Claude Code#Developer Tools

Moonshot AI shipped Kimi Code CLI, an MIT-licensed coding agent that runs in the terminal and is openly positioned as a free, open-source alternative to Anthropic’s Claude Code and Google’s Gemini CLI. The tool reads and edits code, runs shell commands, searches files, and decides its next step from the feedback it receives.

TL;DR: Kimi Code CLI is Moonshot AI’s open-source (MIT) terminal coding agent. It installs as a single binary with no Node.js setup required, accepts screen recordings as context, exposes conversational MCP configuration, ships built-in coder/explore/plan subagents, and integrates with Zed and JetBrains via the Agent Client Protocol. The tool itself is free; heavy use runs against a free-tier-limited Moonshot account, with Kimi K3 API usage reported at roughly $3/$15 per 1M tokens.

What Kimi Code CLI Actually Is

Kimi Code CLI is a terminal-based AI coding agent published by Moonshot AI - the Beijing lab behind the Kimi K2 and Kimi K3 models. The repository lives at github.com/MoonshotAI/kimi-code under the MIT license. Out of the box it talks to Moonshot’s own Kimi models, and the README notes it “can also be configured to use other compatible providers,” so you are not locked in to a single vendor.

The project’s tagline calls it “The Starting Point for Next-Gen Agents,” and the design choices back that up: rather than ship a thin wrapper over a model, Moonshot built a purpose-fit TUI with plugin, subagent, and hook primitives.

Installation: Genuinely No Node.js Required

A recurring claim in viral posts about Kimi Code CLI is “no Node.js setup required.” For once this checks out against the source. The README lists three install paths, none of which need a JavaScript runtime on the host:

# macOS or Linux
curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash

# Homebrew (macOS/Linux)
brew install kimi-code

# Windows (PowerShell)
irm https://code.kimi.com/kimi-code/install.ps1 | iex

After install, you run kimi --version in a fresh shell. Node.js >= 24.15.0 is only listed as a development requirement (for pnpm install from source), not as a runtime dependency - a real differentiator from Node-based CLIs that pull in global module conflicts.

First launch prompts /login, where you authenticate either via Kimi Code OAuth or a Moonshot AI Open Platform API key.

Key Features (Verified Against the README)

  • Single-binary distribution. One install command, no PATH gymnastics, no global npm modules to clash with.
  • Blazing-fast startup. The TUI is ready in milliseconds, not the multi-second spin-up typical of Electron-backed agents.
  • Video input. Drop a screen recording or demo clip into the chat. The agent watches what is hard to describe in words - a reference clip into a LUT, a long video into a short, a screen recording into working code.
  • AI-native MCP configuration. Add, edit, and authenticate Model Context Protocol servers conversationally via /mcp-config, without hand-editing JSON. This is genuinely novel - most MCP clients still demand manual config-file editing.
  • Rich plugin ecosystem. Install skills, MCP servers, and data sources from the marketplace or any GitHub repo, with each install’s trust level surfaced up front.
  • Subagents for focused, parallel work. Built-in coder, explore, and plan subagents run in isolated contexts while keeping the main conversation clean - the same “plan changes before editing a single file” workflow the viral post promised, and one Claude Code users will recognize.
  • Lifecycle hooks. Run local commands at key points to gate risky tool calls, audit decisions, trigger desktop notifications, or plug into your own automation.
  • Editor and IDE integration (ACP). Drive a Kimi Code CLI session from Zed, JetBrains, or any Agent Client Protocol client via kimi acp. Log in once; the editor session inherits your auth.

For Zed, the documented setup is a small JSON block in ~/.config/zed/settings.json:

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

The “Free” Question - Read the Fine Print

The viral framing - “completely free to use” - deserves a footnote. Two things are true at once:

  1. The CLI is free and MIT-licensed. You can read, audit, modify, and redistribute the source. That is unambiguous and rare among frontier-grade coding agents.
  2. Usage runs against a Moonshot AI account. Kimi K3 - the model the CLI defaults to - has a free tier subject to standard rate limits, and a paid API. Third-party reporting (kie.ai, citing launch-day confirmations) puts K3 API pricing at roughly $3 per 1M input tokens and $15 per 1M output tokens, with Moonshot not publishing a hard message cap for the free tier as of launch.

So “free” is honest at the tool level and slightly asterisked at the usage level, exactly like Claude Code is “free to install” but metered through an Anthropic subscription. The kimi.com/code landing page exposes a Pricing tab for specifics.

Timing: Not a “Just Released” Story

Several viral posts frame Kimi Code CLI as brand-new. The repo and the MarkTechPost launch coverage both date the initial release to June 2026, with two rapid updates (v0.25.0 and v0.26.0) shipping on July 16, 2026 - the same day as Kimi K3. Those updates added expanded subagent capabilities and tighter K3 integration. The current buzz is real, but the “just released” hook conflates the K3 launch and CLI maturity milestone with a brand-new product.

Why It Matters

Three things make Kimi Code CLI genuinely interesting rather than another “we wrapped a model in a TUI” launch:

  • Distribution. Single-binary, no-Node install lowers the barrier to try it to roughly one curl command - lower than any comparable frontier agent.
  • Subagents and hooks. The coder/explore/plan split plus lifecycle hooks put it in the same architectural class as Claude Code, not the class of thin chat wrappers.
  • Open weight + open tool. Moonshot is the same lab that open-weighted a 2.8-trillion-parameter model. A frontier-grade agent from that lab, under MIT, is a meaningful shift in what “open-source coding agent” can mean.

For developers already fluent in Claude Code, Kimi Code CLI is the closest structural peer that doesn’t require an Anthropic subscription - with the caveat that serious production use will eventually route through Moonshot’s paid API.

Frequently Asked Questions

Is Kimi Code CLI really free?

The CLI itself is MIT-licensed and free. Usage runs against a Moonshot AI account: there is a free tier with rate limits, and the Kimi K3 API is reported at roughly $3/$15 per 1M input/output tokens. The tool is free in the same sense Claude Code is free to install - the model behind it is metered.

Do I need Node.js installed?

No. The official install script, Homebrew formula, and PowerShell installer all produce a single binary with no Node.js runtime dependency. Node >= 24.15.0 is only required if you clone the repo to develop on the CLI itself.

How is it different from Claude Code?

Structurally, they are peers: both are terminal-native agents with subagents, planning, and hook primitives. The differences are licensing (MIT vs. proprietary), distribution (single binary vs. npm), default model (Kimi K3 vs. Claude), and vendor lock-in (Kimi Code CLI can be pointed at other compatible providers).

Does it work with my IDE?

Yes, via the Agent Client Protocol. Zed and JetBrains are documented; any ACP-compatible client can drive a session through kimi acp. Authentication is shared with the CLI, so you log in once.

Where is the source?

github.com/MoonshotAI/kimi-code, MIT-licensed, with documentation at moonshotai.github.io/kimi-code.