If you’re trying to use Kimi seriously, you need to know which model you’re actually working with. The naming isn’t obviously intuitive. K2 is not an older version of K2.5 the way GPT-3 was an older version of GPT-4. They’re architecturally related but have meaningfully different capabilities, licensing implications, and recommended use cases.
Here’s the complete breakdown: architecture, version-by-version differences, benchmark data with proper attribution, API setup, and where each model fits in practice.
The Architecture Foundation: Why They All Share a Core
Every model in the Kimi K2 family is built on the same fundamental design: a 1-trillion-parameter Mixture-of-Experts model with 32 billion active parameters per token.
Understanding what this means in practice matters more than the numbers themselves.
Mixture-of-Experts. Instead of one giant neural network running entirely for every token, MoE models contain many smaller “expert” subnetworks, and only a subset activates for any given input. According to Moonshot’s technical documentation and the Hugging Face model cards for the K2 family, the architecture contains 384 routed experts plus one shared expert, with 8 experts selected per token across 61 transformer layers.
The practical effect: you get the knowledge capacity of a 1T-parameter model at roughly the inference cost of a 32B-parameter one. This is the architectural reason why Kimi can be priced the way it is against dense models of comparable scale.
Pre-training data. According to Moonshot’s published technical reports, the K2 base model was pre-trained on 15.5 trillion tokens.
Muon optimizer. Moonshot’s technical documentation credits the Muon optimizer as enabling training stability at this parameter count. This is relevant because it’s one of the stated reasons the 1T model could be trained without instability, which is non-trivial at that scale.
With that foundation established, here’s how each version is distinct.
Kimi K2 (July 2025): The Original
Kimi K2 was the model that changed how people thought about Moonshot. Released July 2025 under a Modified MIT license, it was the first genuinely frontier-adjacent open-weight model from the company.
Architecture: 1T parameters, 32B active, 384-expert MoE, pre-trained on 15.5T tokens. Text-only. 256K context window.
Key modes: Instant (fast inference), Thinking (extended reasoning), Instruct (base instruction following).
Benchmark context: According to VentureBeat’s analysis at launch and Moonshot’s published results, K2 Thinking achieved what Moonshot described as state-of-the-art on Humanity’s Last Exam at 44.9% and BrowseComp at the time of release. These were vendor-reported figures; independent replication followed in subsequent weeks.
Licensing note: The Modified MIT license permits commercial use and redistribution, but includes a clause restricting use of the model to create derivative products that compete with Moonshot’s own commercial offerings in certain ways. Read the full license on Hugging Face before building products on top of K2.
Status: The legacy K2 family (K2-0905-preview, K2-0711-preview, K2-Turbo-preview, K2-Thinking, K2-Thinking-Turbo) was scheduled for end-of-life on May 25, 2026, per Moonshot’s platform documentation. If you’re still running workloads on legacy K2 API endpoints, migration to K2.5 or K2.6 is overdue.
Kimi K2.5 (January 2026): The Multimodal Upgrade
Released January 27, 2026. K2.5 represents a meaningful architectural expansion, not just a parameter bump.
Architecture additions over K2: According to Moonshot’s published technical reports and the InfoQ analysis of the K2.5 launch, Moonshot integrated MoonViT-3D (their vision encoder) into the K2 base model. They resumed pre-training from a K2 checkpoint with an additional 15 trillion tokens of mixed visual and textual data, meaning vision and language capabilities developed in the same training pass rather than as separate bolt-on systems. This is the stated reason K2.5’s vision integration is considered architecturally native.
Specifications: 1T parameters, 32B active, 256K context, native multimodal (text and images), Modified MIT open-weight.
Agent Swarm introduction: K2.5 was the first model to include Agent Swarm. According to Moonshot’s technical documentation and their published paper on PARL (Parallel Agent Reinforcement Learning), Moonshot developed this training technique specifically to teach the model to decompose and parallel complex tasks. Per Moonshot’s methodology documentation, the reward function during PARL training balances task quality (80%) with critical path efficiency (20%), and uses a “critical steps metric” that measures the slowest sub-agent at each stage rather than total steps. K2.5 supports up to 100 simultaneous sub-agents.
Four operation modes: Instant, Thinking, Agent, and Agent Swarm (initially available as research preview at K2.5 launch, generally available by K2.6).
Benchmark figures per Moonshot’s published results:
- SWE-bench Verified: 76.8%
- BrowseComp, standard agent: 60.6%
- BrowseComp, Agent Swarm: 78.4%
- WideSearch, Agent Swarm: 79.0%
- Humanity’s Last Exam with tools: 50.2%
Third-party corroboration: According to Artificial Analysis, K2.5 ranked among the leading models on their intelligence index at time of evaluation, competitive with GPT-5.4 and Claude at the broader benchmark level. This provides meaningful independent corroboration of the model family’s general positioning.
API pricing: Approximately $0.60 per million input tokens, $3.00 per million output. Cached input: approximately $0.10 per million. Verify current rates at platform.moonshot.ai.
Kimi K2.6 (April 2026): The Current Flagship
Released April 20, 2026, eight days after a K2.6 Code Preview. This is the model powering Kimi’s chat interface for paid users and representing Moonshot’s best current general-purpose performance.
Architecture changes from K2.5: The base MoE architecture is unchanged (1T parameters, 32B active, 384 experts, 256K context). The improvements came through additional training on agentic and coding task data, and the PARL technique was extended to support the Agent Swarm scale-up from 100 to 300 sub-agents.
Improvements over K2.5, per Moonshot’s published benchmark results:
- SWE-Bench Pro: 58.6% (vs 50.7% for K2.5)
- Terminal-Bench 2.0: 66.7% (vs 50.8% for K2.5)
- BrowseComp, Agent Swarm: 86.3% (vs 78.4% for K2.5)
These improvements are meaningful on the specific benchmarks that matter for agentic coding: real terminal-based task completion (Terminal-Bench) and complex research requiring parallel information retrieval (BrowseComp Agent Swarm). These are Moonshot’s own evaluation figures; treat them as vendor-reported.
Third-party corroboration: According to Artificial Analysis, by April 2026 K2.6 ranked as the strongest open-weight model on their intelligence index, within a few points of the top closed-source frontier models. This is the most significant independent signal available for K2.6.
Production use: K2.6 is the default model for Kimi Work agentic tasks, Agent Swarm runs, Kimi Code sessions, and the Kimi chat interface for Moderato and above subscribers. Per multiple reports in mid-2026, K2.6 also appeared in Perplexity’s model picker, making it one of the first Kimi models in a major Western AI product.
API pricing: Approximately $0.95 per million input tokens, $4.00 per million output. Cached input: approximately $0.16 per million. Verify at platform.moonshot.ai.
Kimi K2.7 Code (June 2026): The Coding Specialist
Released June 12, 2026. Architecture base is K2.6, with additional post-training specifically targeting software development and agentic coding pipelines.
Architecture: 1T parameters, 32B active, 384 experts, 256K context window. Modified MIT license, weights on Hugging Face.
Changes from K2.6, per Moonshot’s proprietary evaluation suites:
- 21.8% improvement on Kimi Code Bench v2
- Approximately 30% fewer reasoning tokens consumed per agentic loop (Moonshot’s stated figure: a loop that previously used roughly 1,000 reasoning tokens now uses approximately 700)
- More reliable MCP (Model Context Protocol) tool calls, with improved performance on CI checks, ticket updates, and multi-file edits in a single pass
Critical benchmark caveat: All published benchmark figures for K2.7 Code as of its June 2026 release are from Moonshot’s own proprietary suites (Kimi Code Bench v2, MCP Mark Verified). No results on standard independent leaderboards (SWE-bench, LiveCodeBench, Terminal-Bench) were available at publication time. This is consistent with how other labs’ newest models launch. Independent verification typically follows within weeks to months. Treat K2.7 Code benchmark claims as directionally informative, not independently validated.
API pricing: Approximately $0.55 to $0.75 per million input tokens and $2.50 to $3.50 per million output, per available pricing data. These figures vary across endpoints and may have updated since launch. Verify at platform.moonshot.ai.
Self-hosting: K2.7 Code is available on Hugging Face under Modified MIT. For EU deployments or data-sensitive environments, self-hosting is the recommended path as of mid-2026, since managed cloud options (AWS Bedrock, Azure Foundry) had K2.5 and K2.6 available in preview but not yet K2.7 Code at publication time.
Version Comparison at a Glance
| Feature | K2 (Legacy) | K2.5 | K2.6 | K2.7 Code |
|---|---|---|---|---|
| Release | July 2025 | Jan 2026 | Apr 2026 | Jun 2026 |
| Parameters | 1T / 32B | 1T / 32B | 1T / 32B | 1T / 32B |
| Context | 256K | 256K | 256K | 256K |
| Vision | No | Yes | Yes | Yes |
| Agent Swarm | No | 100 sub-agents | 300 sub-agents | 300 sub-agents |
| SWE-bench Pro (Moonshot) | Not published | 50.7% | 58.6% | Not published |
| Status | EOL May 2026 | Active | Flagship | Coding specialist |
| API Input (approx.) | Legacy pricing | ~$0.60/M | ~$0.95/M | ~$0.55-0.75/M |
| API Output (approx.) | Legacy pricing | ~$3.00/M | ~$4.00/M | ~$2.50-3.50/M |
Pricing as of July 2026. Verify at platform.moonshot.ai before using for cost models.
Using the Kimi API: Setup and Configuration
The Kimi API is fully OpenAI-compatible. Any existing workflow using the OpenAI Python or JavaScript SDK can swap in Kimi by changing the base URL and model string.
International access: api.moonshot.ai Mainland China access: platform.moonshot.ai (separate RMB rate card) Authentication: Bearer token using your Moonshot API key GitHub: Moonshot’s open-weight model cards, example scripts, and some tooling are available under the moonshotai organization on GitHub (github.com/MoonshotAI)
Basic Python setup:
from openai import OpenAI
client = OpenAI(
api_key="your-moonshot-api-key",
base_url="https://api.moonshot.ai/v1"
)
response = client.chat.completions.create(
model="kimi-k2.6",
messages=[
{"role": "user", "content": "Your prompt here"}
]
)
Context caching. The Kimi API applies automatic context caching: when repeated or overlapping context (system prompts, document text, conversation history) appears across requests, it’s served at the cached input rate, roughly 80 to 85% lower than the standard input price. No configuration required. For workflows iterating on a fixed codebase or document, the effective input cost is substantially lower than the headline rate.
Rate limits. API rate limits are tier-based, scaling with cumulative account recharge (Tier 0 through Tier 5, from $1 to $3,000). Higher tiers unlock more concurrent requests and higher requests-per-minute. The per-token price is flat at every tier: more spending raises your throughput ceiling, not your unit cost. Tier 1 ($10 cumulative) gives 50 concurrent requests and 200 RPM. Tier 5 ($3,000) gives 1,000 concurrent and 10,000 RPM. Tier 0 has a 1.5M tokens-per-day limit; Tier 1 and above have no daily token cap.
Current model strings (verify at platform documentation, as these update):
kimi-k2.6for the flagshipkimi-k2.5for the cheaper multimodal alternative- Check platform.moonshot.ai for the current K2.7 Code model string, as these have shifted with preview releases
Getting an API key: Register at platform.moonshot.ai (international) or platform.moonshot.cn (China). Minimum $1 recharge to activate. $5 cumulative recharge triggers a $5 voucher.
Integration with Claude Code, Cline, Roo Code: Kimi provides an Anthropic-compatible endpoint variant for tools that natively support Anthropic’s API format. Set your ANTHROPIC_BASE_URL to the Kimi Anthropic-compatible endpoint and authenticate with your Kimi API key. Per Moonshot’s integration documentation, you should disable image-related steps if using a text-only variant.
Self-Hosting K2.6 and K2.7 Code
Open weights for K2.5, K2.6, and K2.7 Code are all available under the moonshotai organization on Hugging Face, under Modified MIT.
Supported frameworks: vLLM, SGLang, KTransformers, TensorRT-LLM. INT4 quantization is natively supported, significantly reducing VRAM requirements.
Hardware reality: Even at INT4 quantization, running the full 1T model at reasonable speed requires serious GPU infrastructure. Cloud GPU instances (A100 or H100 class) are the practical route for most teams.
Why bother?
- Full data control: nothing leaves your infrastructure
- GDPR compliance for EU deployments
- No per-token cost after infrastructure is provisioned
- Ability to fine-tune on proprietary data
For most teams, the Kimi API is more economical than self-hosting unless GPU utilization is very high or data sovereignty is non-negotiable. If the latter, self-hosting is the only viable path.
Kimi K3: What’s Known and What Isn’t
A successor called Kimi K3 has been announced by Moonshot for Q3 2026. Unconfirmed figures circulating in developer communities and some press coverage suggest approximately 2.5T total parameters and a 1M-token context window. None of these specifications have been officially confirmed by Moonshot at publication time. File under “interesting if accurate, wait for the announcement.”
Frequently Asked Questions
What is Kimi K2?
The foundational open-weight model from Moonshot AI, released July 2025. 1T parameters, 32B active per token, pre-trained on 15.5T tokens per Moonshot’s published documentation. Text-only. Legacy K2 API endpoints were scheduled for end-of-life May 25, 2026.
What’s the difference between Kimi K2.5 and K2.6?
K2.5 added vision (via MoonViT-3D) and Agent Swarm (up to 100 sub-agents) to the K2 base. K2.6 significantly improved agentic coding and long-horizon performance, and upgraded Agent Swarm to 300 sub-agents. Per Moonshot’s published benchmarks, K2.6 improved SWE-Bench Pro by roughly 8 points and Terminal-Bench by 16 points over K2.5.
What is Kimi K2.7 Code?
A coding-focused variant of K2.6, released June 2026. Per Moonshot’s proprietary benchmarks, it showed a 21.8% improvement on their internal coding evaluation while using roughly 30% fewer reasoning tokens. No independent third-party verification on standard leaderboards was available at publication.
What context window do Kimi models support?
All current K2-family models support 256K tokens. Kimi K3 (announced Q3 2026, specifications unconfirmed) reportedly targets 1M tokens.
How do I get a Kimi API key?
Register at platform.moonshot.ai (international). Top up at least $1. Your key appears in the API Keys section of your dashboard.
Is the Kimi API OpenAI-compatible?
Yes. The API follows OpenAI’s format and works with the OpenAI Python or JavaScript SDK via a custom base URL. An Anthropic-compatible variant is also available for tools like Claude Code and Cline.
What is Agent Swarm?
According to Moonshot’s technical documentation, Agent Swarm was trained using Parallel Agent Reinforcement Learning (PARL). The model decomposes complex tasks into parallel sub-tasks, each handled by a separate sub-agent simultaneously. Per Moonshot’s published PARL methodology, the reward function balances task quality (80%) with critical path efficiency (20%). K2.5 supports up to 100 sub-agents; K2.6 and K2.7 Code support up to 300.
Can I run Kimi models locally?
Yes. Open weights are available on Hugging Face under Modified MIT. Frameworks include vLLM, SGLang, KTransformers, and TensorRT-LLM. INT4 quantization helps, but serious GPU infrastructure is still required.
What is PARL?
Parallel Agent Reinforcement Learning. According to Moonshot’s technical documentation and published methodology, it’s the training technique used to teach the model to decompose tasks into parallel sub-tasks rather than defaulting to sequential execution. The reward function incentivizes parallel sub-agent instantiation balanced against task quality outcomes.
What is MoonViT-3D?
According to Moonshot’s published technical reports, MoonViT-3D is their vision encoder, integrated into K2.5 and all subsequent K2 models. Visual and language representations were trained jointly from the same checkpoint rather than as separately trained modules grafted together.
When is Kimi K3 coming out?
Announced for Q3 2026. No official release date or confirmed specifications as of publication. Reported figures from community sources suggest approximately 2.5T parameters and a 1M context window, but these are unconfirmed.
Final Thoughts
The K2 family makes more sense once you see the pattern: a shared 1T/32B MoE foundation, with each generation layering on multimodal capability (K2.5), stronger agentic performance (K2.6), or task-specific post-training for coding (K2.7 Code).
The architecture is genuinely clever. The 384-expert MoE approach at this scale, combined with Muon-optimizer training stability and PARL-trained Agent Swarm, isn’t just aggressive pricing on a rebranded base model. These are real engineering choices that produce the cost efficiency and agentic capability the benchmarks point to.
The honest caveat is that K2.7 Code’s benchmarks are still vendor-reported only. Independent validation will come. For K2.6, Artificial Analysis’s third-party ranking provides meaningful external signal. Use that to calibrate your confidence in which numbers to act on now and which to wait for more independent data on.
If you’re evaluating Kimi for a real project, K2.6 is the right starting point. K2.7 Code is worth a trial if coding workflows are your primary use case and you’re comfortable with the current benchmark uncertainty.
Start with the free tier at kimi.com or a minimal API top-up. Your own test on your own codebase will tell you more than any benchmark table can.
Architecture specifications and benchmark figures come from Moonshot’s official documentation, Hugging Face model cards, and third-party sources including Artificial Analysis where explicitly noted. K2.7 Code benchmark figures are Moonshot proprietary-only as of publication. Pricing reflects publicly available API rates as of July 2026 and is subject to change. Always verify current specifications and pricing at platform.moonshot.ai.
Curated by Lorphic
Digital intelligence. Clarity. Truth.
