Moonshot AI's Kimi Code Ships a Swarm Command to Parallelize Coding Tasks

Kimi Code, Moonshot AI's open-source terminal coding agent, just shipped v0.12.0 with a headline feature that changes how the tool handles large, parallelizable tasks: a /swarm command that lets you spin up a coordinated fleet of sub-agents directly from your terminal session. It's a meaningful step up from single-agent workflows, and it's available right now.

The agent swarm concept, in plain terms

Most coding agents work sequentially: one agent reads a file, makes a change, runs a test, then moves on. That's fine for small tasks, but it becomes a bottleneck on anything with independent workstreams. Swarm mode breaks that pattern.

An agent swarm has an orchestrator that dynamically creates specialized sub-agents and decomposes complex tasks into parallelizable subtasks for efficient distributed execution. Think of it as the difference between one developer working through a list versus a team splitting the list across members simultaneously.

The coordinator analyzes your prompt and breaks it into independent subtasks, each with a clear scope, input context, and expected output format. For example: "Migrate all 60 Express route handlers from callbacks to async/await, add error boundaries, and update the tests" gets decomposed into groups of agents handling migrations, error boundaries, and test updates in parallel.

What /swarm actually does in v0.12.0

The new /swarm command surfaces this capability directly in the CLI's interactive terminal UI (TUI). Before this release, running multiple sub-agents required either manual orchestration or experimental flags. Now it's a first-class slash command with two important production-readiness additions:

• Live progress display: You can watch sub-agents work in real time from a single terminal view, with status breakdowns and elapsed time per agent group.
• Rate-limit-aware retries: The swarm handles API rate limits gracefully, backing off and retrying automatically instead of failing the whole task when one sub-agent hits a quota wall.

The sub-agent architecture itself is worth understanding. Each sub-agent works in its own isolated context window, so the main agent's conversation history stays clean and doesn't balloon with exploratory logs from parallel workers. The system supports approximately 300 to 1,200 requests per 5-hour window, with up to 30 concurrent requests.

Kimi Code ships three built-in sub-agent types out of the box:

• coder: General-purpose engineering sub-agent that can read, write, and execute commands.
• explore: Read-only codebase explorer for mapping a repo without touching files.
• plan: Architecture and planning agent with no shell access, focused purely on design decisions.

Three features graduate from experimental

Beyond /swarm, v0.12.0 also promotes three previously opt-in features to stable defaults, which is arguably just as significant for day-to-day use:

• Goals: Long-running objectives the agent tracks across multiple turns. You set a goal with /goal <objective>, and the agent keeps working toward it, resuming after interruptions.
• Background questions: The agent can ask clarifying questions asynchronously while continuing to work, rather than blocking the whole session waiting for your answer.
• Sub-skill discovery: The agent can now automatically find and load relevant skills from your skill library without you having to name them explicitly.

Previously, all three required setting environment variables like KIMI_CODE_EXPERIMENTAL_GOAL_COMMAND=1 before launch. They now work out of the box.

Proxy support closes a real gap

The other practical addition is full proxy support. v0.12.0 honors the standard HTTP_PROXY, HTTPS_PROXY, ALL_PROXY, and NO_PROXY environment variables, including SOCKS proxies, for all outbound traffic. This matters for anyone running Kimi Code inside a corporate network or a containerized CI environment where outbound traffic is routed through a proxy. Before this, the CLI would silently bypass those settings.

The bigger picture: a fast-moving CLI

Kimi Code is an intelligent programming service built on Kimi's latest flagship models, providing AI-assisted capabilities including code reading, file editing, and command execution through a CLI and VS Code extension. The agent reads and modifies code, runs shell commands, searches files, fetches web pages, and autonomously plans and adjusts its next steps based on feedback as it works.

What's notable about v0.12.0 is the release cadence around it. The changelog shows the project went from v0.12.0 to v0.14.1 in just three days, with each version shipping meaningful features: custom color themes, Claude Code and Codex instruction imports, an Interrupt hook event, and a YOLO choice for swarm tasks. This is a team shipping fast.

On the model side, the underlying K2.5 model was trained with Parallel-Agent Reinforcement Learning (PARL), a technique that teaches the model to self-direct an agent swarm of up to 100 sub-agents, executing parallel workflows across up to 1,500 coordinated steps, without predefined roles or hand-crafted workflows. PARL is the key innovation here: rather than hard-coding when to parallelize, the model learned parallelism as a behavior during training. Naive multi-agent systems often fail in two ways: serial collapse, where the system defaults to a slow single-threaded pattern even with many agents available, or fake parallelism, where agents are spawned but the work isn't actually parallel and doesn't reduce latency. PARL is designed to avoid both failure modes.

Getting started

Two installation options are available: the official install script (recommended, no pre-installed Node.js required) and a global npm install. Once installed, run /login to authenticate via OAuth, then /init to let the agent index your repo.

# Install via npm
npm install -g @moonshot-ai/kimi-code
# Or use the official install script
curl -fsSL https://kimi.com/install.sh | sh
# Inside the CLI
/login          # OAuth login
/init           # Index your repo
/swarm          # Launch a swarm task

Kimi Code is a premium membership benefit within the Kimi membership plan, specifically designed for code development scenarios. Subscribe to unlock complete AI programming capabilities, including API access, high-performance computing resources, and comprehensive IDE integration support. The entry tier starts at $19/month and gives you access to K2.6 inside the Kimi interface with agent credits and Kimi Code access included. The underlying K2.6 model is also available directly via API at $0.60 input / $2.50 output per million tokens.

The /swarm command is most useful when your task has clear independent workstreams: large refactors across many files, parallel test generation, or multi-module migrations. Swarm tasks consume tokens fast, so watch your quota. For simple, focused tasks, the single-agent path is still more economical. The project is open source under Apache 2.0, and the team is actively taking issues, plugin ideas, and PRs.