Kimi Code alternatives: choose by workflow and API control

Which Kimi Code alternative you want depends on which "Kimi Code" you are leaving — the MIT-licensed terminal client, the membership service that funds it, or the K-series models — and two of those three can be replaced without changing your terminal client at all. Nearly every page ranking for this query is a model comparison, so the first job here is separating the three, and the second is the part no listicle carries: what actually moves out of ~/.kimi-code when you go.

One trap before anything else, because it is silent. pip install kimi-code does not install Kimi Code CLI. Moonshot's own README describes that PyPI package as "Archived. A legacy alias of kimi-cli, not the new Kimi Code CLI" (kimi-cli README, checked September 21, 2026). A tutorial that installs with uv tool install kimi-cli, configures ~/.kimi/config.toml, or uses provider types called openai_legacy and gemini is describing the archived Python client, not this one — those are the legacy client's own documented spellings.

Three products, one name: decide which you are replacing

Repository figures read from the GitHub API on September 21, 2026. The membership and the Open Platform are genuinely different products with different model ids — the membership names kimi-for-coding and k3, the Open Platform names kimi-k3 and kimi-k2.7-code — and the two id sets do not overlap, so a config written for one does not carry over unchanged. If your question is specifically Kimi's client and service against Anthropic's, Kimi Code vs Claude Code covers that comparison and this page does not repeat it.

Start from the reason you are leaving

The quota rules behind the first two rows are worth reading before you decide. Kimi's membership documentation states that "Requests from the CLI, VS Code, Desktop, and third-party tools all count toward that quota" and that "All logged-in devices and API Keys share the same quota"; that for new members the weekly limit is removed while the rolling five-hour rate window remains, and legacy plans still refresh every seven days with no rollover; and that "The Go tier has no coding quota; Plus and above can use Kimi Code" (checked September 21, 2026). No tier publishes a numeric token or request allowance, so there is no honest way to convert a plan price into a per-token rate — which is exactly why the decision below is about billing shape rather than a savings number.

If the reason is billing, the client can stay

Kimi Code's providers documentation describes the openai type as being for the OpenAI Chat Completions protocol "as well as any third-party service compatible with that protocol (override base_url as needed)". That makes the cheapest possible migration a provider table plus a model alias:

default_model = "kunavo/claude-sonnet-5"

[providers.kunavo]
type = "openai"          # the protocol, not the vendor
base_url = "https://api.kunavo.com/v1"   # the /v1 stays on openai types
api_key = "sk-kn-..."    # not read from your shell

[models."kunavo/claude-sonnet-5"]
provider = "kunavo"
model = "claude-sonnet-5"
max_context_size = 200000

Four details decide whether this works on the first try, all read from that page and the env-vars page on September 21, 2026. One: type names the protocol, not the vendor, and the documented set is kimi, anthropic, openai, openai_responses, google-genai and vertexai. Two: URL shape differs by type — openai defaults to https://api.openai.com/v1 and keeps the /v1, while google-genai and vertexai want the host root only, because the SDK appends the version path itself. Three: provider credentials are not read from your shell unless you name the variable yourself. The documented priority is api_key or api_key_env (set exactly one), then a [providers.<name>.env] sub-table, then startup fails, and the page states that "the CLI does not fall back to shell environment variables for credentials" except for an explicitly declared api_key_env. Four: api_key_env itself is documented as arriving in 2.0.1, published September 18, 2026 — on 2.0.0 or any 0.4x build it is not available.

There is a lighter route with a real limit: the KIMI_MODEL_* environment block accepts only kimi, anthropic and openai for KIMI_MODEL_PROVIDER_TYPE, so Responses, Gemini and Vertex endpoints have to go through config.toml. The interactive /provider importer has its own edges: it refuses proprietary protocols such as Amazon Bedrock and Cohere, and imports vendors whose protocol its catalog does not declare as OpenAI-compatible with a "guessed" note.

What a third-party endpoint does not reach

Changing the model provider does not carry four things with it, and this is the part a price comparison misses. Video upload is listed as an additional capability of the kimi provider type specifically, not of the OpenAI-compatible path. Web search and web fetch are not part of the model provider at all: the config-files page says the services table configures exactly two fixed keys, moonshot_search and moonshot_fetch, each with its own base URL and key, and that other keys are ignored. Remote Control (kimi rc) "requires a paid membership and is not available to free users", per its own guide, which also says the remote window is opened by logging in with the same Kimi account as the local CLI. And the /login selector offers two Moonshot options only — Kimi Code OAuth, or a Kimi Platform API key — with the getting-started page sending you to edit config.toml directly for any other provider.

One thing you do not have to rebuild: Kimi Code searches your repository with ripgrep rather than with a vector index. The data-locations page describes it downloading and caching rg under bin/ the first time Grep needs one — preferring a system rg on your PATH before the cache — and caching fd there for file-reference completion. So there is nothing to re-index when the provider changes. Kunavo serves no embedding model, and this route does not call for one.

