I installed Kimi Code the week K3 shipped and ran it against a mid-sized Next.js repo for four days before writing this. What surprised me wasn’t the model — it’s genuinely competent at multi-file refactors — it was how easy it is to accidentally torch your monthly credit pool without ever touching a settings panel. Moonshot buried the one habit that actually controls your bill inside a docs footnote. This guide pulls it out front and center, along with the plan math, the setup steps, and where K3 still shows rough edges.

Three Model IDs, One Picker

Open the /model menu in Kimi Code and you’ll see three entries, and mixing them up is the first place people trip. Only one of them is actually K3.

One naming quirk worth flagging before you go build something: Kimi Code’s CLI and VS Code extension use kimi-for-coding, but if you hit the raw Moonshot API directly, the same model answers to kimi-k2.7-code. Same weights, different label depending on which door you walked through. I lost twenty minutes to this on day one, pointing a third-party harness at the wrong ID and getting a silent fallback instead of an error.

Setup: Install, Log In, Select K3

Kimi Code CLI ships two install paths. The official script pulls a single binary and skips Node.js entirely — this is the one I’d default to:

On Windows, the PowerShell equivalent is irm https://code.kimi.com/kimi-code/install.ps1 | iex, and you’ll want Git for Windows installed first since the CLI shells out through Git Bash. If you’d rather manage it through your existing Node toolchain, npm install -g @moonshot-ai/kimi-code works too, but it wants Node 22.19.0 or newer — the CLI complained loudly on my machine until I bumped from an older LTS version.

Once installed, run kimi to open the TUI and type /login. You get a choice between Kimi Code OAuth (browser device-code flow — scan, approve, done in about ten seconds) or pasting a Moonshot Open Platform API key directly. I used OAuth for the CLI and reserved the API key for a script I was testing against the raw endpoint; keeping those separate made it much easier to see which surface was burning credits when my bill came due.

With a Moderato-or-above membership active, type /model and select k3. That’s the entire vendor-documented path. The VS Code extension exposes the same choice as a dropdown in the input bar. If you’re wiring K3 into a third-party harness, set the model ID to k3 and, if your plan includes the full window, set the context-length field to 1048576 explicitly — several tools default to a smaller window and won’t self-correct.

Plan Tiers: What Each One Actually Buys

Moonshot splits this information across two pages that don’t reference each other — the model docs tell you what each tier unlocks, the pricing page tells you what it costs. Here’s both, joined into one table, current as of July 17, 2026.

The number worth sitting with is the jump from Moderato to Allegretto. Doubling your fee from $19 to $39 doesn’t just buy 4x the context — it buys a 5x credit multiplier. If you’re actually running K3 daily, Allegretto is the better deal per credit, not just the bigger context tier. K2.7 Code, meanwhile, stays free for everyone, including Adagio, so the ladder gates K3 and concurrency specifically, not basic coding ability.

One honest caveat: Moonshot’s own pricing page currently carries a notice that Kimi and Kimi Code benefits will be split apart in a coming restructure, and the promo prices are explicitly time-limited. Treat this table as a dated snapshot, not a permanent rate card.

Cache Discipline: The Rule That Actually Controls Your Bill

This is the part most setup guides skip, and it’s the one that matters most. K3’s API pricing is flat across the entire 1M window — no tiering by context length — but input has two very different prices depending on whether it hits the cache:

Moonshot documents this plainly, if quietly: switching models mid-session invalidates the existing context cache, forcing a full re-prefill at the miss rate. Its own launch material also states the Kimi API rides a cache-hit rate above 90% on coding workloads — so under normal conditions, most of your input is billed at the cheap end. Break that streak with a model switch and you pay the 10x penalty on everything that had built up.

Here’s the arithmetic on a session carrying 400K tokens of cached context. A warm-cache turn bills that input at the hit rate: 400,000 × $0.30 per million ≈ $0.12. Switch models mid-session and that same context re-prefills at the miss rate: 400,000 × $3.00 per million = $1.20 — roughly a dollar of avoidable spend from one switch, before the session has done any new work. Do that a few times a day across a team and it stops being a rounding error.

The fix is a habit, not a setting: pick your model before the session starts. Need a different one mid-task? Close the session and open a fresh one. You’ll pay a normal cache warm-up either way, but you avoid the re-prefill tax — and, per Moonshot’s own limitations notes, you avoid a quality risk too (more on that below). Running /compact on long sessions also helps, since it keeps the context you’d have to re-prefill from ballooning in the first place.

