Kimi Code CLI: Moonshot AI agent on your key via Gonka

Step 1: install Kimi Code. The official methods from the documentation:

# macOS and Linux: prebuilt binary, no Node.js needed
curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash

# Windows (PowerShell); Git for Windows is required before the first run
irm https://code.kimi.com/kimi-code/install.ps1 | iex

# npm (Node.js 22.19 or newer)
npm install -g @moonshot-ai/kimi-code

The script puts the binary in ~/.kimi-code/bin/kimi and appends that directory to PATH via your shell configuration file. Its builds are glibc-only: on Alpine and other musl systems it will stop and suggest npm. Reopen your terminal and check: kimi --version.

Step 2: get a key. Sign up at gate.joingonka.ai/register, confirm your address, and create a key with the jg- prefix under "API keys".

Step 3: run the installer.

npx @joingonka/setup --tool kimi-code

The installer will ask for your key (it isn't passed via command-line arguments) and write only its own tables into ~/.kimi-code/config.toml:

• a [providers.joingonka] provider of type openai — that's the Chat Completions protocol — with the gateway address and the key in the api_key field; the file will be set to permissions 600;
• one [models."joingonka/…"] table per network model — with the real context window and response cap, plus explicit capabilities: tool calling for all, reasoning for DeepSeek V4 Flash and GLM-5.3 Flash, tools only for MiniMax M2.7;
• default_model — DeepSeek V4 Flash, if no default model is selected yet or it points to a model that has left the gateway's network; it won't touch another provider's choice without the --model flag and will suggest a command for a one-off run instead;
• it will save a copy of the previous file, leave other providers and your fields in the gateway tables untouched, and finally send a live request to the gateway to tell you whether the key, address, and model were accepted.

Here's what the output looked like in our run (abridged):

Configured provider "joingonka" in ~/.kimi-code/config.toml
Base URL: https://gate.joingonka.ai/v1 (provider type "openai" — Chat Completions)
Models: joingonka/MiniMaxAI/MiniMax-M2.7, joingonka/deepseek-ai/DeepSeek-V4-Flash-0731, joingonka/zai-org/GLM-5.3-Flash
Default model: joingonka/deepseek-ai/DeepSeek-V4-Flash-0731
…
✓ Verified: the gateway accepted the key, base URL and model.

Set a different default model with the --model flag (glm, minimax, or a full identifier); the no-questions mode takes the key from an environment variable:

JOINGONKA_API_KEY=jg-your-key npx @joingonka/setup --tool kimi-code --model glm --non-interactive

The installer automatically accounts for a data directory relocated via the KIMI_CODE_HOME variable. But ~/.kimi is the directory of the older Python client kimi-cli: Kimi Code 2.x doesn't read it, and on first launch offers to migrate settings from there (the same is done by kimi migrate).

Everything the installer does can also be done by hand. Kimi Code stores its settings in TOML; table keys containing a dot or a slash go in quotes. Here's the complete snippet for the Gonka network:

default_model = "joingonka/deepseek-ai/DeepSeek-V4-Flash-0731"

[providers.joingonka]
type = "openai"
base_url = "https://gate.joingonka.ai/v1"
api_key = "jg-your-key"

[models."joingonka/deepseek-ai/DeepSeek-V4-Flash-0731"]
provider = "joingonka"
model = "deepseek-ai/DeepSeek-V4-Flash-0731"
max_context_size = 380000
max_output_size = 32768
capabilities = ["thinking", "tool_use"]
display_name = "DeepSeek V4 Flash (Gonka)"

[models."joingonka/zai-org/GLM-5.3-Flash"]
provider = "joingonka"
model = "zai-org/GLM-5.3-Flash"
max_context_size = 390000
max_output_size = 8192
capabilities = ["thinking", "tool_use"]
display_name = "GLM 5.3 Flash (Gonka)"

# MiniMax M2.7, unlike DeepSeek and GLM, is declared without thinking
[models."joingonka/MiniMaxAI/MiniMax-M2.7"]
provider = "joingonka"
model = "MiniMaxAI/MiniMax-M2.7"
max_context_size = 200000
max_output_size = 8192
capabilities = ["tool_use"]
display_name = "MiniMax M2.7 (Gonka)"

Where to keep the key. Kimi Code does not take keys from the shell environment: export OPENAI_API_KEY=… has no effect on it. There are two ways, and you can't use both at once:

If both fields appear in the same table, Kimi Code will reject them at startup: has both apiKey and apiKeyEnv set in config.toml - they are mutually exclusive. Note that kimi doctor does not catch this conflict — it only checks the shape of the file.

Which provider type to choose. Kimi Code supports several protocols, and so does the gateway:

In Kimi Code, one provider speaks one protocol, so a second protocol means a second provider under a different name. You can add and remove providers interactively with the /provider command inside the agent.

A model in Kimi Code is an alias, the name of a table [models."…"]. The installer names them using the pattern joingonka/<model-id>, just as Kimi Code names its own (kimi-code/k3), and it's precisely the alias that's needed wherever a model is selected. Kimi Code won't find an identifier without a prefix, like MiniMaxAI/MiniMax-M2.7.

In our run, /model looked like this:

Select a model  (type to search)
Tab toggle provider · ↑↓ navigate · Enter select · Alt+S session-only · Esc cancel

 All   joingonka

   MiniMax M2.7 (Gonka)       joingonka
 ❯ DeepSeek V4 Flash (Gonka)  joingonka ← current
   GLM 5.3 Flash (Gonka)      joingonka

 Thinking  (←→ to switch)
  [ On ]    Off

Thinking toggle. The reasoning switch below the list on network models doesn't change anything by itself: Kimi Code only sends the reasoning level to models that declare levels. For GLM-5.3 Flash, it's worth doing — its reasoning is disabled by the value low (for more details, see the model overview). Add three fields to the model table:

[models."joingonka/zai-org/GLM-5.3-Flash"]
# … fields written by the installer …
support_efforts = ["low", "high"]
default_effort = "high"
off_effort = "low"

We verified what goes to the gateway: with Thinking on, Kimi Code sends reasoning_effort: "high", and the model reasons; with it off, "low", and the response comes back without a reasoning block. Re-running the installer won't touch these fields: it only edits its own keys.

Model for subagents. Built-in subagents (coder, explore, plan) use the main agent's model by default. The [secondary_model] section gives them a pool from which the main agent selects on its own, guided by hints. Any alias works for the pool — DeepSeek V4 Flash, GLM-5.3 Flash, or MiniMax M2.7:

[secondary_model]
default_model = "joingonka/deepseek-ai/DeepSeek-V4-Flash-0731"

[secondary_model.models]
"joingonka/deepseek-ai/DeepSeek-V4-Flash-0731" = "Long context and long output: big reads and edits."
"joingonka/zai-org/GLM-5.3-Flash" = "Reasoning model for tricky logic and debugging."

Pool keys must match the aliases in [models]: according to the documentation, a dangling reference prevents creating a session. The line for MiniMax M2.7 is added the same way; references to models that have left the network are cleaned up by the installer on the next run.

Which model to choose. The price is the same for all network models, so the choice is about behavior. Here's how they behaved in Kimi Code 2.0.2 on the task "read the file and find the bug" (verified September 23, 2026):

First, make sure Kimi Code sees the provider and the file parses without errors:

$ kimi provider list
joingonka  type=openai  models=3  source=inline

Default model: joingonka/deepseek-ai/DeepSeek-V4-Flash-0731

$ kimi doctor
OK config.toml  ~/.kimi-code/config.toml

Never publish the output of kimi provider list --json anywhere: the key in it sits there in plain text.

Next, a one-off run. Drop a calc.py into a directory with an addition function that actually subtracts, and ask it to find the bug:

kimi -p "Read calc.py and tell me in one sentence whether it has a bug."

In -p mode, the answer goes to stdout while the reasoning and tool trace go to stderr, so the output is easy to parse with a script. Here's how GLM-5.3 Flash answered:

• Yes: the `add` function in calc.py:2 returns `a - b` instead of `a + b`, so `add(2, 3)` prints `-1`.

Keep in mind: in -p mode Kimi Code asks nothing and executes commands on its own — in our run the model tried to launch python3 without asking to check its guess. The first launch of the interface in a new directory begins with a Trust this folder? prompt — it concerns the project's MCP servers — and the welcome screen shows the model: Model: DeepSeek V4 Flash (Gonka). The second half of the check is the gateway dashboard: in the "Usage" section the request will appear broken down by model and by key.

If something went wrong, the diagnosis is usually readable right from the message:

For every phrase you send, Kimi Code adds a system prompt and descriptions of two dozen built-in tools, and a task usually takes several steps. In our run, each step carried about 20,000 input tokens, and "read the file, find the error" took two steps — about 40,000 tokens, almost all on input. Therefore, the price per token is the deciding factor here.

Through the JoinGonka Gateway, tokens cost $0.0069 per million for input and $0.021 per million for output — the price is the same for all models in the network and is pulled onto this page from a live source.

The estimates in the right column are based on September 2026 prices. For comparison — how you can generally pay for models in Kimi Code:

Exact consumption and balance are in the dashboard, in the "Usage" and "Billing" sections. Kimi Code monitors the length of the conversation itself: the status bar shows what share of the context is occupied, and the /compact command compresses the history manually.

Permission modes. Kimi Code defaults to the Always Ask mode: reads are performed immediately, while edits and commands require your confirmation. Ask When Needed (/yolo or --yolo flag) skips routine edits and commands but prompts for sensitive files and dangerous commands; Never Ask (/auto, --auto) asks for nothing. The planning mode is enabled via Shift-Tab. A one-off run of kimi -p always proceeds without questions, so run it inside a container or a separate working copy.

What works without a Moonshot account. Your provider handles everything the model does: reading and editing code, commands, subagents, sessions, and MCP servers. Web search is a Moonshot service: without logging into an account, the WebSearch tool is not available in the agent's set, but loading a page by address (FetchURL) remains. Network models are text-based, so inputting images and videos does not work with them.

Telemetry and updates. Anonymous telemetry is enabled by default: you can disable it with the telemetry = false line in config.toml or the KIMI_DISABLE_TELEMETRY=1 variable. Updates are installed automatically ([upgrade] auto_install = true in ~/.kimi-code/tui.toml); if you need predictability, turn it off and update using the kimi upgrade command. The gateway does not store the content of prompts and responses—only consumption aggregates remain in the statistics.

Multiple environments. Kimi Code does not have provider settings at the project level. You can separate work and personal keys using the KIMI_CODE_HOME variable: with it, settings, sessions, and logs move to a different directory, and the installer, when run with the same variable, writes to the same place.

In the editor. Kimi Code works inside Zed, JetBrains, and other ACP clients via the kimi acp command — using the same data directory and the same providers.

Labs whose models are served by the network also release their own agents: MiniMax has a terminal MiniMax Code, DeepSeek has DeepSeek Harness, and Z.ai, the creators of GLM, have ZCode. All of them connect to the same gateway with the same key.