Honest limit on all of the above: it is read from Moonshot's documentation, not from a session. No Moonshot page found on September 21, 2026 states outright that the CLI runs with no Kimi account when only a [providers.*] entry is present, and the getting-started and IDE pages still list a completed login as a first step. Verify it yourself before you cancel anything.

If you are leaving the client too

Repository metadata read from the GitHub API on September 21, 2026. A stale pushed_at is an observation, not a deprecation notice: Aider is not archived and no maintainer statement was found, so treat the date as cadence evidence and check it yourself before standardising a team on it. Two exclusions worth stating rather than hiding. Continue is not offered as a destination here: a census on September 17, 2026 recorded it as acquired and read-only with a final release, and that status was not re-verified today — re-check it before considering it. And the configuration details for every client above were verified in Kunavo's own integration pages on earlier dates, not re-tested today, which is why this table links to them instead of restating their setup.

If you want an editor instead of a different agent, note that Kimi Code already speaks the Agent Client Protocol: its IDE guide exposes an ACP server as kimi acp and shows the Zed agent_servers entry that drives it. That is a surface change, not a client migration — see Zed for the editor side.

What moves with you, and what does not

Read from the data-locations page on September 21, 2026. The whole tree relocates with KIMI_CODE_HOME, which is also the cleanest way to park a working setup while you test something else. Note what the "generic" copies do and do not promise: Kimi documents that it keeps them outside its own directory so other tools can share them. It does not promise that any other vendor's agent reads them, so confirm your destination's own instruction-file convention.

Coming from the Python client instead? That is a migration, not a choice. Run kimi migrate: the migration guide says it carries configuration, MCP server configuration, input history and whichever chat sessions you select, and that OAuth credentials, MCP service authorizations and kimi-cli plugins are not copied — so expect to run /login and re-authorize MCP servers afterwards. The rollback is free: "Migration never modifies or deletes any of the old data under ~/.kimi/." Uninstalling the old one afterwards is uv tool uninstall kimi-cli or brew uninstall kimi-cli, per the archived README's own migration steps — a different formula from the new client, which that README installs as brew install kimi-code.

Two Moonshot sources disagree about urgency here, and both were read on September 21, 2026. The archived README says "Existing installations are no longer supported and will stop working. Please migrate as soon as possible." The migration guide still on kimi-code's main branch says "The legacy version will gradually be phased out" and that "kimi-cli keeps working as before, and the two do not interfere with each other." The README is the newer and more specific statement; plan for it rather than for the gentler one.

What the metered routes cost, as token arithmetic

Assume one session that sends 250,000 uncached input tokens and receives 20,000 output tokens. These are illustrative estimates, not measured task costs and not a bill ceiling; caching, retries and tool traffic all sit outside the arithmetic. Kimi's figures are its own published per-token rates; Kunavo's come from the live catalog. Different model families, so this compares rates, not outcomes.

Kimi rates read from platform.kimi.ai on September 21, 2026, where the K3 table also lists cache-write pricing at $3.00 for a five-minute TTL and $6.00 for an hour. A cheapest listed price and the lowest cost to finish a task are different claims: a model that needs three attempts can cost more than a dearer one that needs a single pass, so measure against one bounded task in your own repository rather than against the table.

Kunavo's catalog amount is a billing floor rather than a cap: when the upstream reports its charge, the bill is the greater of catalog cost and upstream cost multiplied by the applicable markup. The minimum top-up is $10 in prepaid credit, which funds a balance — it is not a task fee or a subscription. See billing details.

If the config-file route is the one you want, Kunavo publishes the full provider block for this client. That is a published configuration reference, not a compatibility test: Kimi Code has never been runtime-tested against Kunavo's endpoint, and everything above was read from Moonshot's documentation and the GitHub and npm APIs. Keep your existing route working while you try it, run one bounded task, then read the charge your account actually recorded. Start at the Kimi Code integration guide, or create a Kunavo account when you are ready to fund a key. For the protocol-level view of what an OpenAI-compatible base URL does and does not carry, see OpenAI-compatible API; for the wider client landscape, the AI agent API directory.

FAQ

Checked September 21, 2026: repository metadata for kimi-code, kimi-cli and all seven destination clients via the GitHub API; the npm registry entry for @moonshot-ai/kimi-code; Moonshot's providers, env-vars, config-files, data-locations, IDE and migration pages; the kimi-cli README; the Kimi Code membership page; the OpenCode third-party page; and the Kimi Open Platform chat pricing table. No Kimi Code plan price is quoted on this page: kimi.com renders tier prices client-side and none appears in the server HTML, so confirm the amount in checkout. Continue's status and the destination clients' own configuration details were not re-verified today. Kunavo has run no session of this client against its own endpoint, and every dollar figure here is illustrative token arithmetic.