Kimi Code Main Features: A Complete Guide to the AI Coding Assistant

Kimi Code is a single-binary, terminal-based AI coding assistant that combines a full-stack agent engine, fast TUI, and extensible plugin ecosystem into one self-contained tool.

Kimi Code brings autonomous coding capabilities directly to your terminal. According to the MoonshotAI/kimi-code source code, it delivers sub-second startup times, parallel subagents, video input support, and editor integration through the Agent Client Protocol (ACP).

Single-Binary Distribution and Fast Startup

Kimi Code ships as a single executable with no Node.js prerequisite. The install script downloads the appropriate platform binary and places it on your PATH.

# One-command installation

curl -fsSL https://install.kimi.ai | bash

The TUI renders in milliseconds after invocation. This speed comes from bundling the TypeScript runtime and agent engine into a native binary via the apps/kimi-code package.

In apps/kimi-code/src/main.ts, the entry point parses CLI arguments, initializes the session loop, and hands off to the TUI renderer without external dependencies:

// Entry point structure (from source analysis)
// apps/kimi-code/src/main.ts
// - Parses slash-commands
// - Creates top-level session
// - Boots interactive terminal UI

Purpose-Built Terminal UI for Long Sessions

The TUI is optimized for extended agent interactions. Unlike generic chat interfaces, it handles streaming tool outputs, approval prompts, and multi-turn reasoning without visual clutter.

Key TUI capabilities include:

• Slash commands for quick actions (/login, /config, /agent, /plugins)
• Drag-and-drop video upload for visual reasoning tasks
• Real-time tool execution feedback with approval checkpoints
• Session persistence across reconnections

Video Input and Visual Reasoning

Kimi Code accepts video clips as input. Drop a screen recording into the TUI, and the agent processes frames to generate code, transformations, or analysis.

# Inside the TUI

/upload /path/to/demo.mp4

This enables workflows like: record a UI interaction, have the agent replicate it in code, or extract color values from a design mockup. The video pipeline is handled within packages/agent-core alongside other multimodal inputs.

Subagents for Parallel Work

The engine supports specialized subagents that run in isolated scopes:

Subagent	Purpose
coder	Focused code generation and refactoring
explore	Codebase navigation and analysis
plan	Architecture design and task decomposition

Spawn a subagent without cluttering your main conversation:

/agent coder    # Dedicated coding session

Each subagent operates in its own session scope, defined in packages/agent-core-v2/src/app/scopes.ts. The v2 engine implements four DI scopes—App, Workspace, Session, and Agent—that let the server (kap-server) manage concurrent isolated contexts.

Plugin Ecosystem and Skill Installation

Kimi Code extends functionality through skills, MCP servers, and data sources. Install from the marketplace or any GitHub repository:

/plugins install https://github.com/MoonshotAI/kimi-code/tree/main/plugins/official/kimi-webbridge

The plugin manager records installations in plugins/installed.json. Official plugins include:

• Kimi WebBridge (plugins/official/kimi-webbridge/kimi.plugin.json): Real browser automation for web testing and scraping
• Kimi Datasource: Structured data API integrations

Lifecycle hooks let you run custom commands on events like tool approvals or session notifications.

AI-Native MCP Configuration

Manage Model Context Protocol servers conversationally via the /mcp-config command. Instead of hand-editing JSON files, describe your needs and Kimi Code generates the configuration.

/mcp-config    # Interactive MCP server setup

This reduces friction when connecting to external tools like databases, API gateways, or custom MCP implementations.

Editor and IDE Integration via ACP

Any Agent Client Protocol-compatible editor can drive Kimi Code sessions. The ACP bridge exposes the same backend used by the terminal UI.

Configure Zed, JetBrains, or other supported editors:

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

The kimi acp command starts the protocol adapter, routing editor requests through packages/kap-server/src/server.ts. This WebSocket/REST interface is described in packages/protocol/src/asyncapi.ts, ensuring uniform communication across all clients.

Core Architecture: Monorepo Structure

Kimi Code's TypeScript monorepo organizes components into distinct packages:

Package	Function
apps/kimi-code	CLI bootstrap, slash-command parsing, TUI rendering
packages/agent-core	Original unified engine (agents, sessions, skills, tools)
packages/agent-core-v2	DI-scoped server engine with layered lifetime management
packages/kap-server	REST + WebSocket API, debug RPC surface
packages/klient	Client SDK for IPC, memory, or remote connections
packages/protocol	Shared WebSocket control frames, error codes, event streaming
packages/tree-sitter-bash	Pure-TS Bash parser for shell script understanding

The packages/klient/src/client.ts SDK abstracts communication details, letting editors and automation tools interact with kap-server without managing low-level protocols.

Session Lifecycle and Configuration

Control Kimi Code behavior without leaving the TUI:

/config        # Edit tui.toml interactively

/login         # OAuth or API key authentication

Credentials store under ~/.kimi/ and persist across sessions. The configuration editor exposes settings for auto-updates, external editor command, and notification preferences.

Summary

• Single-binary deployment eliminates Node.js dependencies and enables sub-second startup
• Video input support lets agents reason over screen recordings and visual content
• Isolated subagents (coder, explore, plan) handle parallel tasks without conversation pollution
• Extensible plugin system supports skills, MCP servers, and data sources from any source
• ACP integration connects terminal and editor experiences through unified WebSocket/REST APIs
• Scoped DI architecture in agent-core-v2 separates App, Workspace, Session, and Agent lifetimes

Frequently Asked Questions

How does Kimi Code differ from other AI coding assistants?

Kimi Code operates as a self-contained binary rather than a cloud service or IDE extension. It runs locally with optional server mode, supports video input, and exposes the same backend to both terminal users and ACP-compatible editors. The plugin architecture also decouples skill development from core releases.

What is the Agent Client Protocol (ACP)?

ACP is the WebSocket/REST protocol that kap-server exposes for external clients. Defined in packages/protocol, it standardizes session control, tool streaming, and error handling. Any editor implementing ACP can launch kimi acp and drive sessions without custom integration code.

Can Kimi Code run without the terminal UI?

Yes. The kap-server package (packages/kap-server/src/server.ts) exposes headless sessions over WebSocket. The klient SDK (packages/klient/src/client.ts) lets scripts and applications connect via IPC, shared memory, or remote endpoints. The TUI is one client among many possible interfaces.

How do subagents maintain isolation?

The v2 engine in packages/agent-core-v2/src/app/scopes.ts implements dependency injection scoping. Each subagent receives its own Agent scope nested within a Session scope, preventing state leakage while sharing Workspace and App-level resources like file system watchers and plugin registries.

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