Kimi K2 in 2026: What to Use Now (K2.5, K2.6, K3)
Kimi K2 changed open-source AI in 2025, but what should you use now? Compare the K-family lineup (K2.5, K2.6, K3), pricing, benchmarks, and self-hosting.

Kimi K2 was a turning point for open-weight AI. When Moonshot AI released it in July 2025, it was the first serious open-source model purpose-built for agentic tasks: tool use, multi-step reasoning, code generation, not just conversation. With 1 trillion total parameters and 32 billion activated via a Mixture-of-Experts architecture, it competed directly with closed frontier models.
But a lot has changed since then. Groq dropped K2 entirely, successors have shipped vision, thinking, and MCP support, and the pricing landscape looks completely different. If you’re still thinking about Kimi K2 the way the July 2025 launch articles described it, you’re working with stale information. This article covers what K2 actually was, where the K-family stands in August 2026, and which model you should use today.
If you’re interested in building your own AI agent with Mastra or exploring other agentic frameworks, the K-family models are among the strongest open-weight options available.
Updated August 2026
This article was originally published July 2025 and has been fully refreshed. The Groq tabs, old pricing tables, and roadmap sections have been replaced with current information. All “Future Roadmap” items from the original K2 launch have since shipped in successor models.
What made Kimi K2 stand out?
Unlike traditional language models that excel at conversation, Kimi K2 was optimized for agentic tasks. It doesn’t just understand your request. It plans, executes, and delivers complete solutions using tools and multi-step reasoning. This made it the first open-weight model that could genuinely compete with closed models on tool-calling benchmarks.
Moonshot AI achieved this through a massive MoE architecture: 384 experts with 8 selected per token plus 1 shared expert, trained on 15.5 trillion tokens with zero training instability. The result was a model that scored 65.8% on SWE-bench Verified (single-attempt) and 70.6% on the Tau2 retail tool-use benchmark, matching closed frontier models at the time.
For developers looking at the best AI coding tools and agents, Kimi K2 was the model that proved open-weight agentic coding was viable.
Key technical specifications
Mixture-of-Experts (MoE) design:
- Total parameters: 1 trillion
- Activated parameters: 32 billion per forward pass
- Expert configuration: 384 experts + 1 shared expert, 8 selected per token
- Layers: 61 (1 dense)
- Attention hidden dim: 7168, 64 heads
- Vocab size: 160,000
- Attention: Multi-head Latent Attention (MLA) with SwiGLU
- Context window: 131,072 tokens (128K)
- Training data: 15.5T tokens with zero training spikes
- Optimizer: MuonClip (see technical deep-dive below)
- Knowledge cutoff: December 2024
Benchmark results (at launch, July 2025):
- LiveCodeBench v6: 53.7% Pass@1
- SWE-bench Verified: 65.8% single-attempt accuracy
- MMLU: 89.5% exact match
- AIME 2025: 49.5% (Avg@64)
- Tau2 retail (tool use): 70.6% Avg@4
- Math & STEM: State-of-the-art across multiple benchmarks at launch
Agentic intelligence features:
- Advanced tool use: Integration with APIs and external tools
- Multi-step reasoning: Complex problem-solving workflows
- Code generation: Strong performance across multiple languages
- Data analysis: Statistical analysis with visualization generation
- Web development: Complete application building capabilities
- Command line operations: Direct system interaction and file manipulation
- No enforced JSON mode: Original K2 does not support
response_format. Use structured prompting instead. - Recommended temperature: 0.6
Kimi K2 vs the field at launch (July 2025)
These comparisons reflect the competitive landscape when K2 launched. All three competitors listed here are now two or more generations behind — GPT-5.x, Claude Fable 5, and DeepSeek V3.2 are the current counterparts. For current-gen comparisons, see the K-family section below.
| Feature | Kimi K2 | GPT-4.1 |
|---|---|---|
| Coding (LiveCodeBench) | 53.7% | 44.7% |
| Tool Use (AceBench) | 76.5% | 80.1% |
| Math (AIME 2025) | 49.5% | 37.0% |
| Context Window | 131K | 128K |
| Agentic Capabilities | Native | Limited |
| Cost (Input/Output) | $0.55-1/$2.2-3 | Higher |
Winner at launch: Kimi K2 for coding and agentic tasks
| Feature | Kimi K2 | Claude Sonnet 4 |
|---|---|---|
| SWE-bench Verified | 65.8% | 72.7% |
| MMLU | 89.5% | 91.5% |
| Tool Use | 76.5% | 76.2% |
| Open Source | Yes | No |
| Self-Hosting | Yes | No |
Winner at launch: Close competition — Kimi K2 won on accessibility and cost
| Feature | Kimi K2 | DeepSeek V3 |
|---|---|---|
| Coding Performance | 53.7% | 46.9% |
| Math Reasoning | 49.5% | 46.7% |
| Tool Use | 76.5% | 72.7% |
| Parameters | 1T (32B active) | 671B (37B active) |
| Training Stability | Zero spikes | Standard |
| Agentic Focus | Purpose-built | General |
Winner at launch: Kimi K2 for specialized agentic applications
Historical comparison
These models are now outdated. GPT-5.x, Claude Fable 5, and DeepSeek V3.2 are the current-generation counterparts. For a look at how the K-family competes today, see the K2.5/K2.6/K3 lineup below. You can also check our guide to Qwen 3.6 for AI coding agents for another current open-weight option.
The K-family lineup in 2026: K2.5, K2.6, and K3
Every “Future Roadmap” item from the original K2 launch has shipped in a successor. Here’s the full timeline:
| Model | Released | Params | Context | Key Addition | OpenRouter Price |
|---|---|---|---|---|---|
| Kimi K2 (0711) | Jul 2025 | 1T / 32B active | 128K | Original — agentic tool use, MoE | $0.57 / $2.30 |
| Kimi K2 0905 | Sep 2025 | 1T / 32B active | 256K | Better agentic coding | $0.60 / $2.50 |
| Kimi K2 Thinking | Nov 2025 | 1T / 32B active | 256K | Interleaved thinking + tool use, 200-300 sequential tool calls | ~$0.60 / $2.50 |
| Kimi K2.5 | Jan 2026 | 1T / 32B active | 256K | Multimodal (MoonViT 400M), Agent Swarm | $0.45 / $2.25 |
| Kimi K2.6 | Apr 2026 | ~1T MoE | 262K | Long-horizon coding (4,000+ tool calls / 12h runs), structured outputs | $0.57 / $3.41 |
| Kimi K2.7-Code | Jun 2026 | ~1T MoE | 262K | Coding-focused, ~30% lower reasoning-token usage | — |
| Kimi K3 | Jul 2026 | 2.8T / 104B active | 1M | Kimi Delta Attention, MoonViT-V2, MXFP4, MCPMark 94.5 | $2.80 / $14.00 |
K2 proved open-weight agentic AI works, K2 Thinking added reasoning, K2.5 added vision, K2.6 pushed long-horizon coding, and K3 went frontier with 2.8 trillion parameters and a million-token context window.
If you’re comparing the K-family against other open-weight options, see our guide to the best open-source LLMs to replace Claude or GPT.
Kimi K2 pricing and availability today
Here’s the current state as of August 2026.
Original Kimi K2
The original K2 (0711 build) is still available on OpenRouter, but it’s now a legacy model served by a single provider:
- Price: $0.57/M input, $2.30/M output
- Context: 131K tokens, max output 100,352 tokens
- Throughput: ~34 tokens/second (at time of writing)
- Providers: 1 (single provider)
It works, but K2.5 is cheaper and better for most use cases.
Groq no longer serves Kimi K2
Groq decommissioned moonshotai/kimi-k2-instruct on October 10, 2025, and
its successor kimi-k2-instruct-0905 was shut down April 15, 2026. Groq now
points users to openai/gpt-oss-120b. If you’re looking for Groq’s free API
for other models, see our guide to Groq’s free API.
What to actually use today
The default recommendation for most developers.
- Price: $0.45/M input, $2.25/M output (cache read: $0.07/M)
- Context: 262K tokens, 64K max output
- Providers: 10 on OpenRouter (DeepInfra, SiliconFlow, DigitalOcean, Venice, NovitaAI, Amazon Bedrock, and more)
- Key features: Multimodal via MoonViT (400M-param vision encoder), Agent Swarm, thinking + instant modes
- Best for: Agentic tasks with vision, general coding, cost-sensitive workloads
K2.5 is the cheapest multimodal K-family model and the one I’d recommend starting with. At $0.45/M input with cache pricing at $0.07/M, it’s one of the cheapest AI models for agents that still delivers strong agentic performance.
For developers who need JSON schema support and long-horizon coding.
- Price: $0.57/M input, $3.41/M output (cache read: $0.20/M)
- Context: 262K tokens, 262K max output
- Providers: 20 on OpenRouter
- Key features: Structured outputs via JSON schema, image input, 4,000+ tool calls in single runs (up to 12 hours), Agent Swarm with hundreds of sub-agents
- Best for: Production pipelines requiring structured outputs, long-running agentic workflows
K2.6 is the workhorse for production agentic coding. The structured output support (via JSON schema) is a significant upgrade over the original K2, which had no enforced JSON mode. With 20 providers on OpenRouter, you get good redundancy.
For multi-model routing across Kimi, Claude, and GPT, consider Agent Router.
Frontier reasoning and a million-token context window.
- Price: $2.80/M input, $14.00/M output (cache read: ~$0.29/M)
- Context: 1,000,000 tokens (1M)
- Params: 2.8T total / 104B active, 896 experts (16 selected + 2 shared)
- Key features: Kimi Delta Attention (KDA) + Gated MLA, MoonViT-V2, MXFP4 quantization, MCPMark-Verified 94.5,
reasoning_effortparameter (low/high/max, defaultmax) - Best for: Frontier reasoning tasks, massive context analysis, MCP-heavy workflows
K3 is the premium tier, roughly 5x K2.5’s cost. Note that K3 always returns reasoning_content and requires passing the full assistant message back (including reasoning_content + tool_calls) in multi-turn conversations.
You can also access Kimi K3 through OpenCode Go, an open-source coding agent, or get Kimi K3 for cheap through bundled API access.
API endpoint correction
The international Moonshot AI platform is now at platform.kimi.ai (not the
.cn endpoint). The kimi-latest alias was retired January 28, 2026 —
always use explicit model slugs like kimi-k3 or moonshotai/kimi-k2.5.
Self-hosting Kimi K2: the reality check
The original article mentioned “self-hosting available with vLLM/SGLang/KTransformers.” That’s technically true, but it needs context for the bitdoze audience.
Self-hosting reality check
A 1T-parameter MoE model in block-FP8 requires multi-GPU clusters (8x H100/H200-class) and hundreds of GB of VRAM. This is not a VPS job. For most solo operators, API access through OpenRouter or DeepInfra is the practical choice.
Self-hosting engines (all confirmed in the official GitHub README):
- vLLM — most popular for production serving
- SGLang — optimized for structured generation
- KTransformers — CPU/GPU hybrid offloading
- TensorRT-LLM — NVIDIA-optimized inference
What changed with successors: K2 Thinking added native INT4 quantization, and K3 introduced MXFP4 — both make smaller GPU clusters borderline feasible. But “borderline” still means dedicated GPU hardware, not a Hetzner VPS running your Docker stack.
License details: K2 through K2.6 are open-weight under a Modified MIT License. Free for most uses, but a separate commercial license is required if your product exceeds 100 million monthly active users or $20 million/month revenue. The license also has a synthetic-data carve-out (model outputs are not covered) — relevant if you’re fine-tuning. K3 uses a separate “Kimi K3 License.”
Kimi Vendor Verifier: Moonshot ships a tool to confirm a third-party endpoint is actually serving the right model. Worth using if you’re routing through less-known providers.
What shipped since launch: vision, thinking, MCP
The original K2 article had a “Future Roadmap” section. Everything in it landed:
Vision: K2.5's MoonViT
K2.5 (January 2026) added native multimodal capabilities through MoonViT, a 400M-parameter vision encoder. This means K2.5 can process images alongside text — useful for UI analysis, document understanding, and visual debugging tasks. K3 upgraded this to MoonViT-V2 with video support.
Thinking: K2 Thinking
K2 Thinking (November 2025) added interleaved thinking with tool use. The model can reason through problems step-by-step while calling tools in sequence. It supports 200-300 sequential tool calls in a single run, with 256K context. Benchmarks: SWE-bench Verified 71.3%, HLE 44.9%, BrowseComp 60.2%.
MCP and long-horizon: K2.6 + K3
K2.6 (April 2026) pushed long-horizon agentic coding with support for 4,000+ tool calls in runs lasting up to 12 hours, with Agent Swarm coordinating hundreds of sub-agents. K3 (July 2026) added MCPMark-Verified 94.5 — strong Model Context Protocol support for complex tool orchestration.
Real-world testing with Kimi K2
Tested at launch (July 2025)
The testing results below are from the original K2 release. They reflect the model’s capabilities at that time. For K2.5/K3 testing, see the pricing section recommendations above.
I tested Kimi K2 by building a complete solar panel website using Astro in Zed editor. Here’s what happened:
Project setup and architecture
What Kimi K2 delivered:
- Complete Astro project structure with proper configuration
- Responsive design system using Tailwind CSS
- Component architecture with reusable UI elements
- SEO optimization with proper meta tags and structured data
- Performance optimization with lazy loading and image optimization
- Accessibility compliance following WCAG guidelines
The model understood the project requirements and delivered a production-ready codebase without multiple iterations.
Code quality and best practices
Impressive capabilities:
- Clean, maintainable code following industry standards
- Proper TypeScript integration with type safety
- Modern CSS practices with CSS Grid and Flexbox
- Component composition with proper prop handling
- Error handling and edge case management
- Documentation with inline comments and README
The generated code felt like it was written by an experienced developer, not an AI.
Agentic problem solving
Multi-step execution:
- Analyzed requirements and proposed optimal architecture
- Created file structure and initialized project dependencies
- Built components incrementally with proper testing
- Handled styling conflicts and responsive design challenges
- Optimized performance by identifying bottlenecks
- Deployed and tested the final application
This wasn’t just code generation — it was genuine software engineering.
Getting started: code examples
Updated code snippets for the models you should actually use today.
Using K2.5 (the default recommendation):
import OpenAI from "openai";
const openai = new OpenAI({
baseURL: "https://openrouter.ai/api/v1",
apiKey: process.env.OPENROUTER_API_KEY,
});
const completion = await openai.chat.completions.create({
model: "moonshotai/kimi-k2.5",
messages: [
{
role: "user",
content: "Build a React component for a solar panel calculator",
},
],
tools: [
{
type: "function",
function: {
name: "create_file",
description: "Create a new file with content",
},
},
],
});
console.log(completion.choices[0].message);For K3 (frontier reasoning):
const completion = await openai.chat.completions.create({
model: "moonshotai/kimi-k3",
messages: [
{
role: "user",
content: "Analyze this codebase and suggest architectural improvements",
},
],
// K3 supports reasoning_effort: "low" | "high" | "max" (default: "max")
});Note: K3 always returns reasoning_content. In multi-turn conversations, pass the full assistant message back (including reasoning_content and tool_calls).
Corrected international endpoint:
curl -X POST "https://api.moonshot.ai/v1/chat/completions" \
-H "Authorization: Bearer $MOONSHOT_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "kimi-k3",
"messages": [
{
"role": "user",
"content": "Help me build a complete web application"
}
]
}'The kimi-latest alias was retired January 28, 2026. Always use explicit model slugs: kimi-k3, kimi-k2.5, etc. Documentation is at platform.kimi.ai.
Performance and cost optimization
Speed and provider selection
Updated for 2026:
- No more Groq 250 TPS — Groq dropped all K2 variants; the fastest K-family inference is now through DeepInfra or SiliconFlow on OpenRouter
- K2.5 on DeepInfra/SiliconFlow for the best speed-to-cost ratio
- K3 for capability when you need frontier reasoning or 1M context
- Enable streaming for real-time responses in agentic workflows
- Use structured outputs (K2.6+ only, via JSON schema) for consistent formatting
- Implement caching — K2.5 cache reads at $0.07/M, K3 at $0.29/M
Cost optimization
Budget-friendly strategies:
- Start with K2.5 at $0.45/M input — it’s the cheapest multimodal K-family model
- Use cache pricing for repeated patterns (K2.5: $0.07/M cache reads)
- Batch similar requests when possible
- Choose the right model tier — don’t use K3 ($14/M output) for tasks K2.5 ($2.25/M) handles fine
- Monitor usage with OpenRouter’s provider dashboards
- Consider OpenCode Go for bundled access to K3 and 17 other models
Quality and prompting
Best practices:
- Temperature settings: K2 original = 0.6; K2.5/K2 Thinking = 1.0 (thinking mode) / 0.6 (instant mode); top_p 0.95
- Provide clear tool definitions with explicit parameters
- Structure complex tasks into clear steps
- Use structured outputs (K2.6+ only) — original K2 does not support
response_format - Include examples in your prompts for better one-shot results
- Test with different providers to find optimal performance for your workload
Technical innovation: MuonClip optimizer
Kimi K2’s stability comes from a training innovation that solved one of the biggest problems with large MoE models.
Technical deep dive
Kimi K2 introduced the MuonClip optimizer, solving training instability issues that plague large MoE models. This innovation enabled zero training spikes across 15.5 trillion tokens — a first at this scale.
Key innovations:
- QK-Clip technique: Prevents attention logit explosions that cause training divergence in large MoE models
- Adaptive scaling: Dynamic adjustment based on attention patterns during training
- Stable training: Zero spikes during 15.5T-token training runs
- Token efficiency: Superior performance per training token compared to standard optimizers
MuonClip’s stability innovations carried forward into all K-family successors. The training stability it enabled is one reason Moonshot AI was able to iterate so quickly from K2 to K3 in just one year.
Final verdict: which Kimi model should you use?
- Budget agentic + vision → K2.5 ($0.45/$2.25, 10 providers, multimodal, cache $0.07) — the default for most developers
- Structured outputs + long-horizon coding → K2.6 ($0.57/$3.41, JSON schema, 20 providers, image input)
- Frontier reasoning + 1M context → K3 ($2.80/$14.00, 2.8T params, MCPMark 94.5)
- Original K2 → Only if you specifically need the 0711 build for compatibility; otherwise use K2.5
Quick recommendation
For most developers in 2026, start with Kimi K2.5 on OpenRouter. It’s the cheapest multimodal K-family model with 10 providers, cache pricing at $0.07/M, and strong agentic performance. If you need structured outputs or long-horizon coding, step up to K2.6. Reserve K3 for frontier tasks that actually need a million-token context.
Want to try Kimi K3 without the premium price? OpenCode Go gives you access to K3 and 17 other models for around $10/month. For a broader look at open-weight options, see our guide to the best open-source LLMs to replace Claude or GPT.
FAQ
Is Kimi K2 still available?
Yes. The original Kimi K2 (0711 build) is still available on OpenRouter at $0.57/M input and $2.30/M output, served by a single provider with ~34 tokens/second throughput. However, K2.5 is cheaper ($0.45/$2.25), has more providers (10 vs 1), and adds multimodal capabilities. Unless you specifically need the 0711 build for compatibility, use K2.5 instead.
Why did Groq drop Kimi K2?
Groq decommissioned moonshotai/kimi-k2-instruct on October 10, 2025, redirecting users to the 0905 build. That successor was deprecated March 23, 2026 and shut down April 15, 2026, replaced by openai/gpt-oss-120b. The likely reason is cost and demand optimization — Groq’s custom hardware is better utilized serving models with higher throughput requirements.
Can I self-host Kimi K2 on a VPS?
No. A 1T-parameter MoE model in block-FP8 requires 8x H100/H200-class GPUs and hundreds of GB of VRAM. This is a multi-GPU cluster workload, not something you run on a VPS. K2 Thinking’s native INT4 and K3’s MXFP4 quantization make smaller clusters borderline feasible, but “smaller” still means dedicated GPU hardware. For most solo operators, API access through OpenRouter is the practical path.
What's the difference between K2.5, K2.6, and K3?
| Model | Price (In/Out) | Context | Key Feature | Providers |
|---|---|---|---|---|
| K2.5 | $0.45 / $2.25 | 262K | Multimodal (vision), cheapest | 10 |
| K2.6 | $0.57 / $3.41 | 262K | Structured outputs (JSON schema), long-horizon | 20 |
| K3 | $2.80 / $14.00 | 1M | Frontier reasoning, MCPMark 94.5 | Multiple |
Start with K2.5. Step up to K2.6 when you need structured outputs. Use K3 only for frontier tasks.
Is Kimi K2 open source?
Open-weight under a Modified MIT License. Free for most uses. A separate commercial license is required if your product exceeds 100 million monthly active users or $20 million/month revenue. The license also has a synthetic-data carve-out (model outputs are not covered by the license). K3 uses a separate “Kimi K3 License” with different terms.


