KIMI
K2.7 CODE

What Is Kimi 2.7 Code?

Kimi 2.7 code - officially Kimi K2.7 Code - is Moonshot AI's newest open-weight large language model, released on June 12, 2026. It is not a general-purpose chatbot. It is a coding-focused, agentic model built directly on top of Kimi K2.6, and it is engineered for one job above all others: long-horizon software engineering. Where a conventional assistant answers a single question, K2.7 Code plans a task, edits files, runs shell commands, calls tools, inspects the results, and debugs its own work across many steps - the way a junior engineer works through a ticket rather than firing off a one-line reply.

Two claims define the release. The first is capability: across Moonshot's coding and agentic suites, K2.7 Code clearly outperforms its predecessor. The second is efficiency: it reaches that higher performance while spending roughly 30% fewer "thinking" tokens than K2.6. In a world where autonomous coding runs can burn millions of output tokens, a 30% reduction in reasoning overhead is not a footnote - it is a direct line item on the bill.

Under the hood it is a Mixture-of-Experts (MoE) design with 1 trillion total parameters but only 32 billion active per token, so it computes far less than a dense trillion-parameter model would on each forward pass. It is natively multimodal - accepting text, image, and even video input - which is unusual for a coding-first model. It runs exclusively in forced thinking mode (there is no "instant" path), and it ships under a permissive Modified MIT license. One naming caveat worth knowing: at launch there is no general-purpose "Kimi K2.7" or "Instruct" sibling - the Code variant is the whole story for now, tuned for engineering rather than broad chat.

Crucially, the model never ships alone. It is paired with Kimi Code, Moonshot's open-source terminal coding agent - the same model-plus-CLI strategy Anthropic runs with Claude Code. That pairing is the real headline: Moonshot is shipping a full coding platform, not just a set of weights.

Kimi K2 7 Code on GitHub

Anyone researching Kimi k2 7 code github quickly discovers that the release has two open-source halves, and the GitHub side is just as important as the weights. The model is only half the story; the other half is Kimi Code CLI, Moonshot's terminal-first coding agent and a direct competitor to Claude Code and Gemini CLI. The CLI has been rewritten in TypeScript and is distributed via npm, and it runs autonomous, multi-step workflows entirely from the terminal: reading and editing code, executing shell commands, searching files, and fetching web pages.

What makes the agent more than a thin wrapper is its sub-agent architecture. Kimi Code CLI ships with built-in coder, explore, and plan sub-agents that each run in isolated contexts, so a large task can be decomposed - explore the codebase, plan the change, then write it - without the context bleed that plagues single-thread agents. Both the code repository and the model weights are released under the Modified MIT license, which is what keeps the self-host path open for commercial teams.

The community moved fast around the GitHub ecosystem. Within days of launch, integration guides and configuration repositories appeared for wiring K2.7 Code into the tools developers already use:

• Claude Code - point it at the Moonshot endpoint and swap the model.
• Cline and Roo Code - popular VS Code agent extensions.
• OpenCode - start it and switch model with /models.
• Aider - for quick edits, git-aware workflows, and model comparisons.

For local serving, the repositories document the standard one-liners: vllm serve "moonshotai/Kimi-K2.7-Code" or the SGLang launch server, both exposing an OpenAI-compatible endpoint. A practical tip surfaced repeatedly across these projects: configure a project daily spending budget in the Kimi Platform dashboard, and set tool_choice to auto or none to keep autonomous agent loops from quietly consuming excess credits. If you run K2.7 Code locally, you can even point Kimi Code CLI at your own instance - kimi config set api.base-url http://localhost:8000/v1 - for the full agent experience at zero per-token cost.

It's worth understanding why the CLI matters so much for this particular model. Generic wrappers pass conversation history between turns - they give the model what was said. Kimi Code CLI is built to expose K2.7 Code's preserve-thinking and native multi-step tool calling, so it gives the model what it was reasoning about. In practice that means a request like "find every API endpoint without rate limiting and add it" can resolve in a single model turn - explore, plan, patch, test - rather than six separate exchanges, each with its own round-trip. For complex tasks, that native multi-step execution translates into several times fewer API calls than a turn-by-turn tool like Aider would make, which is both faster and cheaper. The repeated community recommendation is to use Kimi Code CLI for complex, multi-file work where reasoning coherence matters, and to reach for a lighter tool only for quick one-off edits.

