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

> Explore the main features of Kimi Code, a powerful AI coding assistant. Discover its full-stack agent engine, fast TUI, and extensible plugin ecosystem in this comprehensive guide.

- Repository: [Moonshot AI/kimi-code](https://github.com/MoonshotAI/kimi-code)
- Tags: getting-started
- Published: 2026-08-11

---

**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`.

```bash

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

```typescript
// 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.

```bash

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

```text
/agent coder    # Dedicated coding session

```

Each subagent operates in its own **session scope**, defined 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). 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:

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

```

The plugin manager records installations in [`plugins/installed.json`](https://github.com/MoonshotAI/kimi-code/blob/main/plugins/installed.json). Official plugins include:

- **Kimi WebBridge** ([`plugins/official/kimi-webbridge/kimi.plugin.json`](https://github.com/MoonshotAI/kimi-code/blob/main/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.

```text
/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:

```json
{
  "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`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/kap-server/src/server.ts). This WebSocket/REST interface is described in [`packages/protocol/src/asyncapi.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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:

```text
/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`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/kap-server/src/server.ts)) exposes headless sessions over WebSocket. The `klient` SDK ([`packages/klient/src/client.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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.