Primary Applications Within the Kimi-Code Project: A Complete Guide

The kimi-code repository maintains five primary applications—kimi-code (CLI/TUI), kimi-web (browser UI), vis (visual debugger), kimi-inspect (web inspector), and vscode (IDE extension)—each housed under the apps/ directory and powered by a shared TypeScript core engine.

The MoonshotAI/kimi-code project is a TypeScript monorepo structured around a central engine in packages/ and multiple user-facing frontends in apps/. These applications provide distinct interaction surfaces for the Kimi Code platform, ranging from terminal-based interfaces to rich browser experiences and IDE integrations. All applications consume capabilities through the core SDK (@moonshot-ai/kimi-code-sdk) rather than binding directly to low-level agent internals.

Overview of the Application Architecture

The monorepo organizes code into two primary zones. The packages/ directory contains the core engine (packages/agent-core), utilities (packages/kosong), and server components (packages/kap-server). The apps/ directory contains standalone deployable units that import from these packages. This separation ensures consistent business logic while allowing each frontend to optimize for its specific runtime environment—whether Node.js for CLI tools or browser contexts for web UIs.

The Five Primary Applications in apps/

Each application operates as an independent workspace with its own package.json, build configuration, and entry points.

1. kimi-code – The Terminal Interface (CLI/TUI)

Located at apps/kimi-code/, this is the original command-line and text-based user interface. It drives interactive sessions via the terminal, providing a lightweight, keyboard-driven experience for users who prefer shell environments.

The entry point and dependency manifest live in apps/kimi-code/package.json. This application never depends directly on the low-level agent core; instead, it communicates through the high-level SDK.

# Launch the TUI from repository root

pnpm --filter @moonshot-ai/kimi-code run dev

2. kimi-web – Browser-Based Web UI

Housed in apps/kimi-web/, this application delivers a rich graphical interface built with Vue 3 and Vite. It mirrors the functionality of the terminal UI but adds visual enhancements and mouse interaction.

The web UI communicates with the backend over REST and WebSocket connections at /api/v1. Configuration and scripts reside in apps/kimi-web/package.json.

# Start the development server (typically http://localhost:5173)

pnpm --filter @moonshot-ai/kimi-web dev

3. vis – Visual Debugging Tools

The apps/vis/ directory contains a two-part application for debugging and replay analysis. The server component (apps/vis/server/package.json) records session transcripts and agent decisions, while the web component visualizes this data for developers.

This tool is essential for inspecting the inner workings of agent sessions, allowing developers to step through replays and analyze decision trees.

# Start the visual debugger backend

pnpm --filter @moonshot-ai/vis-server dev

# In another terminal, start the web visualization UI

pnpm --filter @moonshot-ai/vis-web dev

4. kimi-inspect – Web Inspector for Sessions

Found at apps/kimi-inspect/, this web inspector connects to the kap-server at /api/v1/debug to provide a browsing interface for active and historical sessions.

Users can explore chat history, inspect Service panels for both Session and Agent scopes, and debug runtime states through a dedicated web UI configured in apps/kimi-inspect/package.json.

# Launch the inspector (typically http://localhost:5174)

pnpm --filter @moonshot-ai/kimi-inspect dev

5. vscode – VS Code Extension

The apps/vscode/ directory houses the VS Code extension, which embeds the Kimi Code experience directly into the editor. It utilizes a Webview UI built with its own Vite configuration and TypeScript sources, defined in apps/vscode/package.json.

This integration allows developers to interact with Kimi Code without leaving their IDE, maintaining context between code editing and AI assistance.

# Build and run the extension in development mode

pnpm --filter @moonshot-ai/vscode dev

How to Run Each Application

Assuming Node.js >= 24.15 and pnpm 10.33 are installed, you can start any application using pnpm's workspace filter commands. This keeps builds isolated and fast by leveraging the monorepo's dependency graph.

# Terminal UI

pnpm --filter @moonshot-ai/kimi-code run dev

# Browser UI

pnpm --filter @moonshot-ai/kimi-web dev

# Visual Debugger (run both commands)

pnpm --filter @moonshot-ai/vis-server dev
pnpm --filter @moonshot-ai/vis-web dev

# Session Inspector

pnpm --filter @moonshot-ai/kimi-inspect dev

# VS Code Extension

pnpm --filter @moonshot-ai/vscode dev

Shared Core Dependencies

While each application maintains independent build pipelines, they all import from the shared packages. According to the source code structure, the primary dependencies include:

• packages/agent-core – The engine handling AI agent logic
• packages/kosong – Shared utilities and helpers
• packages/kap-server – Server-side infrastructure and API endpoints

This architecture ensures that improvements to the core engine propagate to all user interfaces simultaneously, while allowing frontend-specific optimizations in apps/.

Summary

• The kimi-code project ships five primary applications under apps/: kimi-code (CLI/TUI), kimi-web (browser UI), vis (debugger), kimi-inspect (session inspector), and vscode (IDE extension).
• Each application has its own entry point in package.json files located at apps/{name}/package.json (or apps/vis/server/package.json for the vis backend).
• All applications communicate with the shared core engine in packages/ rather than implementing agent logic directly.
• The monorepo uses pnpm workspaces with --filter commands to run specific applications in isolation.
• Requirements include Node.js >= 24.15 and pnpm 10.33 for development.

Frequently Asked Questions

What is the difference between kimi-code and kimi-web?

kimi-code (apps/kimi-code/) provides a terminal-based text UI for command-line interaction, while kimi-web (apps/kimi-web/) offers a browser-based graphical interface built with Vue 3. Both consume the same SDK functionality but target different user preferences—shell environments versus rich web clients.

How does the vis application help with debugging?

The vis application (apps/vis/) captures session transcripts via its server component and renders them through a web UI, allowing developers to replay agent sessions, inspect decision trees, and analyze the state transitions that occurred during execution. This is invaluable for troubleshooting complex agent behaviors.

Can I run these applications independently?

Yes. Each application in apps/ is self-contained with its own package.json and can be started independently using pnpm --filter @moonshot-ai/{app-name} dev. They communicate via HTTP/WebSocket APIs (typically at /api/v1), so the web UIs can run against a local or remote backend without requiring other frontend applications to be active.

What package manager does the kimi-code project use?

The project uses pnpm (version 10.33 or higher) as its package manager. This is evident in the workspace commands (pnpm --filter) and the monorepo structure, which relies on pnpm's filtering capabilities to target specific applications (apps/kimi-code/package.json, apps/vscode/package.json, etc.) without building the entire repository.

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