Kimi K2.6 正式发布开源权重：万亿参数多智能体编程模型详解

Dark Side of the Moon officially releases and open-sources Kimi K2.6, featuring long-horizon autonomous coding and agent cluster capabilities. With a trillion-parameter MoE architecture activating only 32B, it is the first open-source model among domestic large models to possess full multi-agent collaborative programming capabilities.

The Dark Side of the Moon officially released Kimi K2.6 today and simultaneously open-sourced the model weights. This marks another major iteration of the Kimi series in programming and agent capabilities, following K2.5 at the end of January this year.

Straight to the point: K2.6’s core selling point isn’t that its benchmark scores improved slightly, but that it attempts to answer a much bigger question—can an AI model work like a true engineering team, autonomously handling complex programming tasks over long periods and across multiple roles?

From code-preview to the official release: what happened in the past half month

If you’ve been keeping up with developments in Chinese AI models, K2.6 shouldn’t be unfamiliar. On April 13th, The Dark Side confirmed via official email to Beta testers that the model they were using was K2.6-code-preview. That version was quite low-key—there was hardly any official promotion, though Kimi Code members (from ¥39/month) could get early access.

Early community feedback gave some clues. Some testers said its “chain of thought has an Opus-like style”—high praise in developer circles—meaning the model’s reasoning when tackling complex problems isn’t mechanical or templated, but layered, reflective, and self-correcting.

From the code-preview to today’s official release, The Dark Side of the Moon clearly made a lot of adjustments. The official version is no longer limited to coding tasks—it elevates long-horizon execution and agent swarms to first-class native capabilities.

Trillion parameters, 32B activated: same architecture, new capabilities

K2.6 continues the K2 series’ MoE (Mixture of Experts) architecture:

Total parameters: 1 trillion (1T)
Activated parameters: 32 billion (32B)
Number of experts: 384, 8 activated per token
Context window: 256K tokens
Layers: 61 (including 1 dense layer)
Attention mechanism: MLA (Multi-head Latent Attention)
Activation function: SwiGLU
Vocabulary size: 160K

The architecture remains the same as K2/K2.5, indicating that K2.6’s improvements mainly come from training data, strategy, and post-training optimization—not from parameter inflation. For developers looking to deploy or fine-tune locally, that’s good news: inference cost is similar to K2.5, and a 32B activated size is runnable on mainstream hardware.

One notable detail is the MuonClip optimizer—The Dark Side of the Moon’s self-developed optimization method addressing attention explosions and loss spikes commonly seen in large-scale MoE training. The K2 series was pre-trained on 15.5 trillion tokens with stable performance throughout—this optimizer deserves credit.

Three genuinely noteworthy capabilities

1. Long-Horizon Coding

This is the capability that made users’ hearts race—according to community comments.

Traditional AI coding assistants are essentially “Q&A machines”: you give it a function signature, it completes it; you paste an error message, it fixes it. The interaction is fragmented and the context short-lived.

Long-horizon coding tackles a higher-level problem: give the model a requirement description (e.g., “add an OAuth2 authentication module to this Python project”), and it must autonomously read the codebase, understand the architecture, plan the implementation, write code, run tests, and fix bugs based on test results—all without human intervention—for potentially tens of minutes or longer.

That’s fundamentally different from tools like Claude Code or Cursor, which act more like advanced autocompletion assistants; long-horizon coding is more like adding a junior developer to your team.

Technically, this relies on several key improvements:

Deeper reasoning chains: the model can think through longer steps before answering.
Reliable multi-step tool use: greatly reduced error rates when consecutively using file I/O, terminal commands, searches, etc.
Better agent planning: tasks are decomposed into reasonable subtask sequences instead of written blindly in one go.

2. Agent Swarms

If long-horizon coding makes a single agent stronger, agent swarms make multiple agents collaborate.

The concept emerged in K2.5, but K2.6 takes it further. The official blog mentions Claw Groups, a research-preview feature allowing multiple AI agents to work in parallel—each handling a different subtask—then merge results.

Example scenario: refactoring the database layer of a microservice project from MySQL to PostgreSQL. In Agent Swarms mode, one agent might analyze SQL queries and ORM mappings, another generates PostgreSQL-compatible code, and a third writes and executes migration tests. They share information but progress independently.

This adds value because complex engineering tasks are inherently parallelizable—many agents working simultaneously is more efficient than one working sequentially. Of course, coordination is challenging—avoiding conflicts, merging outputs, and managing errors are tough engineering problems.

3. Proactive Agents

Traditional AI assistants are reactive—they answer only when asked. K2.6 introduces Proactive Agents to break this pattern: the model proactively detects issues, suggests improvements, and adjusts plans while executing tasks.

For instance, if it notices that the current implementation may cause a performance bottleneck, it won’t just finish coding and report later—it pauses mid-process, explains the issue, and proposes alternatives. This behavior is more like a seasoned engineer than an instruction follower.

Benchmarks: useful, but take with salt

The community has grown healthily skeptical of domestic benchmark results—“each time they come out punching Claude and kicking GPT, then get criticized weeks later,” as one developer put it.

