Kimi K2.7 Code

Moonshot AI’s Kimi K2.7 Code is a 1-trillion-parameter Mixture-of-Experts model built specifically for agentic coding and software engineering. It activates only 32 billion parameters per token — 32B out of 1000B total — making it a sparse, compute-efficient architecture for long-horizon tasks like end-to-end code generation, refactoring, and autonomous debugging.

As the successor to K2.6, K2.7 Code delivers substantial benchmark gains: +21.8% on Moonshot’s in-house Kimi Code Bench v2 (62.0 vs. 50.9), +11.0% on Program Bench, and +31.5% on MLS Bench Lite. It also reduces reasoning token usage by roughly 30%, getting to answers faster. The model handles text, images, and video input, supports a 262,144-token context, and always operates in thinking mode.

K2.7 Code is released under a Modified MIT License — open weights that you can inspect, fine-tune, and deploy. It’s positioned as a direct competitor to closed coding agents like GPT-5.5 and Claude Opus 4.8, but with the transparency and control that local-first practitioners demand.

K2.7 Code uses a sparse MoE layout with 384 experts, of which 8 are selected per token plus 1 shared expert. The total parameter count is 1T, but only 32B are active at any inference step. This means:

• Memory is the bottleneck: You need to load all 1T parameters into VRAM. At FP16 that’s ~2 TB; even at 4-bit quantization expect ~500 GB. This requires multi-GPU setups (e.g., 8× A100 80 GB or 4× H100).
• Compute is light: With only 32B active parameters per forward pass, throughput can be high once the model is loaded. Tokens-per-second will be dominated by memory bandwidth and expert routing overhead.
• Efficient attention: Uses Multi-head Latent Attention (MLA) and SwiGLU activation to reduce memory overhead during generation.

The model includes a 400M-parameter MoonViT vision encoder, enabling multimodal understanding for image and video inputs. The context window is 262,144 tokens — enough for large code repositories, entire documentation sets, or long conversation histories.

K2.7 Code is specialized for agentic coding workflows — tasks that require multi-step reasoning, tool use, and interaction with the filesystem and shell. It excels at:

• End-to-end software engineering: Write, debug, and refactor entire codebases. The model can spawn subagents for parallel work, fetch web documentation, and execute shell commands.
• Long-horizon tasks: Automate large refactors, migrate frameworks, or patch security vulnerabilities across many files.
• Function calling and MCP: Works with the Model Context Protocol (MCP) for tool integration. Scores 81.1 on MCP Mark Verified, indicating reliable agent orchestration.
• Code reasoning: Always operates in thinking mode, which helps with complex logic like algorithm implementation, system design, and test generation.
• Multilingual and multimodal: Supports chat in multiple languages and can analyze images (diagrams, UI mockups) and video (walkthroughs, demos).

Because it’s open weight, you can fine-tune it on your own codebase or domain-specific rules. The Kimi Code CLI (available via curl install) provides a ready‑to‑use terminal interface that wraps K2.7 Code with file I/O, search, and subagent spawning capabilities.

Running a 1T-parameter model locally demands serious hardware. Here’s what you need to know:

• Full precision (FP16): ~2 TB VRAM. Practical only with server-grade GPU clusters (e.g., 8× H100 or 16× RTX 6000 Ada).
• 4-bit quantization (Q4_K_M): ~500 GB. Still requires 6–8 consumer GPUs if you have that many, or 2–4 enterprise GPUs.
• 2-bit quantization (Q2): ~250 GB. Feasible on 4× RTX 4090 (24 GB each) with careful offloading, but quality tradeoffs are unknown.
• Active parameters only: The sparse activation (32B) helps compute but not memory — the full 1T must be resident.

Unless you have a multi-GPU workstation or cloud GPU cluster, consider:

• Use the Kimi Code CLI (cloud-hosted) — it provides the same agentic interface without hardware requirements.
• Rent a multi-GPU instance from a provider that supports custom Docker images with vLLM or TensorRT-LLM.
• Watch for smaller distilled versions — no official ones yet, but the community may release quantized or adapted models.

With a proper multi-GPU setup using 8× H100, you can expect 50–100 tokens per second for text generation, depending on batch size and context length. The 30% reduction in reasoning tokens means fewer output tokens per task compared to K2.6.

K2.7 Code competes directly with other open-weight coding models, but its scale is unique. Here’s how it stacks:

Choose K2.7 Code if: You need a powerful open coding agent for complex, multi-file, long-context tasks and have access to multi-GPU infrastructure. Its sparse 32B active parameters keep inference fast once the model is loaded.

Choose a smaller model (e.g., Qwen2.5-Coder-32B) if: You’re limited to a single consumer GPU. You’ll lose some agentic capability but gain deployability.

Benchmark caveat: All K2.7 Code scores are from Moonshot’s own benchmarks. Independent evaluations on SWE-bench or Aider are not yet available, so treat the numbers as indicative rather than definitive.