Kimi Code Agent Swarm: Run Multiple Kimi Agents in Parallel

The short answer: yes, you can run a Kimi Code swarm

A Kimi Code session is just a process. You install the CLI once (the official script is curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash, or npm install -g @moonshot-ai/kimi-code if you already have Node 22.19 or later), log in once with /login, and from then on every kimi you start is an independent agent with its own conversation, its own context, and its own working directory. Two sessions know nothing about each other.

So a Kimi Code agent swarm is not a special mode you unlock. It is simply more than one Kimi Code agent running at the same time. Open a second terminal, run kimi again, and you have two independent agents. One can be migrating a database layer while the other writes integration tests. Add a third and a fourth and you have a small swarm, every one of them running Kimi K3 with its huge context window.

Each session also leaves a real trace on disk. Kimi Code stores every session as plain files under ~/.kimi-code/sessions/, organized per project, with the transcript and the session title. That matters for a swarm because you can name sessions with /title, resume the last one in a directory with kimi --continue, and tell your agents apart later. The Kimi Code conversation history guide covers that side in detail.

The real work is managing the swarm once it grows. Kimi Code agents pause for approval before risky actions unless you loosen permissions, they finish at different times, and sometimes they touch the same files. The three methods below handle that coordination with very different amounts of friction.

One subscription, many agents: how the quota behaves

This is the most important Kimi-specific fact before you scale up. Every Kimi Code agent you run signs in with the same account, and they all draw from one shared quota pool. That quota refreshes on a weekly cycle, and there is a rolling 5 hour window on top, so a burst of heavy parallel work can hit the short window even when plenty of weekly quota remains.

In practice the 5 hour window is the ceiling a swarm actually feels. Four agents chewing through a big repository at the same time consume in one hour what a single agent would spread across the afternoon. Nothing breaks, you just reach the window sooner and wait for it to roll. If you want the full detail on plans, multipliers and what each tier includes, see the Kimi Code plans and pricing guide.

• All agents share one pool: there is no per-terminal quota, so a swarm spends faster than a single agent
• Weekly refresh: the pool resets on a 7 day cycle from your subscription date
• Rolling 5 hour window: short bursts are limited separately, which is what parallel work tends to hit first
• Check usage anytime with the /usage command inside any session

Method 1: Multiple terminal windows (free, basic)

The most obvious way to build a Kimi Code swarm is to open several terminal tabs, move into your project in each one, and start kimi. Nothing to install beyond Kimi Code itself.

# Terminal tab 1
cd ~/my-project
kimi

# Terminal tab 2
cd ~/my-project
kimi

# Terminal tab 3
cd ~/my-project
kimi

Each tab is now an independent Kimi Code agent. You can hand each one a different task and switch between them as they work. When an agent stops to ask for approval before running a command or writing a file, that tab just sits there waiting, which means you are bouncing between tabs to keep the swarm moving.

Pros

• Free, nothing to set up beyond Kimi Code
• Works instantly with tools you already have
• Easy to reason about, one tab is one agent

Cons

• You lose track of which tab is running which task almost immediately
• No notification when a Kimi Code agent finishes or stops for a permission prompt
• No shared view, you have to click into each tab to check progress
• No way to search across the conversation history of different agents
• If two agents edit the same file, untangling it is on you
• No view of how much shared quota the swarm has consumed until you ask each session

For two agents this is fine. Beyond that, the time you spend hunting for the tab that needs input starts to cancel out the speed you gained by going parallel in the first place.

Method 2: tmux or screen (free, advanced)

If you live in the terminal, tmux lets you split one window into panes and keep sessions alive in the background. You can watch several Kimi Code agents at once without flipping between tabs.

# Start a new tmux session
tmux new-session -s kimi-swarm

# Split horizontally
tmux split-window -h

# Split the right pane vertically
tmux split-window -v

# Now you have 3 panes - run kimi in each one

tmux also lets you detach and reattach, so your Kimi Code agents keep running after you close the terminal window. One honest caveat for unattended runs: Kimi Code is a young, fast-moving CLI, and there are open upstream reports of sessions stalling silently when a request hangs. A stalled pane in a detached tmux session looks exactly like a working one, so check in on long runs rather than assuming silence means progress.

Pros

• Free and available on almost any Unix machine
• See several panes at once, no tab switching
• Sessions survive disconnects, good for long runs
• Scriptable and configurable down to the keybinding

Cons

• Real learning curve if you have never used tmux
• Still no desktop notification when an agent finishes or asks for a permission
• No conversation history or cross-agent search
• Text-only panes get cramped past three or four agents
• A silently stalled agent looks identical to a busy one
• You rebuild the layout by hand every session unless you script it
• Conflicts between agents touching the same file are still your problem

