Landa CLI

Issues · 中文

Landa is a feature-rich fork of Kimi Code CLI — an AI coding agent that runs in your terminal with a distinct personality and deep local-first enhancements.

What is Landa

Landa is an AI coding agent that runs in your terminal — it can read and edit code, run shell commands, search files, fetch web pages, and choose the next step based on the feedback it receives. It works out of the box with Moonshot AI's Kimi models and can also be configured to use other compatible providers.

What makes Landa different: A focused, no-nonsense personality (lazy senior developer — efficient, not careless), deep MCP integration with a code intelligence engine (Lander), local GGUF model support, and a streamlined TUI designed for long agent sessions.

Key Features

Upstream Features

• Single-binary distribution. Install with one command: no Node.js setup, PATH gymnastics, or global module conflicts.
• Blazing-fast startup. The TUI is ready in milliseconds, so starting a session never feels heavy.
• Purpose-built TUI. A carefully tuned interface, optimized end to end for long, focused agent sessions.
• Video input. Drop a screen recording or demo clip into the chat and let the agent watch what is hard to describe in words.
• AI-native MCP configuration. Add, edit, and authenticate Model Context Protocol servers conversationally with /mcp-config, without hand-editing JSON.
• Rich plugin ecosystem. Install skills, MCP servers, and data sources from the marketplace or any GitHub repo, with each install's trust level surfaced up front.
• Subagents for focused, parallel work. Dispatch built-in coder, explore, and plan subagents in isolated contexts while keeping the main conversation clean.
• Lifecycle hooks. Run local commands at key points to gate risky tool calls, audit decisions, trigger desktop notifications, or connect to your own automation.
• Editor & IDE integration (ACP). Drive a session straight from Zed, JetBrains, or any Agent Client Protocol client with kimi acp.

Local Enhancements

• Landa personality system. The agent persona is a lazy senior developer who follows the YAGNI principle, the "ladder" approach (stdlib before dependencies, one line before fifty), and writes minimal, correct code. Every interaction channels efficiency without cutting corners on safety.
• MCP-first code exploration. A custom system prompt enforces structured MCP (Lander) usage over raw shell commands — search_graph, trace_path, get_architecture, and query_graph replace grep, glob, and ls for code understanding. Includes a full rejection mapping document (Spanish/English) for converting Bash/Glob/Grep reflexes into MCP calls.
• Lander MCP integration. Auto-connected code intelligence engine with full knowledge graph indexing — resolutions, call graphs, import chains, complexity metrics, and architecture clusters — all queryable in under 1ms.
• Local GGUF model provider. Run local LLMs through llama.cpp with /enable_local and /disable_local slash commands. Auto-detects llama-server.exe and .gguf model files, configures provider, model alias, context size, and thinking mode automatically.
• MCP output visibility toggle (Ctrl+M / Alt+M). Hide or show MCP tool output independently of verbose mode — spinner-only by default, full JSON on demand. TOON encoding for compact MCP JSON results.
• Streamlined TUI mode. Per-tool spinners removed, read/agent groups suppressed by default, rounded tree borders (╰─ instead of └─), full thinking content without truncation, auto-approve for Bash & Edit tools, minimal approval noise.
• Sky memory system (experimental). Model-managed contextual memory using structured <sky> blocks — project state, indexed nodes, session summaries, and hot files. Can be toggled via the sky-mode experimental flag.
• Enhanced default system prompt. Language-matching rules, MCP exploration discipline, compaction forward-plan capture, structured tool-use integrity, and image compression announcements.

Install

Install with the official script. No Node.js required.

• macOS or Linux:

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

• Homebrew (macOS/Linux):

brew install kimi-code

• Windows (PowerShell):

irm https://code.kimi.com/kimi-code/install.ps1 | iex

On Windows, install Git for Windows before first launch because Landa uses the bundled Git Bash as its shell environment. If Git Bash is installed in a custom location, set KIMI_SHELL_PATH to the absolute path of bash.exe.

Then, run it with a new shell session:

kimi --version

For npm install, upgrade, uninstall, see Getting Started.

Quick Start

Open a project and start the interactive UI:

cd your-project
kimi

On first launch, run /login inside Landa and choose either Kimi Code OAuth or a Moonshot AI Open Platform API key. After login, try your first task:

Take a look at this project and explain its main directories.

Local Model Quick Start

# Place llama-server.exe in apps/kimi-code/llama/ and a .gguf model in apps/kimi-code/local-model/
# Then inside Landa:
/enable_local
# Or specify a custom model path:
/enable_local /path/to/your-model.gguf

# Disable when done:
/disable_local

MCP Visibility

Toggle MCP tool output visibility (independent of verbose mode):

• Ctrl+M (or Alt+M) — toggle MCP output on/off
• /mcp — show MCP server status

What We've Built (Local Changelog)

Area	Changes
Agent Persona	Replaced system prompt with "Landa" — a lazy senior dev. YAGNI ladder, MCP-first exploration, structured sky memory format.
MCP / Lander	Auto-connected Lander code intelligence. TOON encoding for compact JSON. MCP visibility toggle (Ctrl+M). MCP parallelism enabled. 50K truncation bypass for MCP tools.
Local Models	/enable_local and /disable_local commands. Auto-detection of llama-server binary and GGUF files. Full provider config generation.
TUI	Minimal mode: no per-tool spinners, suppressed read/agent groups, rounded tree borders, full thinking display, auto-approve Bash/Edit. Alt+M binding.
Sky Memory	Experimental <sky> memory blocks for model-managed context. Sky reminder injection. Structured fields (project, nodes, edges, session).
System Prompt	Language-matching enforcement, MCP discipline guide, compaction forward plans, tool-use integrity hardening, image compression announcements.
Rejection System	Documented mapping (Spanish/English) converting exploratory Bash/Glob/Grep reflexes into proper MCP queries.
Config & Flags	sky-mode experimental flag, mcpVisible state, auto-approve tool list expanded.

Use it in your editor (ACP)

Landa speaks the Agent Client Protocol, so ACP-compatible editors and IDEs (Zed, JetBrains, …) can drive a session over stdio. Log in once, then point your editor at the kimi acp subcommand — no extra login needed.

For Zed, add this to ~/.config/zed/settings.json:

{
  "agent_servers": {
    "Kimi Code CLI": {
      "type": "custom",
      "command": "kimi",
      "args": ["acp"],
      "env": {}
    }
  }
}

Then open a new conversation in Zed's Agent panel. See Using in IDEs for JetBrains setup and troubleshooting.

Docs

• Getting Started
• Interaction and approvals
• Sessions
• Using in IDEs (ACP)
• Configuration
• Command reference

Develop

Requirements: Node.js ≥ 24.15.0, pnpm 10.33.0.

git clone https://github.com/MoonshotAI/kimi-code.git
cd kimi-code
pnpm install

pnpm dev:cli    # run the CLI in dev mode
pnpm test       # run tests
pnpm typecheck  # TypeScript check
pnpm lint       # oxlint
pnpm build      # build all packages

See CONTRIBUTING.md for the full contribution guide.

Community

• Issues
• For security vulnerabilities, see SECURITY.md.

Acknowledgements

Our TUI is built on top of pi-tui. We thank the authors of pi-tui for their valuable work.

License

Released under the MIT License.