Moonshot AI's Kimi K2.7 Code ships with a control surface that's deliberately bolted shut. Before you write a single prompt, several knobs developers normally reach for are simply gone.
K2.7's Immutable Knobs: Fixed Sampling and No Override
Kimi K2.7 Code removes the runtime controls most coding-agent builders expect: reasoning runs on every call and cannot be turned off, sampling is hard-coded, and tool invocation is constrained. According to ExplainX, thinking/reasoning mode is mandatory with no disable flag . That means even a trivial lookup or a one-line format fix pays the full reasoning overhead — there is no fast path for low-stakes calls.
Sampling is fixed too. Temperature sits at 1.0 and top_p at 0.95 with no per-call override, per the model card summarized by Marktechpost . Deterministic or low-entropy tasks — structured extraction, classification, idempotent edits — have no escape path to lower-variance decoding. You take temperature 1.0 or you don't use the model.
Tool control is narrowed as well. tool_choice accepts only auto or none; required is unavailable . Any workflow that must force a specific tool call — a guaranteed function invocation, a mandatory schema return — has to be re-engineered around the model rather than enforced at the API.
The constraints follow the model, not the tier. The kimi-k2.7-code-highspeed variant runs the same model at roughly 180 tokens/s output, up to 260 tokens/s in short-context cases, but inherits every restriction above . Both standard and HighSpeed share a hard 32,768-token maximum output ceiling . For developers, the takeaway is plain: K2.7 deliberates on every call, and there is no off-switch.
The Asymmetry: 256K Intake, 32K Reply
The window is lopsided. K2.7 ingests up to 256K tokens — enough to load a sizeable repository in one pass — yet caps generation at 32,768 tokens per call . You can show it a lot; it answers in a comparatively narrow slot.
That asymmetry matters most against the frontier. GPT-5.5 and Claude Opus 4.8 both list a 1M context window and 128K maximum output — roughly 4× more headroom on the reply side . K2.7 reads at near-frontier scale but writes back a quarter as much per turn.
| Model | Context window | Max output |
|---|---|---|
| Kimi K2.7 Code | 256K | 32,768 |
| GPT-5.5 | 1M | 128K |
| Claude Opus 4.8 | 1M | 128K |
Sources: Kimi figures ; GPT-5.5 and Opus 4.8 .
The practical effect lands in agentic coding. A 32K output ceiling won't emit a full-file rewrite or scaffold a project beyond roughly 10K lines in one shot — those jobs spill past the limit and stall mid-generation. Plan for multi-pass workflows instead:
- Chunk large edits — split file rewrites across turns rather than requesting one monolithic diff.
- Lean on tool calls — let the agent write incrementally to disk instead of returning whole files inline.
- Budget the reply — track output length per call; long generations hit the 32,768 wall, not a soft warning.
Hosting adds a second consideration. K2.7 bundles MoonViT, a 400M-parameter vision encoder for image and video input . Useful for multimodal debugging, but it rides along in the full weight tree and consumes GPU memory whether or not you feed it images — overhead worth accounting for before you self-host.
Hosting 595 GB: INT4 Quantization and Compatible Runtimes
Self-hosting K2.7 Code means moving a roughly 595 GB safetensors tree from the Hugging Face repository moonshotai/Kimi-K2.7-Code before any inference happens . The model logged 229,156 downloads in the 30 days after release, so the appetite for a downloadable coding model at this scale is real . Provisioning, not curiosity, is the gate.
The architecture explains the footprint. K2.7 is a Mixture-of-Experts design with about 1.1 trillion total parameters but only ~32 billion activated per token . Each token routes through 8 of 384 experts plus 1 shared expert, across 61 layers, with MLA attention and SwiGLU feed-forward blocks . You pay storage and memory for the full expert set; you pay compute for only the activated slice.
Native INT4 quantization ships in the box, which is what makes the trillion-parameter weight tree tractable on real hardware rather than a research cluster . Moonshot confirms the model runs on established serving stacks:
- vLLM — high-throughput serving
- SGLang — structured generation and agentic loops
- KTransformers — CPU/GPU hybrid offload for MoE
- Transformers — the reference path
- Docker Model Runner — containerized local hosting
Moonshot's framing is that existing K2.6 deployment patterns carry over to these runtimes, so teams already running the prior model inherit most of their tooling . That is convenience, not a guarantee. As one operator framed the recurring trap with large MoE checkpoints: "Compatible on paper and compatible in your build are different claims — verify the INT4 MoE kernel path in your pinned version before you buy the GPUs," a caution echoed across self-hosting writeups of the release .
The practical sequence: confirm your specific vLLM (or SGLang) version implements INT4 MoE routing for this architecture, size GPU memory against the full weight tree plus the MoonViT encoder overhead, then provision. Skipping that check is how a 595 GB download becomes idle hardware.
K2.7 Speaks Both Dialects: Swapping the URL Is All It Takes
K2.7 Code ships with both OpenAI-compatible and Anthropic-compatible endpoints, so migrating an existing agent is a configuration change, not a rewrite. Point your client at Moonshot's host and set the model ID; the SDK you already use stays in place . That dual-dialect surface is the practical reason teams are testing it against incumbent tooling rather than rebuilding pipelines.
For the OpenAI path, repoint the base URL to api.moonshot.ai and set the model to kimi-k2.7-code. No library edits are required — the OpenAI Python or Node client treats it as another compatible backend .
For the Anthropic path, two environment variables reroute Claude Code without touching code:
ANTHROPIC_BASE_URL=https://api.moonshot.ai/anthropic
ANTHROPIC_MODEL=kimi-k2.7-codeClaude Code then issues its normal agentic loop against Moonshot's servers . If you already drive Claude Code in CI or a dev container, this is a near-zero-friction swap.
The API surface is broad enough for most agent workloads. Supported features include:
- ToolCalls — function calling for multi-step tool use.
- JSON Mode — structured output for parseable responses.
- Partial Mode — prefill-style continuation of assistant turns.
- Automatic context caching — cached input bills at $0.19 per 1M tokens versus $0.95 standard, a ~5× discount that matters for agents replaying long system prompts.
The gap to watch is tool_choice. Moonshot limits it to auto or none, so tool_choice='required' — forcing a tool call on every turn — is not available . Agents that depend on guaranteed tool invocation will need a fallback. Streaming semantics can also differ by client, so token boundaries and delta framing may not match what your current backend emits.
The takeaway: test your exact call pattern — your specific tool-choice settings, streaming consumer, and JSON parsing — before committing to migration. The endpoints speak the same dialects, but the constraints around forced tool use and stream formatting are where a "drop-in" swap quietly breaks.
From Download to Redistribution: The Hidden Obligation
Before you ship K2.7 Code in anything user-facing, read the license — it is not standard MIT. Moonshot releases both the code and the weights under a Modified MIT License, and the modification carries a concrete obligation: any product or service exceeding 100 million monthly active users or $20 million in monthly revenue must prominently display "Kimi K2.7 Code" in its user interface . That is a permissive-with-attribution model, not a no-strings grant.
The threshold is disjunctive — either trigger alone activates the clause. A high-traffic free product can cross 100M MAU long before it crosses $20M in revenue, and a lean paid platform can clear the revenue line on a fraction of that traffic. Read the full text rather than the summary before committing.
The clause attaches to the product, not the call path. It does not matter whether you reach the model through Moonshot's hosted API or run the open weights on your own hardware — both API consumers and self-hosted deployers are in scope once their product clears either threshold. Swapping to self-hosting to dodge attribution does not work; the obligation follows the surface your users touch, not the endpoint your backend hits.
Who actually needs to act on this:
- Coding-agent and AI IDE vendors at scale — large user bases push them toward the MAU trigger fastest.
- Enterprise AI platform teams with high-volume agentic workloads, where token bills and revenue both run high.
- Open-weight deployers embedding K2.7 in commercial products, who may assume self-hosting removes obligations — it does not.
For most early-stage teams this is a non-issue. If you are below 100M MAU and $20M in monthly revenue, the Modified MIT terms behave like ordinary permissive licensing — you can build, fork, and ship without the UI attribution requirement. The trap is structural rather than immediate: a clause that costs nothing at launch becomes a redistribution obligation precisely when your product succeeds. Bake the attribution decision into your architecture review now, while changing a UI string is cheap.
Where K2.7 Leads and Where It Lags
K2.7 Code's measured strength is tool use, not raw coding. Its best published result is 81.1 on MCP Mark Verified, edging out Claude Opus 4.8 at 76.4 but trailing GPT-5.5 at 92.9 . On pure coding the frontier lead holds: Program Bench 53.6 vs GPT-5.5's 69.1, and Kimi Code Bench v2 62.0 vs 69.0 .
Quick Answer: K2.7 Code's relative strength is agentic tool use — it tops Opus 4.8 on MCP Mark Verified (81.1 vs 76.4) but trails GPT-5.5 (92.9). On single-shot coding it stays behind both. All six benchmarks are Moonshot-run, with no SWE-bench or LiveCodeBench entries at launch.
The pattern is consistent across Moonshot's table: K2.7 narrows the gap on multi-step and MCP-heavy tasks while the closed models keep a clear margin on isolated code generation. If your workload is agentic — planning, file edits, repeated tool calls — the ranking matters less than it does for one-pass completions.
| Benchmark | K2.7 Code | Opus 4.8 | GPT-5.5 |
|---|---|---|---|
| Kimi Code Bench v2 | 62.0 | 67.4 | 69.0 |
| Program Bench | 53.6 | 63.8 | 69.1 |
| MCP Atlas | 76.0 | 81.3 | 79.4 |
| MCP Mark Verified | 81.1 | 76.4 | 92.9 |
Read these numbers with a caveat. Every score comes from Moonshot-controlled suites — Kimi Code Bench v2, Kimi Claw 24/7 Bench, MCP Atlas, and MCP Mark Verified — which the card says will be open-sourced but are not yet public . At the June 2026 launch there were no entries on the standard third-party boards:
- No SWE-bench Verified or SWE-bench Pro result.
- No Terminal-Bench 2.0 submission.
- No LiveCodeBench entry — and HighSpeed mode shipped while independent benchmarking was skipped .
That gap drew a blunt assessment. As one analysis put it, the model "grades its own homework," beating a previous version on tests no outside lab has yet reproduced .
The concrete takeaway: the weights, the Modified MIT license, and the $0.95/$4.00 list pricing are all checkable today . The capability claims are not. If you run high-volume agentic or MCP workloads where output tokens dominate the bill, K2.7 is worth a pilot now — but benchmark your own tasks against Opus 4.8 and GPT-5.5 rather than trusting the vendor table, and revisit once SWE-bench and LiveCodeBench numbers land.
Frequently asked questions
Can I disable reasoning mode in Kimi K2.7 Code?
No. Thinking mode is mandatory and cannot be turned off, and sampling is fixed at temperature 1.0 and top_p 0.95 . There is no per-call override path: tool_choice is limited to auto or none, so you cannot trade reasoning tokens for latency on individual requests. Budget for that overhead on every call.
What happens when a task needs more than 32K tokens of output?
K2.7 truncates at its maximum output of 32,768 tokens . Tasks that exceed that ceiling — full-file rewrites, large scaffolding, bulk migrations — require multi-pass workflows that chunk the work and stitch results together. For comparison, both GPT-5.5 and Claude Opus 4.8 list 128K maximum output , so single-call long generations stay on the closed frontier.
Does the 12× cheaper claim hold across all workloads?
No. The 12× figure compares K2.7's $4.00 per 1M output tokens to Claude Fable 5's $50.00 per 1M — a best-case ceiling against the most expensive Claude tier . Against Claude Opus 4.8 the gap narrows to roughly 6× on output . Mandatory reasoning overhead, the 32K output cap, and cache-hit rates can all inflate effective per-task cost beyond the list comparison.
What does the Modified MIT license require at scale?
Code and weights ship under a Modified MIT License, not plain MIT. Products or services exceeding 100M monthly active users or $20M in monthly revenue must prominently display "Kimi K2.7 Code" in their UI . Standard MIT carries no attribution-in-product requirement, so high-scale coding-agent and IDE vendors should review this clause before redistribution.
Has K2.7 Code been evaluated on public benchmarks like SWE-bench?
Not at launch. Every published score uses Moonshot's in-house suites — Kimi Code Bench v2, Kimi Claw 24/7 Bench, and MCP Mark Verified — with no entries on SWE-bench Verified, Terminal-Bench 2.0, or LiveCodeBench as of June 2026 . Outlets have flagged this "grades its own homework" gap , so treat capability claims as unverified until third-party results land.
