# What is Kimi Code? A Deep Dive into the Terminal AI Coding Agent Architecture

> Discover Kimi Code, the advanced terminal AI coding agent. Read edit files execute commands search the filesystem and make autonomous decisions. Learn more about its architecture and SDK.

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

---

**Kimi Code is a next-generation AI coding agent that runs directly in your terminal, capable of reading and editing source files, executing shell commands, searching the filesystem, and making autonomous decisions through a language model interface.** Built as a TypeScript monorepo by MoonshotAI, it combines a terminal UI with a dependency-injection-driven agent engine and a public SDK for IDE integration.

## Core Architecture of Kimi Code

Kimi Code follows a layered architecture with clear separation between user interface, agent logic, and runtime services. Understanding these layers is essential for both users and developers extending the platform.

### The Five Architectural Layers

| Layer | Purpose | Key Source Path |
|-------|---------|---------------|
| **CLI / TUI** | Interactive terminal entry point that drives sessions, renders transcripts, and forwards input to the agent engine | [`apps/kimi-code/README.md`](https://github.com/MoonshotAI/kimi-code/blob/main/apps/kimi-code/README.md) |
| **Unified Agent Engine (v1)** | Original core providing sessions, scopes, services, and DI container | [`packages/agent-core/README.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/agent-core/README.md) |
| **Agent Engine v2** | Refactored DI × Scope architecture powering `kap-server` and the SDK with four lifecycle scopes and unit-based features | [`packages/agent-core-v2/AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/agent-core-v2/AGENTS.md) |
| **Public TypeScript SDK** | Contract-driven façade (`@moonshot-ai/kimi-code-sdk`) exposing the engine over RPC for external processes | [`packages/node-sdk/README.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/node-sdk/README.md) |
| **Runtime Support Packages** | Utilities for telemetry, OAuth, filesystem abstraction (`kosong`), `MiniDb` persistence, and pluggable skills | Various `packages/*` directories |

The **v2 engine** represents a significant architectural evolution, introducing four nested lifecycle scopes: **App → Workspace → Session → Agent**. Each scope inherits services from its parent while maintaining isolation appropriate to its level.

## How Kimi Code Executes: A Typical Workflow

When you launch Kimi Code, the following sequence occurs according to the source implementation in [`packages/agent-core-v2/AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/agent-core-v2/AGENTS.md):

1. **Start the CLI** (`kimi`) → the TUI creates a **Session**.
2. The **Session** runs inside the **Session scope**, inheriting services from **Workspace** and **App** scopes.
3. The **Agent Engine v2** resolves requested **sub-agents** (e.g., `coder`, `explore`, `plan`) as **Feature units**. Each sub-agent operates in its own **Agent scope**, isolated from the main conversation transcript.
4. The engine communicates with a **Model Context Protocol (MCP)** server to generate actions—shell commands, file edits, or API calls.
5. Results stream back to the TUI where you approve, reject, or modify them. Lifecycle hooks enable custom scripts at key points (e.g., pre-tool-call).

This **scope isolation** enables parallel sub-agents working on separate tasks without transcript contamination—a critical capability for complex multi-file operations.

## Key Design Principles

### Dependency Injection (DI) Driven Extensibility

The Kimi Code engine is fully **DI-driven**. Adding capabilities requires only registering a **contribution token**; the engine auto-wires it into the appropriate scope. This design powers:

- **Parallel sub-agents** with transcript isolation
- **Fine-grained persistence** via `MiniDb` for session indexing and queries
- **Extensible plugin ecosystem** installable from marketplace or GitHub repos

### Model Context Protocol (MCP) Integration

Kimi Code communicates with LLM providers through **MCP**, a standardized protocol for model context exchange. Configure MCP servers via the TUI:

```sh
/mcp-config add

```

Configuration persists in the **Workspace scope**, available to all sessions launched from that workspace. Source: [`apps/kimi-code/README.md`](https://github.com/MoonshotAI/kimi-code/blob/main/apps/kimi-code/README.md)

## Practical Usage Examples

### Launching the Terminal UI

```bash

# From any project directory

cd your-project
kimi                    # launches the interactive terminal UI

```

Source: [`apps/kimi-code/README.md`](https://github.com/MoonshotAI/kimi-code/blob/main/apps/kimi-code/README.md)

### Programmatic Control via Node.js SDK

The `@moonshot-ai/kimi-code-sdk` package exposes Kimi Code functionality over RPC for automation and IDE integration:

```typescript
import { createClient } from '@moonshot-ai/kimi-code-sdk';

const client = createClient({ url: 'http://localhost:8080' });

async function analyzeRepo() {
  const session = await client.session.create();
  const result = await session.ask('Explain the main directories of this repo.');
  console.log(result.message);
}

analyzeRepo().catch(console.error);

```

Source: [`packages/node-sdk/README.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/node-sdk/README.md)

### Creating Custom Skills

Register new capabilities as TypeScript plugins using the v2 API:

```typescript
// my-skill.ts
import { registerSkill } from '@moonshot-ai/agent-core-v2';

registerSkill('time', async () => {
  return `The current time is ${new Date().toLocaleTimeString()}`;
});

```

Install via the Kimi UI after publishing:

```bash
/kinstall my-skill

```

Source: [`packages/agent-core-v2/AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/agent-core-v2/AGENTS.md)

## Critical Source Files and Their Roles

| Path | Purpose |
|------|---------|
| [`apps/kimi-code/README.md`](https://github.com/MoonshotAI/kimi-code/blob/main/apps/kimi-code/README.md) | CLI/TUI entry point documentation |
| [`packages/agent-core/README.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/agent-core/README.md) | Original unified agent engine overview |
| [`packages/agent-core-v2/AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/agent-core-v2/AGENTS.md) | DI × Scope engine design: scopes, units, contribution points |
| [`packages/node-sdk/README.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/node-sdk/README.md) | Public TypeScript SDK usage |
| `packages/kap-server/` | REST/WebSocket server exposing engine at `/api/v1` |
| `packages/telemetry/` | Analytics and debugging telemetry |
| `packages/oauth/` | MoonshotAI service authentication |
| `packages/kosong/` | Provider-agnostic LLM abstraction layer |
| `packages/minidb/` | JSON document store for session indexing |

## Summary

- **Kimi Code** is a terminal-native AI coding agent from MoonshotAI with autonomous file editing, shell execution, and decision-making capabilities.
- **Architecture** follows a TypeScript monorepo structure with CLI/TUI, dual agent engine versions, public SDK, and runtime utility packages.
- **Agent Engine v2** introduces DI × Scope architecture with four lifecycle levels (App → Workspace → Session → Agent) enabling isolated parallel sub-agents.
- **Extensibility** is DI-driven: register contribution tokens to add skills, tools, or configuration without modifying core code.
- **Integration** occurs via MCP protocol configuration and the `@moonshot-ai/kimi-code-sdk` for programmatic control.

## Frequently Asked Questions

### What programming language is Kimi Code built with?

Kimi Code is implemented in **TypeScript** as a **monorepo** structure. All core components—including the CLI, agent engines, SDK, and supporting utilities—are TypeScript packages under `apps/` and `packages/` directories.

### Can Kimi Code integrate with my IDE instead of the terminal?

Yes. Kimi Code exposes its functionality through **`kap-server`** (REST/WebSocket at `/api/v1`) and the **`@moonshot-ai/kimi-code-sdk`** package. Any IDE or external process can drive Kimi Code sessions via these RPC interfaces, as documented in [`packages/node-sdk/README.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/node-sdk/README.md) and `packages/kap-server/`.

### How does Kimi Code handle multiple concurrent tasks?

Through **sub-agents** running in isolated **Agent scopes**. Each sub-agent (e.g., `coder`, `explore`, `plan`) operates within its own scope nested under the Session scope, preventing transcript contamination while enabling parallel execution. The DI × Scope architecture in Agent Engine v2 manages this isolation automatically.

### What is the difference between Agent Engine v1 and v2?

**v1** (`packages/agent-core/`) provides the original unified engine with sessions, scopes, and DI container. **v2** (`packages/agent-core-v2/`) refactors this into a more sophisticated DI × Scope architecture with four explicit lifecycle scopes, unit-based features, and direct support for the server (`kap-server`) and SDK implementations. New development should target v2 APIs.