Kimi Code Features Explained: A Complete Guide to Using the AI Coding Agent

Kimi Code is a single-binary AI coding agent that combines a blazing-fast terminal UI with a local web server, sub-agents for parallel tasks, and a rich plugin ecosystem—all without requiring Node.js installation.

Kimi Code is the flagship tool from MoonshotAI that brings autonomous coding assistance directly into your terminal. Whether you prefer interactive TUI sessions, scripted automation, or browser-based workflows, its TypeScript monorepo architecture supports multiple interfaces through a unified core engine. This article breaks down every major feature based on the actual source code implementation.

Core Architecture: How Kimi Code Is Built

Kimi Code follows a monorepo structure defined in pnpm-workspace.yaml at the repository root. The codebase splits functionality across logical packages:

• apps/kimi-code – CLI entry point and TUI powered by pi‑tui, plus the web subcommand for server mode
• packages/agent-core and packages/agent-core-v2 – the agent engine with lifecycle management
• packages/minidb – embedded JSON document store with WAL persistence
• packages/transcript – immutable transcript model for reproducible sessions
• packages/node-sdk and packages/klient – programmatic SDKs for external integration

The architectural blueprint is documented in AGENTS.md at the repository root and in package-specific guides like packages/agent-core-v2/AGENTS.md.

Single-Binary Distribution: Installation and Startup

The most distinctive Kimi Code feature is its single-binary distribution model. Unlike typical Node.js tools, Kimi Code bundles all dependencies into one executable:

# Install with one command—no Node.js or npm required

curl -fsSL https://raw.githubusercontent.com/MoonshotAI/kimi-code/main/install.sh | bash

This design eliminates version conflicts and dependency management entirely. The binary starts instantly, with the TUI rendering in milliseconds thanks to the optimized pi‑tui pipeline. According to the source code in apps/kimi-code/src/main.ts, the CLI parses flags and boots the interface without any warm-up phase.

Terminal TUI and Interactive Sessions

The primary interface is an interactive terminal UI that supports rich keyboard-driven workflows:

# Start a fresh session in the current directory

kimi

# Resume the most recent session without confirmation

kimi --continue

# Run in Plan mode—read-only exploration before any file changes

kimi --plan

Key TUI behaviors include:

• --yolo – auto-approve all regular tool calls, bypassing confirmation prompts
• --agent-file ./custom.md – load a custom agent definition from markdown
• Session persistence – automatic transcript recording for replay and export

Local Web Server and Browser UI

Kimi Code doubles as a local web server through the web subcommand:

# Start the server and open the bundled web UI automatically

kimi web

The server mode exposes REST and WebSocket APIs that mirror the CLI's session capabilities. This implementation in apps/kimi-code serves the pre-built web UI and enables remote or browser-based interaction without sacrificing the core agent logic. The same transcript model and agent core power both interfaces.

Video Input for Multimodal Coding

One standout Kimi Code feature is video input support. You can drop a screen recording or demo clip directly into a session, and the agent processes visual content to generate or modify code. This multimodal capability is listed in the "Key Features" section of README.md and represents a departure from text-only coding assistants.

AI-Native MCP Configuration

Kimi Code treats Model Context Protocol (MCP) servers as first-class citizens. Instead of hand-editing JSON configuration files, you interact with MCP through natural language:

/mcp-config

This command enters a dedicated configuration mode where you can add, remove, and inspect MCP servers conversationally. The feature eliminates the friction of managing external tool integrations and is implemented as a core CLI workflow in apps/kimi-code.

Plugin Ecosystem and Skills

The plugin system in Kimi Code centers on Skills—modular capabilities discovered from multiple sources:

• User-level skill directory – ~/.kimi/skills/
• Project-level skill directory – ./.kimi/skills/
• Additional paths via --skills-dir
• GitHub repositories and marketplace

Skills are implemented as simple markdown files with frontmatter metadata, making them accessible to edit and version control. The trust level for each skill is displayed upfront before installation. For implementation details, see docs/en/customization/skills.md and the discovery logic in packages/agent-core-v2/src/features/.

