Kimi Code Desktop gives Moonshot’s coding agent a native workspace

Moonshot AI has released Kimi Code Desktop, a native macOS and Windows app built around the same agent engine as the Kimi Code CLI. The project-oriented interface combines code editing, terminal access, browser automation, visual diffs, Git status, and parallel agents in one workspace.

Moonshot bundles the app with existing Kimi memberships. It supports Apple Silicon and Intel Macs as well as Windows PCs. Kimi Code also remains available through the CLI, a VS Code extension, and API keys for third-party integrations. Moonshot documents Desktop updates in its release notes.

Agent work stays visible

The interface records tool calls, progress messages, and files changed during each turn. Developers can inspect diffs before accepting them, while operations involving greater access trigger approval prompts. Three permission modes determine how often the app asks for confirmation:

• Always Ask requires frequent approval before the agent acts.
• Ask When Needed prompts when an operation requires additional permission.
• Never Ask lets the agent proceed without approval prompts and grants it the broadest autonomy.

Plan first or pursue a goal

• Plan mode proposes an implementation approach before changing files, allowing the developer to review and refine the steps.
• Goal mode works toward longer-running objectives that can be paused, resumed, or canceled.
• Background tasks continue outside the active session while preserving controls for checking progress or stopping execution.

Experimental Tower mode runs several agents in parallel for work that can be divided into separate threads. It now requires explicit activation with /tower on or /tower base-branch. Requiring a command reduces the chance of launching parallel edits accidentally, especially when agents may touch related files.

The browser closes the feedback loop

The right-hand panel contains a browser that the agent can control directly. Desktop groups browsing activity into summaries with cited sources, highlights a tab while the agent operates it, displays download progress, supports the configured search engine, and provides a button for opening the current page in the system browser.

Browser control lets the agent consult documentation, run a local app, inspect the rendered result, and continue editing from the same session. Point-and-click annotations add visual instructions: developers can highlight text, select a page element, or drag across a region and attach a comment. That workflow is useful for interface fixes that are cumbersome to describe with file names and line numbers alone.

K3 brings a million-token window

Moonshot identifies Kimi K3 as the flagship model behind the service. The company lists 2.8 trillion parameters and support for as many as one million context tokens, targeting long-running programming tasks, visual front-end work, knowledge work, and complex reasoning. Context tokens are chunks of code and text the model can consider at once, so the larger limit can accommodate more files, documentation, and conversation history during a task.

Kimi can delegate cheaper subtasks to a secondary model. The secondary_model subagent setting is generally available, enabled by default in every launch mode, and configurable through either of these opt-out methods:

• Set the environment variable KIMI_CODE_EXPERIMENTAL_SECONDARY_MODEL=0.
• Add [experimental] secondary-model = false to the configuration.

One agent core, three interfaces

Desktop and the CLI use the same Kimi Code agent core and can coexist on one machine. They share local settings for accounts, models, providers, and plugins where supported. Existing CLI users can run /desktop or kimi install-desktop to open the Desktop download page in a browser.

What to test before switching

Kimi Code Desktop enters the same category as Claude Code and Cursor’s agent interface. Its distinguishing features include K3’s large context window, explicit approval controls, browser automation, visual annotations, and experimental multi-agent execution. The combination supports a full cycle of reading code, making changes, running commands, checking Git state, and verifying browser output without moving between separate tools.

A representative evaluation should measure how reliably K3 completes a real repository change, whether it uses the large context window effectively, how often approval prompts interrupt execution, and whether browser verification catches interface errors. Teams should also compare latency, membership limits, generated diff quality, and recovery from failed commands against their current agent.

Desktop is most relevant to developers handling long refactors, visual web work, or tasks that combine research with implementation. Terminal-heavy pipelines and headless automation remain a better fit for the CLI, while the shared core allows both clients to participate in the same broader Kimi Code workflow.