How to Run Multiple Kimi Code Sessions at Once
kimi command you start an independent session with its own conversation and context, so two or more of them can work on different tasks in the same repository at the same time without sharing anything.
The part that takes a bit of thought is not starting the processes. It is keeping the sessions legible: which terminal is on which task, which one is waiting for a permission, and how fast they are draining the one quota they all share. Kimi Code gives you decent primitives for this (sessions are stored on disk per project, you can name them with /title and resume them with --continue), but nothing ties them together out of the box.
This guide covers how Kimi Code sessions actually work, the three practical ways to run several side by side, and what going parallel does to your quota. For the bigger picture of a full swarm, see the Kimi Code agent swarm guide.Short answer: yes, each kimi process is its own session
Kimi Code is Moonshot AI's terminal coding agent, powered by Kimi K3. You install it once (curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash, or npm install -g @moonshot-ai/kimi-code with Node 22.19+), log in once with /login, and start it with the kimi command. Every invocation is a separate process with its own conversation, its own context, and its own working directory.
So running multiple Kimi Code sessions at once is not a special mode. Open a second terminal, run kimi again, and you already have two independent sessions. One can be migrating a database layer while the other writes integration tests. If you are new to Kimi Code itself, start with how to use Kimi Code and come back.
You are not limited to Kimi either. Because each agent is its own process, you can run Kimi Code in some terminals and Claude Code or Codex CLI in others, all on the same repository. The AI CLI agent swarm overview shows how the different tools fit side by side.
All your Kimi Code sessions sign in with the same account and share one subscription quota, with a weekly refresh and a rolling 5 hour window. Parallel sessions do not cost extra, they just spend the same pool faster. More on that below.
How Kimi Code sessions work: disk, --continue and /title
Kimi Code stores every session on disk as plain files, organized per project directory under ~/.kimi-code/sessions/. Each session keeps its metadata (title, timestamps) and the full transcript. This is what makes parallel sessions manageable: they are real, named, resumable things, not just scrollback.
kimistarts a fresh session in the current directorykimi --continue(or-c) resumes the most recent session for that directorykimi --session <id>resumes one specific session by id/title My migrationinside a session names it, so you can tell your terminals apart later
Two habits pay off as soon as you run more than one session. First, give each session a title the moment you start it: three unnamed sessions in one repo become indistinguishable within the hour. Second, note that --continue is per directory, so if you run several sessions in the same folder it resumes the latest one, not necessarily the one you meant. When that ambiguity bites, resume by id instead. The Kimi Code conversation history guide goes deeper on where sessions live and how to find old ones.
Method 1: Multiple terminal tabs (free, basic)
The most direct way to run two Kimi Code sessions at once is to open several terminal tabs, move into your project in each one, and start kimi.
# Terminal tab 1
cd ~/my-project
kimi
# then inside: /title API tests
# Terminal tab 2
cd ~/my-project
kimi
# then inside: /title Schema migrationEach tab is now an independent Kimi Code session. Hand each one a different task and switch between them as they work. When a session stops to ask for approval before a command or a file write, that tab waits silently for you, so you end up bouncing between tabs to keep things 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 session
Cons
- You lose track of which tab is running which task almost immediately
- No notification when a session 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 history of different sessions
- If two sessions edit the same file, untangling it is on you
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, so you can watch several Kimi Code sessions at once without flipping between tabs.
# Start a new tmux session
tmux new-session -s kimi
# Split horizontally
tmux split-window -h
# Split the right pane vertically
tmux split-window -v
# Now you have 3 panes - run kimi in each oneDetach and reattach works as usual, so sessions survive closing the window. The caveats are the usual tmux ones: no desktop notifications, no cross-session search, and panes get cramped past three or four sessions. One extra Kimi-specific caution: there are open upstream reports of sessions stalling silently when a request hangs, and in a detached tmux pane a stalled session looks exactly like a busy one.
Same repo or separate worktrees?
Running several sessions in the same working copy is fine while their tasks touch different areas. The moment two sessions edit the same files, you inherit the merge. If you plan to keep several Kimi Code sessions busy on the same repository for hours, give each one its own git worktree: same repo, separate folders, separate branches, zero stepping on each other.
git worktree add ../my-project-tests feature/tests
git worktree add ../my-project-migration feature/migration
# Session 1
cd ../my-project-tests && kimi
# Session 2
cd ../my-project-migration && kimiAs a bonus, worktrees make --continue unambiguous, because each session lives in its own directory. The git worktrees for AI agents guide covers the full setup, and worktree vs branch explains when each is worth it.
What parallel sessions do to your quota
Every Kimi Code session draws from the same subscription pool: a quota that refreshes on a weekly cycle plus a rolling 5 hour window on top. Three sessions working flat out consume roughly three times faster than one, so heavy parallel bursts tend to hit the 5 hour window first, even with weekly quota to spare. Nothing breaks when you hit it, you just wait for the window to roll.
You can check consumption with /usage inside any session. The practical advice: run parallel sessions for genuinely independent tasks, and keep it to the two or three that you can actually supervise. The plans and pricing guide has the detail on tiers and multipliers.
Method 3: CodeAgentSwarm (visual, full-featured)
CodeAgentSwarm is a desktop app for macOS and Windows built for running and supervising several AI CLI sessions in one place. Kimi Code is a first-class agent alongside Claude Code, Codex CLI, Antigravity CLI and opencode: you choose the agent per terminal, so running three Kimi Code sessions means opening three terminals and picking Kimi Code in each.
What that adds on top of raw terminals:
- Dynamic titles: each terminal shows what its session is working on right now, instead of three tabs all labelled "kimi"
- Desktop notifications: a native notification when a session finishes or stops to ask for a permission, so no more babysitting tabs
- Searchable history: CodeAgentSwarm reads Kimi Code's locally stored sessions, so you can search and resume conversations across every terminal and every agent
- Quota indicator: a live view of your shared Kimi quota, both the weekly cycle and the 5 hour window, for all sessions combined
- Live file diffs: watch what each session changes in real time, per terminal and per project
- Task board: a kanban next to your terminals that the agents themselves update over MCP
If Claude Code is your main agent, the same setup is covered in running multiple Claude Code sessions, and mixed setups work the same way: pick a different agent per terminal and supervise everything in one window.
New to running several terminals at once? The multi-terminal guide walks through the layout and workflow, and it applies the same whether the agent is Kimi Code or Claude Code.
FAQ
Yes. Each time you run the kimi command you get an independent session with its own conversation and context, so you can open several terminals and run kimi in each one. They do not share state or step on each other unless they edit the same files. CodeAgentSwarm supports multiple terminals so you can supervise several Kimi Code sessions in one window.
Use kimi --continue (or -c) to resume the most recent session for the current directory, or kimi --session with the session id to resume one specific session. Sessions are stored per project under ~/.kimi-code/sessions/, and naming them with /title as you go makes finding the right one much easier.
There is no surcharge for running sessions in parallel, but they all draw from the same subscription quota, which refreshes weekly and has a rolling 5 hour window on top. Parallel sessions finish the work sooner while spending the shared pool faster, so heavy bursts tend to feel the 5 hour window first. The total work your plan buys does not change.
Yes. Each agent is a separate process, so you can run Kimi Code in some terminals and Claude Code or Codex CLI in others, on the same project. In CodeAgentSwarm you pick the agent per terminal, so a mixed setup is the default. There is also a different option if you want one harness: running the K3 model inside Claude Code, covered in the Kimi K3 with Claude Code guide.
Same repo is fine while tasks touch different areas. For longer parallel work, git worktrees are better: each session gets its own folder and branch, so sessions never edit the same working copy, and --continue becomes unambiguous because each directory has its own session history.
Kimi Code itself does not impose a hard limit, since each session is just a process. In practice your shared quota and your attention are the constraints: the rolling 5 hour window throttles heavy bursts, and unsupervised sessions pile up permission prompts. Two to four supervised sessions is the practical sweet spot for most work.
Run several Kimi Code sessions at once in CodeAgentSwarm. Multiple terminals in one window, desktop notifications when a session finishes, searchable history and a live view of your shared Kimi quota.
Try CodeAgentSwarm