# Future Roadmap for Kimi-Code: v2 Engine, Multi-Language SDKs, and Production Deployment

> Explore the Kimi-Code roadmap: v2 engine enhancements, unified web/CLI experience, Python/Go SDKs, and enterprise deployment with Docker and Helm charts.

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

---

**The Kimi-Code roadmap centers on hardening the Agent-Core v2 engine with dependency injection and feature flags, unifying the web and CLI experiences in a single monorepo, expanding SDK support to Python and Go, and introducing enterprise deployment options including Docker images and Helm charts.**

The Moonshot AI `kimi-code` repository is a modular TypeScript monorepo architected around a thin client interface and robust agent engine. According to the project's [`AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/AGENTS.md) and [`CONTRIBUTING.md`](https://github.com/MoonshotAI/kimi-code/blob/main/CONTRIBUTING.md) documentation, the future roadmap for Kimi-Code emphasizes scalability, developer experience, and cross-environment consistency through nine distinct strategic initiatives.

## Agent-Core v2 Engine Maturation

The transition from v1 to v2 represents the foundational architectural shift in the Kimi-Code roadmap. The new **Agent-Core v2** ([`packages/agent-core-v2/AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/agent-core-v2/AGENTS.md)) introduces dependency injection-based lifecycle scopes, a robust flag system, and a flexible service layer designed for complex multi-agent orchestration.

The maintainers plan to harden the v2 engine by stabilizing the feature-flag infrastructure, implementing scoped persistence layers, and ultimately deprecating the legacy v1 engine in favor of a stable public API. This migration is critical as the [`CONTRIBUTING.md`](https://github.com/MoonshotAI/kimi-code/blob/main/CONTRIBUTING.md) explicitly states that only pull requests aligned with the roadmap will be merged.

## Full-Stack UI Unification

Currently, the web UI resides in a separate repository and ships as a pre-built bundle in `apps/kimi-code/dist-web` (as noted in the root [`AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/AGENTS.md)). The roadmap prioritizes integrating the web UI directly into the monorepo to enable hot-reloading during development.

This unification aims to expose a single "Kimi Code" experience across CLI, TUI, and browser environments, eliminating the friction between the web-based and terminal-based interfaces.

## Enhanced SDKs and Language Bindings

The public Node SDK currently lives in `packages/node-sdk` with a client façade in `packages/klient` ([`packages/node-sdk/AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/node-sdk/AGENTS.md)). The roadmap includes expanding beyond TypeScript to generate first-class bindings for Python and Go, streamlining versioning through automated changesets, and improving TypeScript typings for the existing SDK.

This multi-language support will allow developers to integrate Kimi-Code's agent capabilities directly into diverse backend systems and data science workflows.

## MiniDB Storage Architecture Improvements

MiniDB underpins the search index in `packages/minidb` and currently includes a "Caveats / roadmap" section in its README ([`packages/minidb/README.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/minidb/README.md)). Planned enhancements include introducing a pluggable storage backend supporting SQLite or Postgres, implementing incremental indexing for large codebases, and exposing a query API for external tool integration.

These changes will transform MiniDB from a local-only solution into a scalable data layer suitable for enterprise deployments.

## Centralized Feature-Flag Framework

Experimental flags are currently declared per-package, such as the `search_worker` flag in [`packages/agent-core/AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/agent-core/AGENTS.md). The roadmap calls for consolidating these definitions into a central registry with UI toggles and adopting a "stable-by-default" policy for new flags.

This framework is implemented in [`packages/agent-core/src/flags/registry.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/agent-core/src/flags/registry.ts), where flags can be enabled at runtime:

```typescript
import { flags } from '@moonshot-ai/agent-core';

// Enable the experimental search worker
flags.enable('search_worker');

```

## CLI and TUI Ergonomics

