TL;DR — Moonshot AI released Kimi K3 on July 16: 2.8 trillion parameters (largest open-weight model ever, weights promised by July 27), 1M token context, native vision, and benchmark results that put it ahead of Claude Opus 4.8 and GPT-5.5 on coding and agentic evals — while sitting behind only Claude Fable 5 overall. API pricing: $3/M input (cache miss), $0.30/M (cache hit), $15/M output. That's premium-tier capability at roughly half of what frontier-lab flagships charge. We run a phase-aware LLM router for coding agents, so our question is narrower than "is it good": which phases of a coding session should actually route to it? Here's our honest read.
What Kimi K3 actually is
The headline numbers, confirmed from Moonshot's release and independent coverage:
| Spec | Kimi K3 | |---|---| | Parameters | 2.8T MoE (16 of 896 experts active per token, ~1.8%) | | Context window | 1,000,000 tokens | | Vision | Native (first Kimi flagship with it) | | Input price | $3.00/M (cache miss) / $0.30/M (cache hit) | | Output price | $15.00/M | | Open weights | Promised by July 27, 2026 | | Architecture | Kimi Delta Attention (hybrid linear) + Attention Residuals |
Two architectural notes that matter for coding agents specifically:
- Kimi Delta Attention is a hybrid linear-attention scheme — it's what makes the 1M context economically viable. Long-context degradation ("lost in the middle") has historically been where Chinese models lagged Claude; K3's long-horizon eval jump (+732 Elo over K2.6 on Moonshot's internal knowledge-work suite) suggests real progress, not just a bigger number on the spec sheet.
- Native vision means screenshot-driven debugging — pasting a broken UI into Cursor or Claude Code — no longer forces a route to Gemini or Claude. This was a real gap: Kimi K2.6 is text-only, so every vision request in a Kimi-heavy routing pool had to detour.
The benchmark claims, decoded
Moonshot's own framing is unusually honest, so let's keep it that way:
- Ahead of Claude Opus 4.8 and GPT-5.5 across Moonshot's coding and agentic benchmark suite.
- #1 on Arena's Frontend Code leaderboard at 1,679 — ahead of Claude Fable 5 on that specific eval.
- Behind Claude Fable 5 and GPT-5.6 overall — Moonshot says this themselves.
Our translation for coding-agent users: K3 is a legitimate Opus-class implementation and debugging model, plausibly the best open-weight model for frontend work, but not a wholesale replacement for the absolute frontier on hard architectural reasoning. That maps exactly onto how a phase-aware router thinks — no single model wins every phase.
The pricing math that actually matters: cache economics
Sticker price comparison first (per 1M tokens):
| Model | Input | Output | Context | Vision | |---|---|---|---|---| | Kimi K3 | $3.00 ($0.30 cached) | $15.00 | 1M | ✓ | | Claude Opus 4.8 | $5.00 | $25.00 | 1M | ✓ | | GPT-5.5 | $5.00 | $30.00 | 400K | ✓ | | Claude Sonnet 4.6 | $3.00 | $15.00 | 200K | ✓ | | Kimi K2.6 | $0.60 | $4.00 | 256K | ✗ | | DeepSeek V4 Pro | $0.44 | $0.87 | 128K | ✗ | | GLM-5.2 | $1.40 | $4.40 | 1M | ✗ |
At sticker price, K3 costs the same as Sonnet 4.6. But coding-agent traffic is the best-case workload for prompt caching: an agent session replays the same system prompt, tool schemas, and conversation prefix on every turn, so 70–90% of input tokens in a typical Cursor or Claude Code session are cache hits. At $0.30/M cached, K3's effective input price for agent workloads lands around $0.55–$1.10/M — closer to Kimi K2.6 territory than to Sonnet, for a model that benches above Opus 4.8 on coding.
Worked example — a heavy debugging session (40 turns, ~80K context by the end, ~25K output total):
- Opus 4.8: ~$9.80 (with Anthropic's cache pricing)
- Kimi K3: ~$1.55
- Sonnet 4.6: ~$5.90
That's not a rounding error. Across a month of professional use, it's the difference between a $400 bill and a $70 one for the same phase of work.
Where K3 fits in phase-aware routing
Our router classifies every request from Cursor, Aider, Claude Code, Windsurf, etc. into a coding phase — plan / implement / debug / test / refactor / document — and routes each to the cheapest model that clears the quality bar for that phase. Here's our current assessment of K3's slot:
- Debug — strongest fit. Debugging rewards deep multi-file reasoning over long context, and it's where users notice quality drops fastest. K3 at Opus-class quality and ~⅙ the effective cost is exactly the profile this phase wants.
- Plan / architecture — strong candidate for the second slot behind Opus 4.8 / Fable-class models. Moonshot's own "behind Fable 5 overall" framing suggests keeping the absolute frontier first for the hardest planning requests.
- Frontend implementation — the Arena result makes K3 arguably the default here.
- Vision-in-the-loop coding (screenshot → fix the UI) — K3 joins the small club of models that can take these requests natively, and it's the first Chinese model in that club.
- Test generation / docs — overkill. DeepSeek V4 Pro and Haiku-class models remain 5–20× cheaper and pass the quality bar fine.
One caveat we care about as a router: benchmark performance and protocol discipline are different things. A model can top the leaderboards yet still emit malformed tool_use blocks under a specific agent's tool schemas (we've had to blocklist models on the Anthropic protocol path for exactly this after they benched beautifully). We put every new model through a verification gauntlet — simple completion, tool-call round-trip, multi-turn tool loop under real Claude Code traffic shapes — before it enters production routing pools. K3 goes through the same gauntlet.
Availability today (and the honest catch)
As of this writing (July 18), Kimi K3 is live on Moonshot's own platform (api.moonshot.ai, model id kimi-k3), with open weights promised by July 27. Aggregator platforms typically lag official releases by days to weeks — check whether your provider actually serves K3 or silently falls back before you point production traffic at it.
On CodeRouter: Kimi K3 cleared our verification gauntlet (simple completion, tool-call round-trip, multi-turn tool loop, streaming — all on the direct Moonshot endpoint) and is live in our routing pools as of July 18 — plan and debug phases, plus the vision overlay for screenshot-driven coding. Kimi K2.6 continues to serve implementation phases. No action needed on your side. That's the point of routing through one endpoint: when a model like K3 lands, your agent picks it up automatically, model: "auto" and done. New models get adopted when they're verified, not when their press release drops.
Bottom line
Kimi K3 is the most credible "Opus-class quality at half the price" release we've seen, and its cache pricing makes it dramatically cheaper than the sticker suggests for agent workloads specifically. If you're paying frontier prices for every debugging session, this is the release that should make you reconsider — not by switching wholesale, but by routing the phases where K3 wins to K3, and keeping the frontier for the requests that genuinely need it.
CodeRouter is an independent service, not affiliated with Moonshot AI, Anthropic, OpenAI, or any tool mentioned. All trademarks belong to their respective owners. Pricing and benchmark figures are as reported at publication time and may change; verify against providers' official pages.