Sub-Agents for Parallel Task Execution

Kimi Code ships with built-in sub-agents that run isolated tasks while keeping the main conversation focused:

Agent	Purpose
coder	Implements specific code changes
explore	Investigates codebase structure
plan	Designs solutions before execution

These sub-agents operate in separate contexts, preventing the main session from accumulating implementation details. The architecture is documented in docs/en/customization/agents.md with configuration examples.

Lifecycle Hooks for Customization

Lifecycle hooks let you inject local commands at precise execution points:

• Before tool calls
• After file writes
• On session start/end

This enables audit logging, notification triggers, or custom validation without modifying core source code. Hooks are configured through the standard skill system and executed by the agent core in packages/agent-core-v2/src/app/scopes.ts.

Editor Integration via ACP

For IDE-native workflows, Kimi Code supports the Agent Communication Protocol (ACP):

# Attach Kimi Code to an ACP-compatible editor session

kimi acp

This command allows Zed, JetBrains, and other ACP clients to drive a Kimi Code session programmatically. The integration is implemented as a separate command path in apps/kimi-code with bidirectional message handling.

Provider and Model Management

The kimi provider subcommand offers full control over LLM backends:

# List configured providers

kimi provider list

# Add a new provider with custom endpoint

kimi provider add custom-openai --api-base https://api.example.com

# Switch active model for current session

kimi provider use-model gpt-4o

This CLI-driven approach avoids manual configuration file editing and supports scripting for team environments. See docs/en/reference/kimi-command.md for the complete command reference.

Session Export and Portability

Sessions are fully exportable as ZIP archives:

# Export the latest session without confirmation

kimi export -y

# Export a specific session by ID

kimi export --id <session-id> ./backups/

The export includes the complete immutable transcript from packages/transcript, enabling debugging, sharing, or archival. The import process reconstructs the session state exactly as recorded.

Storage and Data Layer

Two packages provide Kimi Code's persistence foundation:

MiniDB (packages/minidb/src/mini-db.ts) implements an embedded JSON document store with:

• Snapshot + WAL persistence for crash recovery
• Full-text search indexing for the server-side query interface
• Zero external dependencies

Transcript (packages/transcript/src/contract/*.ts) defines the immutable event log that serves as the single source of truth for all session interactions. This design enables deterministic replay, visual timeline rendering, and conflict-free merging.

Summary

• Kimi Code features center on a single-binary, zero-dependency distribution with sub-millisecond TUI startup
• Dual interfaces—terminal and web server—share identical agent core and transcript models
• Video input, AI-native MCP configuration, and sub-agents extend beyond typical coding assistant capabilities
• Skills-based plugin ecosystem uses markdown for accessibility and version control
• Lifecycle hooks, ACP editor integration, and provider management enable deep customization
• Immutable transcript model and MiniDB storage ensure reproducibility and portability

Frequently Asked Questions

What makes Kimi Code different from other AI coding assistants?

Kimi Code distinguishes itself through its single-binary distribution requiring no Node.js installation, native video input support, and built-in sub-agents for parallel task isolation. The immutable transcript model in packages/transcript also enables exact session replay and export, features not commonly found in comparable tools.

How does Kimi Code handle plugin security?

The skill system in Kimi Code displays trust levels upfront before installation. Skills are sandboxed markdown files rather than arbitrary code, and additional skill directories must be explicitly added via --skills-dir. For MCP servers, the AI-native /mcp-config interface provides guided setup with clear visibility into what each server can access.

Can I use Kimi Code without the terminal interface?

Yes. Running kimi web starts a local HTTP/WebSocket server that serves the bundled web UI and exposes the full session API. This server mode uses the same packages/agent-core-v2 engine and packages/minidb storage as the CLI, ensuring feature parity between interfaces.

What is the difference between agent-core and agent-core-v2?

packages/agent-core (v1) provides the original agent implementation with session and service layers. packages/agent-core-v2 introduces four lifecycle scopes (App, Workspace, Session, Agent) and a feature-centric architecture in src/features/. New development targets v2, though both packages coexist in the monorepo for migration compatibility.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}