The CLI application in `apps/kimi-code` ([`apps/kimi-code/README.md`](https://github.com/MoonshotAI/kimi-code/blob/main/apps/kimi-code/README.md)) currently drives the engine via the SDK. Future improvements include a richer command-set for session management, multi-agent orchestration capabilities, enhanced TUI rendering performance, and a scripting-friendly REPL interface.

These enhancements target power users who require programmatic control over coding sessions while maintaining the accessibility of the terminal interface.

## Observability and Telemetry Integration

The telemetry package ([`packages/telemetry/README.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/telemetry/README.md)) will expand to export structured logs, integrate OpenTelemetry tracing for distributed session monitoring, and provide a dashboard for session analytics. This addresses the current visibility gaps in agent decision-making and performance profiling.

## Testing and CI Infrastructure

The repository currently runs a full test matrix via Vitest and GitHub Actions ([`.github/workflows/ci.yml`](https://github.com/MoonshotAI/kimi-code/blob/main/.github/workflows/ci.yml)). The roadmap includes adding end-to-end tests for the full stack, implementing flaky-test detection algorithms, and enforcing workspace-sync checks for the `flake.nix` configuration.

## Production Packaging and Deployment

The server-side runtime ([`packages/kap-server/AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/kap-server/AGENTS.md)) currently builds with custom tooling. The deployment roadmap focuses on producing official Docker images, Helm charts for Kubernetes orchestration, and a SaaS-ready deployment pipeline supporting zero-downtime upgrades.

## Current Capabilities and Implementation Examples

While these roadmap items evolve, the current codebase supports immediate usage through the CLI and Node SDK.

Install the single-binary distribution:

```bash
curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash
kimi --version

```

Create sessions using the public Node SDK:

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

const client = new KimiClient({ apiKey: process.env.KIMI_API_KEY });
const session = await client.createSession();

// The engine auto-selects sub-agents (coder/explore/plan) based on the request
const reply = await session.runPrompt('Write a TypeScript debounce utility.');
console.log(reply);

```

Run the development server with hot-reloading:

```bash
pnpm dev:server

```

## Summary

- **Agent-Core v2** will replace the v1 engine with dependency injection and scoped services, stabilizing the public API.
- The **web UI** will merge into the monorepo to create a unified CLI/TUI/browser experience with hot-reloading.
- **SDK expansion** will add Python and Go bindings alongside improved TypeScript typings.
- **MiniDB** will gain pluggable backends (SQLite/Postgres) and incremental indexing capabilities.
- A **centralized feature-flag registry** will replace per-package flags with UI-accessible toggles.
- **Production readiness** includes Docker images, Helm charts, OpenTelemetry tracing, and comprehensive E2E testing.

## Frequently Asked Questions

### When will Agent-Core v2 become the default engine?

According to [`packages/agent-core-v2/AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/agent-core-v2/AGENTS.md), the v2 engine is currently in active development with core features like DI-based lifecycle scopes and the flag system already implemented. The maintainers will deprecate v1 once v2 reaches stability with hardened persistence layers and a documented public API, though no specific date is committed in the source documentation.

### Will the Kimi-Code web UI remain open source?

The roadmap indicates the web UI will be integrated directly into the monorepo from its current separate repository location. As stated in the root [`AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/AGENTS.md), this unification enables hot-reloading during development and suggests the web interface will remain part of the open-source distribution, though specific licensing details are not outlined in the technical roadmap files.

### How can I contribute to the MiniDB storage improvements?

The [`packages/minidb/README.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/minidb/README.md) explicitly lists storage backends and incremental indexing in its roadmap section. Contributors should align pull requests with the architecture described in [`CONTRIBUTING.md`](https://github.com/MoonshotAI/kimi-code/blob/main/CONTRIBUTING.md), which requires that submissions match the stated roadmap themes. Discussion of specific implementation details for pluggable backends should reference the "Caveats / roadmap" section in the MiniDB documentation.

### What languages will the Kimi-Code SDK support besides TypeScript?

The roadmap in [`packages/node-sdk/AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/node-sdk/AGENTS.md) specifies plans for generating bindings for Python and Go, alongside maintaining first-class TypeScript typings. This expansion aims to support backend integration and data science workflows beyond the current Node.js ecosystem.