The Knobs You Don’t Get

If your cost playbook from another harness involves dialing down temperature or dropping to a lighter reasoning tier, K3 will feel restrictive. Sampling is fixed — temperature 1.0, top_p 0.95 — and the API docs instruct you to omit those fields rather than try to override them. Reasoning effort currently centers on max at launch; Moonshot’s own model docs list low and high as available in some surfaces, but independent testing in the days since release consistently shows every K3 call running at max regardless of the label you pass. Budget for max-effort token consumption on every request until that changes.

What you do get is solid on the developer surface: structured output through json_schema with strict mode, forced tool calls via tool_choice: required, and streaming that separates reasoning deltas from the final answer. Control here lives in structure and tooling, not sampling — which is a different mental model if you’re coming from a harness where every request carries five adjustable dials.

Where Moonshot Admits K3 Falls Short

Moonshot’s launch material includes a limitations section that’s unusually candid for a flagship release, and two disclosures matter directly for how you run K3 inside Kimi Code. First, thinking-history sensitivity: if a harness fails to pass back the full historical thinking content, or if a session running another model gets switched to K3 mid-stream, generation quality can become unstable. That’s the quality twin of the cache-cost rule above — one habit, fresh session per model, fixes both failure modes at once.

Second, Moonshot flags excessive proactiveness — K3 can make unprompted decisions on ambiguous or minor issues, which argues for tighter review in plan mode before letting a long agentic run go unattended. It’s rare for a vendor to say this plainly at launch, and it’s worth taking seriously if you’re queuing up unattended multi-hour sessions.

Which Tier Actually Fits Your Workload

Just evaluating the harness? Stay on Adagio. You get K2.7 Code and the full CLI, enough to judge fit before spending anything.

Solo developer, curious about K3? Moderato is the cheapest door in, but 256K and 1x credits will feel tight if you’re running K3 daily across a real repo.

Daily agentic driver? Allegretto is where the math actually lands — full 1M context, HighSpeed, and 5x credits for roughly double Moderato’s fee.

Team running parallel swarms? Allegro and Vivace buy allotment and concurrency, not new capability — the feature set stops expanding after Allegretto.

If you’re deciding between K3 and other coding assistants entirely, our breakdown of whether Claude AI is worth it for coding and our ChatGPT for coding review cover the two most common comparisons developers ask about. For a broader field of terminal-first agents, our vibe coding tools roundup is a useful next stop.

How I Test the Platforms I Review

Every review on Websites2Know is built from hands-on use, not a summary of a landing page. For this piece, I created a personal Kimi account, ran on the free Adagio tier long enough to confirm what it does and doesn’t expose, then subscribed to a paid tier to test K3 directly against a real repository. I worked through the install flow on both a fresh machine and an existing Node setup, tracked login friction, and logged where the documentation and the actual product behavior disagreed — including the silent HighSpeed model-ID fallback and the effort-label mismatch described above.

This review reflects my personal experience and opinion. It is not professional, financial, legal, or technical advice. Pricing, plan gating, and feature availability change quickly in this space — for anything you’re about to commit budget to, verify current terms directly with Moonshot AI before you subscribe.

FAQ

Do I need a paid plan to try Kimi Code at all?

No. The free Adagio tier includes the full CLI and K2.7 Code, the coding-specialist model. You just won’t see K3 in the /model picker until you’re on Moderato or above.

Why does switching models cost me money?

Kimi Code caches your prompt context so repeat turns bill at $0.30 per million tokens instead of $3.00. Changing the active model invalidates that cache, so the next turn re-prefills the full context at the higher miss rate.

Can I lower K3’s reasoning effort to save tokens?

Not effectively yet. K3 currently runs at max reasoning effort regardless of the label you pass, so plan your token budget around always-on, high-effort thinking.

Is K2.7 Code still worth using now that K3 is out?

Yes, for routine work inside 256K context. It’s included on every tier, including free, and its per-token cost is well below K3’s. Reach for K3 when you need the larger window or its broader reasoning depth.

The takeaway worth carrying with you: K3 inside Kimi Code rewards discipline more than configuration. The setup is genuinely simple — one binary, one login, one command. Everything that matters after that is economic, and the economics reward one habit above all others: pick your model, keep your session, protect your cache.