# Primary Applications Within the Kimi-Code Project: A Complete Guide > Explore the primary applications of the kimi-code project including CLI, browser UI, visual debugger, web inspector, and IDE extension. Learn how they leverage a shared TypeScript core. - Repository: [Moonshot AI/kimi-code](https://github.com/MoonshotAI/kimi-code) - Tags: how-to-guide - Published: 2026-07-29 --- **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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/apps/kimi-code/package.json). This application never depends directly on the low-level agent core; instead, it communicates through the high-level SDK. ```bash # 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`](https://github.com/MoonshotAI/kimi-code/blob/main/apps/kimi-web/package.json). ```bash # 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`](https://github.com/MoonshotAI/kimi-code/blob/main/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. ```bash # 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`](https://github.com/MoonshotAI/kimi-code/blob/main/apps/kimi-inspect/package.json). ```bash # 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`](https://github.com/MoonshotAI/kimi-code/blob/main/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. ```bash # 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. ```bash # 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`](https://github.com/MoonshotAI/kimi-code/blob/main/package.json) files located at `apps/{name}/package.json` (or [`apps/vis/server/package.json`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/apps/kimi-code/package.json), [`apps/vscode/package.json`](https://github.com/MoonshotAI/kimi-code/blob/main/apps/vscode/package.json), etc.) without building the entire repository.