tmux is a great general-purpose multiplexer and plenty of developers already use it. But it was never built for supervising AI agents. The moment a Kimi Code agent in pane 3 quietly stops for a permission prompt while you are reading pane 1, you feel the gap.

Method 3: CodeAgentSwarm (visual, full-featured)

CodeAgentSwarm is a desktop app built for exactly this: running and supervising a swarm of AI CLI agents in one place. It runs on macOS and Windows, gives you multiple terminals in a single workspace, and lets you choose the agent per terminal. Kimi Code is a first-class agent alongside Claude Code, Codex CLI, Antigravity CLI and opencode, so for a Kimi swarm you just pick Kimi Code in the agent picker in each terminal you want running kimi.

Here is what that gives you when the agents are all Kimi Code (or a mix):

Multiple Kimi Code agents in parallel

Set every terminal to Kimi Code for a pure Kimi swarm, or mix in Claude Code and Codex CLI where they fit better. Each terminal is a fully independent kimi process with its own conversation and project context. CodeAgentSwarm runs on top of your existing Kimi subscription, so it is not a model provider, it just orchestrates the agents you already pay for.

Quota visibility for the whole swarm

Because every Kimi agent drains the same pool, CodeAgentSwarm shows a usage indicator that reads your real Kimi quota, both the weekly cycle and the rolling 5 hour window. You see how much the swarm has consumed at a glance instead of typing /usage into each session and adding it up in your head.

Real-time visibility with dynamic titles

Every terminal updates its own title to reflect what its agent is doing right now. Instead of several tabs all labelled "kimi", you read titles like "Migrating User Schema", "Writing API Tests", "Refactoring Auth". You can tell which agent is on which task without clicking into any of them.

Desktop notifications

This is the single biggest fix for a swarm. When a Kimi Code agent finishes its task or stops to ask for a permission, you get a native desktop notification. You stop babysitting panes and let the agents call you when they actually need you. It is also the practical answer to the stalled-session problem: when an agent that should have pinged you stays quiet for too long, you notice.

Full conversation history, searchable

Kimi Code stores its sessions locally as plain files, and CodeAgentSwarm reads them, so every Kimi conversation is saved and searchable, including across different agents and different CLIs. You can go back and find what an agent decided yesterday, resume it, or trace exactly which agent made a given change. With a swarm running, that audit trail is what keeps the whole thing legible.

Built-in task board

A kanban task board sits next to your terminals, and the agents update it themselves over MCP. Kimi Code speaks the same MCP tool conventions as Claude Code, so the board integration works the same way: you create tasks, hand them to terminals, and watch cards move as each agent picks up, works, and finishes.

Per-terminal live file diffs

You can watch the file changes each Kimi Code agent is making in real time, per terminal and at the project level. When two agents edit the same file, you see it as it happens instead of discovering it in a messy diff later. This matters even more if you run agents with --yolo: the Kimi Code YOLO mode guide covers how to keep an auto-approving agent accountable.

Quick comparison

Here is how the three ways to run a Kimi Code swarm compare on the things that actually bite once you scale past two agents:

Cost

• Terminal tabs: Free
• tmux/screen: Free
• CodeAgentSwarm: Free tier available, Pro for advanced features. Your Kimi usage is billed through your existing Kimi subscription either way.

Setup time

• Terminal tabs: Zero, just open tabs and run kimi
• tmux/screen: 10-30 minutes to learn the basics, longer to script a reusable layout
• CodeAgentSwarm: A couple of minutes to download, open, and pick Kimi Code per terminal

Notifications

• Terminal tabs: None
• tmux/screen: None unless you script something custom
• CodeAgentSwarm: Native desktop notifications when an agent finishes or needs a permission

Quota visibility

• Terminal tabs: Type /usage in each session and add it up yourself
• tmux/screen: Same, per pane
• CodeAgentSwarm: A usage indicator that reads your Kimi weekly and 5 hour windows for the whole swarm

Conversation history

• Terminal tabs: On disk, but nothing to search it with
• tmux/screen: Same, plus scrollback while the pane lives
• CodeAgentSwarm: Reads Kimi Code's locally stored sessions and makes them searchable across every agent

Learning curve

• Terminal tabs: None
• tmux/screen: Moderate to steep, with keybindings and config files
• CodeAgentSwarm: Low, a visual interface with familiar patterns

If you only ever need two Kimi Code agents at once, terminal tabs are perfectly fine. If you already run your day inside tmux, dropping a few kimi sessions into your existing panes is natural. But once you regularly run three or more agents against one shared quota and want to actually see what each one is doing and spending, CodeAgentSwarm removes the coordination overhead that the other two leave on your plate.