Kimi K2 7 Code Benchmarks

The Kimi k2 7 code benchmarks are the reason the release got so much attention. Moonshot's announcement leads with three headline deltas over K2.6: +21.8% on Kimi Code Bench v2, +11.0% on Program Bench, and +31.5% on MLS Bench Lite, alongside the roughly 30% reduction in reasoning-token usage. In raw scores, K2.7 Code lifts Kimi Code Bench v2 from 50.9 to 62.0, Program Bench from 48.3 to 53.6, and MLS Bench Lite from 26.7 to 35.1 - the last of which essentially catches up to GPT-5.5 in a single generation.

The single most striking result is on tool use. On MCP Mark Verified, which measures whether a model correctly invokes tools across real server environments, K2.7 Code scores 81.1 - ahead of Claude Opus 4.8's 76.4. For agentic, tool-driven workflows - CI checks, ticket updates, and file edits in one loop - an open-source model out-pointing a closed flagship is the genuine highlight of the launch.

It helps to understand what each benchmark actually measures:

• Kimi Code Bench v2 - Moonshot's in-house suite of realistic software-engineering tasks across 10+ languages and a full production stack: backend, infrastructure, performance, systems, security, frontend, and ML/data.
• Program Bench - 200 tasks that ask an agent to recreate a program's behavior from only a compiled binary and its documentation, judged against 248,000+ fuzz-generated tests, with no source or internet access.
• MLS-Bench-Lite - the 30-task official subset of MLS-Bench, testing whether AI can invent generalizable ML methods, with a 5-hour exploration budget per task.
• Kimi Claw 24/7 Bench - an in-house long-horizon agentic test across 17 professional scenarios and 610 evaluation points.
• MCP Atlas and MCPMark-Verified - realistic tool-use suites spanning Notion, GitHub, Filesystem, Postgres, and Playwright.

One honest qualifier belongs on every benchmark conversation: all of these are Moonshot's own suites, run under its own harness (Kimi Code CLI in thinking mode at temperature 1.0, top-p 0.95, 262,144-token context, with GPT-5.5 in Codex xhigh and Opus 4.8 in Claude Code xhigh). They are best read as vendor-reported and directional, not independently confirmed.

The benchmark that arguably matters most for production isn't in the accuracy table at all - it's the token-efficiency result. K2.7 Code's roughly 30% reduction in reasoning-token usage versus K2.6 is the figure that quietly governs cost on real workloads, because for agentic coding the output (reasoning) tokens dominate the bill. Concretely: a long autonomous run that previously consumed around 2 million reasoning tokens now uses closer to 1.4 million, and critically, that efficiency gain does not come at the expense of quality - the accuracy scores went up at the same time. Stack the ~30% fewer tokens on top of an output price of $4.00 per million, and a heavy agentic session gets cheaper twice over: fewer tokens billed, and each token already priced well below the closed flagships. That compounding is the real economic story behind the headline accuracy deltas.

Kimi K2 7 Benchmark - Reading the Numbers

Because Moonshot's figures are first-party, the most useful thing a Kimi K2 7 benchmark guide can do is explain how to interpret them and what to watch for next. As of mid-June 2026, there are no independent third-party numbers for K2.7 Code on the standard public suites - no SWE-bench Verified, SWE-bench Pro, Terminal-Bench, LiveCodeBench, GPQA Diamond, AIME, or MMLU-Pro. That absence does not mean the model is weak; it means the public evidence is still arriving.

So how should you weigh the claims? First, treat the deltas over K2.6 as the most trustworthy signal - they were measured under identical conditions on the same harness, so the relative improvement is meaningful even if the absolute numbers later move on neutral suites. Second, give extra weight to the MCP tool-use results, because those map directly to the agentic work the model is actually sold for. Third, discount cross-vendor comparisons slightly: different models ran in different harnesses (Codex xhigh, Claude Code xhigh), and harness choice shifts results.

The fastest-moving independent signal right now is not a leaderboard at all - it is community testing. Within 48 hours of launch, creators published hands-on video reviews running K2.7 Code locally, clustered, and in the cloud against Claude, and developers shared head-to-head impressions on forums. Until neutral suites publish, that practical testing is the best proxy for real-world behavior.