Still, here’s what we know:

K2.5 SWE-Bench Verified: 76.8%
K2.5 LiveCodeBench: 85%
K2 xbench-ScienceQA: 49.6 (ranked #1 among Non-Thinking models)
K2 BoN(N=5): 73.0, tied second with Doubao Seed-1.6 among Chinese models

Official K2.6 benchmarks aren’t fully published yet, but third-party testing from the code-preview stage showed coder Versun rated its coding ability at 89 (vs 83 for K2.5)—a 6-point gain. The consensus is that K2.6 roughly matches Claude Sonnet 4.6.

Note: there’s no comparison with GLM-5/GLM-5.1, which has raised community concern. Given that Zhipu’s GLM-5.1 is a strong competitor recently released, that omission weakens the evaluation’s credibility.

Additionally, xbench, under Sequoia Capital, offers a broader view: in ScienceQA rankings, K2 leads non-thinking models, but still lags behind thinking models (e.g., Grok-4 at 65.0, o3 at 60.8). Clearly, the K2 series excels in fundamentals but needs a “Thinking” variant for deep reasoning.

Where does K2.6 stand among competitors

China’s AI model landscape in April 2026 is beyond competitive—consider just the past week:

Zhipu released and open-sourced GLM-5.1
MiniMax launched and open-sourced 2.7
Xiaomi’s MiMo-V2-Flash continues its iterations
DeepSeek V3.2 series (including Thinking and Speciale versions) dominates open-source inference models

Within this crowded field, K2.6’s differentiation is clear: it isn’t trying to be the “smartest” model—it’s aiming to be the “most capable worker.”

Specifically:

| Dimension | Kimi K2.6 | DeepSeek V3.2 | GLM-5.1 | Claude Sonnet 4.6 | |------------|------------|---------------|----------|--------------------| | Architecture | MoE 1T/32B | MoE | Dense | Dense (closed-source) | | Core strength | Multi-agent programming | Deep reasoning | Multimodal | Coding + long context | | Open source | Weights open | Weights open | Weights open | Closed | | Context length | 256K | 128K | 128K | 1M | | Agent features | Native support | Tool use | Tool use | Claude Code ecosystem |

K2.6’s moat lies in pretraining agentic capabilities directly into the model. The Dark Side developed an internal agent-simulation pipeline covering hundreds of scenarios and thousands of tools, meaning tool-use capability is innate, not added post-training. Officially, tool-call accuracy is near 100%, with a built-in Token Enforcer to ensure correct formatting.

This approach parallels xAI’s Grok-4, which also embeds native tool-use during pretraining—except Grok-4 is closed-source, while K2.6 is open-source.

The significance of open-sourcing: more than “just downloadable”

The open-sourcing of K2.6 weights may contribute more value to the developer community than its performance gains alone.

Currently released versions:

Kimi K2.6-Base: raw foundation model
Kimi K2.6-Instruct: instruction-tuned version

Both are non-reinforced-learning (Non-Thinking) models—meaning the community can perform their own RL training, DPO alignment, domain fine-tuning, etc. Since the K2 series is compatible with Anthropic’s API format, migration and integration have a low barrier.

For teams building AI programming toolchains, a trillion-parameter model with native agentic capabilities and open weights greatly expands possibilities. Before, you might only work within the Claude Code ecosystem—now you can use K2.6 weights to set up fully self-controlled coding agent systems.

Of course, deploying trillion-parameter models isn’t cheap—even with only 32B activated, loading full weights demands substantial GPU memory. For small teams, API access remains more practical. Currently, Kimi’s Coding Plan starts at ¥39/month—quite cost-effective among domestic options. If you prefer managing multiple models via a unified API interface, aggregation platforms like OpenAI Hub already support the Kimi series.

A few sober questions

Long-horizon coding still needs large-scale real-world verification. Every developer who’s tried AI coding tools knows the gap between demos and reality. High SWE-Bench scores don’t guarantee stability in your legacy-ridden monorepo.
Agent swarms are still in research-preview stage. The maturity, stability, and applicable scenarios of Claw Groups will take time to prove. Multi-agent collaboration is exponentially more complex—state sync, conflict resolution, fault recovery—these go beyond sheer model power.
Incomplete benchmarking. No comparisons with GLM-5.1 or DeepSeek V3.2 in programming use-cases make it hard to judge K2.6’s true ranking among Chinese models. More independent third-party data is needed.
When’s the Thinking version coming? xbench data shows a clear gap between Non-Thinking and Thinking models. K2.5 already had a Thinking variant, so K2.6’s should be on the way—and that may ultimately define its ceiling.

Final thoughts

In one sentence: K2.6 is the first domestic model that seriously tries to answer “Can AI replace a junior engineer?”

Not that it’s fully there yet—but both its product vision and technical route point clearly toward that goal. Long-horizon coding, multi-agent collaboration, proactive planning—combined, these form an AI system capable of independently undertaking engineering work, not just smarter code completion.

Whether it can fulfill that promise—let’s wait for real feedback from the community. After all, benchmarks are benchmarks; doing the job is what really counts.

References: