Moonshot AI released Kimi K2.6 on April 20, 2026 — the direct successor to K2.5's Agent Swarm architecture. Where K2.5 introduced parallel sub-agent orchestration as a concept, K2.6 scales it: 300 sub-agents and 4,000 coordinated steps per autonomous run, up from 100 and 1,500. The practical ceiling isn't a theoretical number — the model has been tested running continuously for 12+ hours on real engineering tasks, across Rust, Go, and Python codebases, handling frontend generation, DevOps scripting, and performance optimization in the same session.

The model is released under Modified MIT license with weights on HuggingFace. It runs on 4×H100 in INT4 — a deliberate engineering choice that makes the full-scale swarm capability accessible without eight-card infrastructure.

What's New: Agent Swarm 3×, Long-Horizon Coding

What's New

The headline upgrade is the scale of the agent swarm. K2.5 launched with 100 parallel sub-agents and 1,500 total tool calls per run. K2.6 raises both: 300 sub-agents and 4,000 coordinated steps. The orchestrator decomposes complex prompts into parallel, domain-specialized subtasks and manages the full lifecycle from initiation through synthesis.

The practical demonstration: K2.6 can be given a single prompt and respond by coordinating 100+ files across a complete project. The orchestration logic — which sub-agents to create, what tools to assign, how to synthesize outputs — remains trained capability (via PARL, the Parallel-Agent RL framework introduced in K2.5), not prompted workflow.

Four new capability areas beyond raw swarm scaling:

Long-horizon coding. Execution runs exceeding 4,000 tool calls and 12 continuous hours, with language generalization across Rust, Go, and Python. Tasks include frontend generation, DevOps automation, and performance optimization — not just isolated algorithmic problems.

Motion-rich frontend generation. Video hero sections, WebGL shaders, GSAP and Framer Motion integration, Three.js 3D — K2.6 can generate production-ready interactive interfaces from text prompts or visual mockups. Coding-driven design is a first-class use case, not a demo.

Proactive agents. K2.6 powers 24/7 background agents (OpenClaw, Hermes Agent, and similar) that execute tasks without active user sessions. The architecture supports persistent agent execution that operates outside chat session boundaries.

Claw Groups (research preview). A multi-agent coordination layer allowing users to combine their own agents, other users' agents, and human collaborators in shared workflows. Still in preview, but signals the direction: cross-boundary agent coordination, not just single-user orchestration.

Architecture: MoE at 1T, Native INT4 QAT

Architecture

K2.6 inherits K2.5's core architecture with targeted improvements for the long-horizon use case.

Model specs:

Spec Value
Total parameters 1 trillion
Active parameters per token 32 billion
Layers 61 (including 1 dense layer)
Expert count 384 routed + 1 shared
Experts per token 8 routed + 1 shared
Attention MLA (Multi-head Latent Attention)
Activation SwiGLU
Context window 262,144 tokens (256K)
Vision encoder MoonViT, 400M parameters
Vocabulary 160K tokens

The key infrastructure addition over K2.5 is native INT4 QAT (Quantization-Aware Training). Rather than post-training quantization, K2.6 bakes INT4 into the training process — the same approach used in Kimi K2 Thinking. The result: INT4 weights come in at approximately 594 GB versus ~2 TB for FP16, and quality degrades minimally because the model was trained for INT4 from the start.

Hardware requirements:

Precision Minimum GPUs
INT4 (native QAT) 4×H100 80GB
FP16 8×H100 80GB

Supported inference frameworks: vLLM, SGLang (v0.5.10+), KTransformers — all with OpenAI-compatible APIs.

Note on vision: the MoonViT encoder handles image and video inputs internally (native multimodal architecture, continuous joint training with text), but image input is not exposed as a direct API parameter. Vision capabilities are used by the model's internal reasoning; external developers cannot pass image tokens directly via the API endpoint.

Benchmarks: Agentic SOTA, Math Trails Competitors

Benchmarks

K2.6's benchmark profile reflects its design priority: agentic and coding tasks are where it leads, pure math reasoning is where it doesn't.

Agentic:

Coding and Engineering:

Vision:

Reasoning (where K2.6 trails):

The HLE-Full number (54.0% with tools) clears every competitor in the comparison — including K2.5 which had HLE 50.2%. The SWE-Bench Pro score (58.6%) is comparable to Qwen3.7-Max (60.6%) and GLM-5.1 (58.4%) — the three models are effectively trading the top spot depending on benchmark variant and scoring conditions.

The math reasoning gap is real and consistent: K2.6 loses to GPT-5.4, Gemini 3.1 Pro, and Claude Opus 4.6 on AIME, HMMT, and GPQA. This tracks with the training priority — the model is explicitly optimized for agentic execution and coding, not isolated reasoning chains.

Access and Availability

K2.6 is available through multiple channels:

The Modified MIT License differs from K2.5's plain MIT — read the license file on HuggingFace for commercial use terms before deploying in production.

What It Means for Developers

The 300-agent / 4,000-step ceiling matters less as an absolute limit than as a signal about what the model is designed to sustain. K2.5 proved the PARL training approach worked. K2.6 proves it scales — and that the capability is stable enough to push to 3× the sub-agent count without orchestration breakdown.

For developers building production agent systems, the INT4 QAT decision is operationally significant. Running a 1T MoE model on 4×H100 (rather than 8) cuts infrastructure cost roughly in half while maintaining model quality. Combined with the Modified MIT license, K2.6 is the most accessible frontier-capable open-weight model for self-hosted agentic deployment as of its April 2026 release.

The long-horizon execution capability — 12+ hours, 4,000+ tool calls — is the metric to watch for autonomous agent products. Coding agents that run overnight to complete a refactor, background agents that process incoming data continuously, DevOps agents that handle deployment pipelines without human check-ins: these are the applications where K2.6's design choices pay off.

Areas where K2.6 is not the right choice: pure reasoning tasks, math competitions, benchmarks that don't involve tool use. If the application is a reasoning pipeline without external tool calls, K2.5's math performance was comparable and the agents supporting it (like GLM-5.1 or DeepSeek V4 Pro) may hold an edge on certain benchmarks.

Bottom Line

Kimi K2.6 scales Agent Swarm to 300 sub-agents and 4,000 steps, cuts hardware requirements to 4×H100 via native INT4 QAT, and delivers the highest HLE-Full score with tools among the comparison set. The 12-hour autonomous execution capability is tested, not theoretical. Open-weight under Modified MIT, runs on HuggingFace weights today.

The tradeoff is explicit: agentic and coding benchmarks are where K2.6 leads; pure math reasoning is where it doesn't. For developers building long-running autonomous systems on open weights, K2.6 is currently the reference point.

Resources

Kimi K2.6 weights available under Modified MIT license at huggingface.co/moonshotai/Kimi-K2.6. API access at platform.moonshot.ai.