Watch for SWE-bench Verified, Terminal-Bench, and LiveCodeBench results from third parties over the coming weeks. When those land, you'll know whether K2.7 Code's first-party story holds up under neutral conditions - and they're the figures any serious adoption decision should ultimately wait for.

Kimi K2 7 Code Size & Architecture

When people search Kimi k2 7 code size, they usually mean two different things: the parameter count and the on-disk footprint. Both matter, and they're not the same number. On parameters, K2.7 Code is a 1-trillion-parameter Mixture-of-Experts model that activates only 32 billion parameters per token. That sparsity is the entire trick: you get the representational capacity of a trillion-parameter model while paying roughly the compute of a 32B model on each forward pass.

The full architecture, straight from the official model card, looks like this:

• 61 layers total, including a single dense layer.
• 384 experts, with 8 selected per token plus 1 shared expert.
• Attention hidden dimension of 7,168; MoE hidden dimension of 2,048 per expert.
• 64 attention heads using MLA (Multi-head Latent Attention).
• SwiGLU activation; 160K vocabulary.
• 256K context length (262,144 tokens).
• A MoonViT vision encoder adding 400M parameters for image and video input.

On disk, the published weights register at roughly 1.1T parameters in mixed precision - the HuggingFace files page lists BF16 alongside F32 and I32 tensors. The detail that makes K2.7 Code far lighter to run than a naive trillion-parameter model is its quantization design: the MoE weights are stored in native INT4 (via quantization-aware training) while attention stays in BF16. This isn't lossy post-hoc compression bolted on afterward; the model was trained with INT4 in mind, which is why high-quality INT4 inference loses almost nothing and why the practical memory bill is a fraction of the FP16 figure. In short: the parameter count is enormous, but the size that actually determines whether you can serve it is the quantized footprint - and that's where the next section comes in.

Kimi K2 7 Code on Hugging Face

The canonical home for Kimi k2 7 code huggingface is the repository moonshotai/Kimi-K2.7-Code, with a mirror on ModelScope. The model card is the single source of truth for the architecture, the full benchmark table, the deployment notes, and the chat template - if you only read one external page about K2.7 Code, make it that one. The repo is tagged as image-text-to-text, ships as safetensors, and is released under the Modified MIT license.

HuggingFace also lays out every practical way to actually run the thing. With Transformers, you can load it directly - AutoModel.from_pretrained("moonshotai/Kimi-K2.7-Code", trust_remote_code=True) - or use the high-level image-text-to-text pipeline. For serving, the card documents vLLM (vllm serve "moonshotai/Kimi-K2.7-Code"), SGLang, and a one-line Docker Model Runner path (docker model run hf.co/moonshotai/Kimi-K2.7-Code).

For developers who don't have data-center hardware, the most important HuggingFace detail is the community quantizations. The model page links GGUF builds for llama.cpp, Ollama, LM Studio, and Jan - the realistic route to running K2.7 Code on more modest setups. The page also exposes hosted options: Inference Providers (such as Novita), a HuggingChat entry, and several community Spaces demoing the model. If you'd rather not download anything, those let you try it in the browser first.

A quick orientation for the repo's tabs: Model card for documentation, Files and versions for the raw safetensors and config, and Community for discussions and issues. Note the transformers version requirement - >=4.57.1, <5.0.0 - which trips up people who try to load the weights on an older install. K2.7 Code shares its architecture with K2.5/ K2.6, so existing deployment recipes for those models port over almost directly.

Kimi K2 7 Code Requirements

Here is where enthusiasm meets reality. The honest answer to Kimi k2 7 code requirements is that this is a demanding model to self-host, and for most developers the API will be the right call. Let's separate software from hardware.

