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

> Explore Kimi Code features: a fast AI coding agent with a terminal UI, local web server, sub-agents, and plugins. Get this Node.js free tool for efficient coding.

- Repository: [Moonshot AI/kimi-code](https://github.com/MoonshotAI/kimi-code)
- Tags: deep-dive
- Published: 2026-08-15

---

**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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/AGENTS.md) at the repository root and in package-specific guides like [`packages/agent-core-v2/AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/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:

```bash

# 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`](https://github.com/MoonshotAI/kimi-code/blob/main/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:

```bash

# 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:

```bash

# 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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/agent-core-v2/src/app/scopes.ts).

## Editor Integration via ACP

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

```bash

# 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:

```bash

# 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`](https://github.com/MoonshotAI/kimi-code/blob/main/docs/en/reference/kimi-command.md) for the complete command reference.

## Session Export and Portability

Sessions are fully **exportable as ZIP archives**:

```bash

# 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`](https://github.com/MoonshotAI/kimi-code/blob/main/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.