Software is the easy part. K2.7 Code runs on three recommended inference engines: vLLM, SGLang, and KTransformers (Moonshot's own engine, with native INT4 support and the tightest integration with the K2 architecture). You need transformers >=4.57.1, <5.0.0. The API is OpenAI- and Anthropic-compatible, so most existing tooling works with nothing more than a base-URL and model-ID swap.

Hardware is where the trillion-parameter scale shows up. Because memory is the binding constraint, the precision you choose dictates the rig you need. Independent estimates for peak inference VRAM (weights, activations, and KV cache, with a little production headroom) come out roughly as:

• FP16 (full precision): ~2,300 GB of VRAM - beyond a single 8-GPU node, so a multi-node cluster.
• INT8 (Q8): ~1,150 GB - multiple high-end GPUs.
• INT4 (Q4): ~577 GB - roughly 8× A100 80GB, rentable in the cloud from around $6/hour.

A useful rule of thumb carried over from the K2 line: your combined RAM + VRAM should roughly equal the quantization file size. With aggressive dynamic 2-bit GGUF quants, some people get the model running on around 350 GB of combined memory - a high-RAM DDR5 CPU build or a multi-GPU rig plus system RAM - but expect single-digit tokens per second and reduced quality at that extreme.

The pragmatic takeaway: self-hosting only makes economic sense if you push tens of millions of tokens a month, or your data genuinely cannot leave your machines. A purpose-built local rig for K2.7 Code costs more than a used car; a $0.95-per-million-token API call does not. If you do go local, native INT4 plus KTransformers is the sweet spot - and cloud GPU rentals are the sensible way to test before committing to hardware.

Kimi K2 7 Code on Reddit & Developer Forums

The community reaction has been loud and, predictably, mixed. Scanning the Kimi k2 7 code reddit threads and other developer forums in the days after launch, a handful of themes recur consistently:

• Praise for open-sourcing a near-frontier coding model. Many developers see K2.7 Code as the strongest open-source coding agent you can actually run yourself, and the MCP Mark Verified result against Opus 4.8 drew particular attention.
• The efficiency angle landed. Teams running long autonomous sessions care more about the ~30% reduction in reasoning tokens than about a benchmark point or two - it shows up directly in their monthly spend.
• Skepticism about speed. Some users found earlier Kimi models sluggish; the promised 6× High-Speed Mode is Moonshot's answer, but it wasn't live at launch, so the complaint stands for now.
• Caution on the benchmarks. The more experienced commenters flag that the numbers are all first-party and explicitly want to see independent SWE-bench-style results before fully buying the comparisons.

A common workflow heuristic also emerged quickly across these discussions: use K2.7 Code for easy and standard-difficulty coding, and reserve the most expensive closed models for the genuinely hard problems. One widely-shared summary put it as using Kimi 2.7 for easy coding tasks, a closed flagship for standard work, and the very top-tier closed models only for ultra-hard coding.

In other words, the verdict is real enthusiasm tempered by a healthy "prove it on neutral ground" reflex - which is exactly the right posture for a brand-new model whose published numbers are all vendor-run. If you're evaluating it yourself, the forum consensus is unanimous on one point: spend an afternoon testing it on your own codebase before drawing conclusions from anyone else's benchmark, including Moonshot's.

Should You Use Kimi K2.7 Code?

Pulling every thread together: Kimi K2.7 Code is the most interesting open-source coding release of mid-2026. It is fast to adopt thanks to an OpenAI- and Anthropic-compatible API and the model ID kimi-k2.7-code; it is genuinely strong at agentic tool use, beating Claude Opus 4.8 on MCP Mark Verified; it is meaningfully cheaper than the closed flagships at $0.95 input and $4.00 output per million tokens; and it is backed by real open weights under a Modified MIT license that you can download and self-host. The asterisks are equally real: the benchmarks are first-party for now, the context window tops out at 256K, the hardware demands for local serving are steep, reasoning is always on with no cheaper non-thinking path, and raw speed is still catching up to the promised High-Speed Mode.

For a coding- and tool-heavy team, the calculus is simple. If you want near-frontier agentic performance at a fraction of closed-model cost, run K2.7 Code through the API or a Kimi Code membership starting at $19/month. If you have hard data-residency constraints and the hardware budget, the open weights let you keep the whole pipeline in-house. And if you only ever need the single best answer on the hardest problems regardless of price, you'll still reach for the closed flagships some of the time - which is precisely how most practitioners are already describing their day-to-day workflow. The one move that beats all the reading: grab a key, point Kimi Code CLI at it, throw a real multi-file task at it, and let your own repository be the benchmark.