It landed July 16, 2026, and the first question most people had wasn’t about the benchmarks. It was about the number.

2.8 trillion parameters. That’s not a typo. Kimi K3 is, per Moonshot’s own framing and independent tracking, the largest open-weight model shipped to date. And Moonshot didn’t just scale the same K2 design up. They rebuilt the architecture from scratch.

Here’s everything: what K3 actually is, what K3 Max and K3 Swarm Max are for, how the benchmarks look with honest attribution, what the API costs, and where the real limitations are.

What Is Kimi K3?

Kimi K3 is Moonshot AI’s flagship model, released July 16, 2026. It’s a 2.8-trillion-parameter Mixture-of-Experts model with native vision, a 1-million-token context window, and always-on reasoning by default. It’s the third major generation in the Kimi model family, succeeding K2.6 (April 2026) and K2.7 Code (June 2026).

Two variants shipped at launch: K3 Max for chat and single-agent tasks, and K3 Swarm Max for large-scale parallel processing across multi-agent workloads. Both are live on kimi.com, Kimi Work, Kimi Code, and the Kimi API as of the release date.

Per Moonshot’s announcement, full model weights are to be released on Hugging Face by July 27, 2026 under a Modified MIT license. As of publication, the weights had not yet appeared. K3 is best described as open-weight in commitment rather than in practice until that release happens.

Kimi K3 Release Date and What Happened

The release date is July 16, 2026. A leaked promotional page on Moonshot’s own Kimi Open Platform tipped the launch a day early, but the official announcement and API access came on the 16th. Moonshot describes this as their most capable model and “the world’s first open 3T-class model,” referencing the 2.8T parameter count as crossing into a new scale tier.

For context: for nine of the twelve months prior to K3’s launch, per Moonshot’s own framing in the technical blog, Kimi models had held the record for the largest open-weight model size at each respective point. K3 continues that trajectory at a significantly larger scale.

K3 Max vs K3 Swarm Max: What’s the Difference?

Two variants, one underlying model, different operational modes.

K3 Max handles chat interactions and single-agent tasks. This is what most users on kimi.com, Kimi Work, and the mobile apps interact with. For research, writing, coding sessions, document analysis, and general AI assistant tasks, K3 Max is the default.

K3 Swarm Max is for large-scale parallel processing across multi-agent workloads. It extends the Agent Swarm architecture (first introduced in K2.5, trained using Moonshot’s Parallel Agent Reinforcement Learning technique) to K3’s scale. Per community reporting from LuminaXspace at launch, K3 Swarm Max is what powers parallel agentic workflows where many sub-agents run simultaneously on decomposed tasks.

Moonshot had not published separate API pricing for K3 Swarm Max at launch. All paid subscription tiers include Swarm access, with higher tiers unlocking greater concurrency and credit multipliers, per Moonshot’s published membership page. Separate per-agent or per-request Swarm Max pricing was not confirmed at publication.

Architecture: What Actually Changed From K2

K3 is a genuine architectural departure, not a scaled-up version of K2.6.

Kimi Delta Attention (KDA). A new attention mechanism designed to improve how information flows across long sequences. KDA provides an efficient foundation for scaling attention at the 2.8T parameter range.

Attention Residuals (AttnRes). A complementary mechanism that selectively retrieves representations across model depth rather than accumulating them uniformly across all layers. Together with KDA, it forms the architectural backbone designed specifically to scale beyond the trillion-parameter regime.

Stable LatentMoE at 16/896 experts. K3 activates 16 of 896 experts per token, a significantly sparser activation than K2’s 32-of-384 configuration. At this level of sparsity, routing and load balancing become first-order challenges. Moonshot addresses this with:

• Quantile Balancing: derives expert allocation from router-score quantiles, eliminating heuristic updates and a sensitive balancing hyperparameter
• Per-Head Muon: extends the Muon optimizer to optimize attention heads independently for more adaptive learning at scale

Additional training improvements: Sigmoid Tanh Unit (SiTU) activation function, Gated Multi-head Latent Attention (Gated MLA), quantization-aware training from the SFT stage using MXFP4 weights with MXFP8 activations, and fully balanced expert-parallel training with static shapes and no host synchronization on the critical path.

The combined effect of these changes, per Moonshot’s published technical documentation on the K3 blog, yields approximately a 2.5x improvement in overall scaling efficiency compared to K2. That number is vendor-reported.

Kimi K3 Specifications

Spec	Kimi K3	Kimi K2.6	Kimi K2.7 Code
Total parameters	2.8 trillion	1 trillion	1 trillion
Active parameters per token	~16/896 experts	32/384 experts	32/384 experts
Context window	1,048,576 tokens (1M)	256K tokens	256K tokens
Vision	Yes (native)	Yes	Yes
Open weights	By July 27, 2026 (promised)	Yes (Mod. MIT)	Yes (Mod. MIT)
Thinking mode	Max effort (default at launch)	Available	Available
Architecture	KDA + AttnRes + Stable LatentMoE	MoE	MoE
Multimodal	Yes	Yes	Yes

Kimi K3 Benchmarks (With Attribution)

All K3 benchmark results below are from Moonshot’s published technical blog at kimi.com/blog/kimi-k3 unless another source is specified. Moonshot states all results were obtained with reasoning effort set to “max,” temperature 1.0, top-p 1.0. Different benchmarks used different evaluation harnesses (KimiCode, Claude Code, or Codex), which is noted where it matters for comparability.

Moonshot’s own statement on positioning: “While its overall performance still trails the most powerful proprietary models, Claude Fable 5 and GPT 5.6 Sol, Kimi K3 demonstrated frontier-level performance across our evaluation suite, consistently outperforming other tested models.” That’s an unusually candid vendor disclosure. Read the benchmark numbers in that context.

Coding Benchmarks

Benchmark	Kimi K3	Claude Fable 5	GPT 5.6 Sol	Claude Opus 4.8	GLM-5.2
DeepSWE	67.3% (KimiCode)	Higher (with fallback*)	Competitive	Lower	Per GLM-5.2 blog
Terminal-Bench 2.1	Published (KimiCode)	Benchmark ref**	Benchmark ref**	Benchmark ref**	Benchmark ref**
FrontierSWE	Published (KimiCode)	Higher	Per Codex harness	Per published scores	Per Z.ai blog
Program Bench	Published (KimiCode)	Not benchmarked	Per vals.ai	N/A	Per Z.ai blog
SWE Marathon	Published (Claude Code)	Higher	Per Codex	Published	Per Z.ai blog

*Moonshot notes Claude Fable 5 was evaluated by a third party and results may include fallback behavior (falling back to Claude Opus 4.8 when Fable 5 refuses).

**For Terminal-Bench 2.1, Claude models used the Terminus 2 harness, GPT 5.5/5.6 Sol used Codex, and GLM-5.2 used Claude Code per Moonshot’s footnotes. Cross-harness comparisons require caution.

The honest read: Kimi K3 posts competitive coding numbers, sits below Claude Fable 5 and GPT 5.6 Sol on the hardest benchmarks, and outperforms Claude Opus 4.8 and GLM-5.2 on most evaluated tasks, per Moonshot’s published results. Independent third-party validation on standard public leaderboards was limited at the time of publication.

Productivity and Agentic Benchmarks

Benchmark	Kimi K3	Notes
BrowseComp (1M context, no compression)	90.4%	Moonshot results
BrowseComp (with context compaction at 300K)	Lower	Comparable to published Claude model card scores
OfficeQA Pro	Published	Claude Code harness; PDFs as images
SpreadsheetBench 2	Published	Claude Code harness
MCP Atlas (500-task subset)	Published	Gemini 3.1 Pro as judge, 100-turn limit
AutomationBench (600-task subset)	Published	Official GitHub setup

Kernel Optimization (Long-Horizon Coding Case Study)

Moonshot ran a structured evaluation: each model given up to 24 hours independently in an identical sandbox to optimize GPU kernels across four tasks spanning AttnRes, KDA, and a 512-head-dimension MLA kernel on NVIDIA H200 and an alternative-vendor GPGPU. Per Moonshot’s published results, Kimi K3 performed competitively with Claude Fable 5 (with fallback) and substantially outperformed Claude Opus 4.8, GPT 5.6 Sol, and GPT 5.5. Moonshot notes that an early version of K3 handled the majority of the team’s own kernel optimization work during late-stage development.

What K3 Is Actually Capable Of

Beyond the benchmark table, Moonshot published specific case studies. These are vendor-selected examples illustrating ceiling performance, not typical workflow averages.

MiniTriton compiler. In a structured evaluation, Kimi K3 built MiniTriton, a Triton-like compiler with its own tile-level IR layer over MLIR, optimization passes, and a PTX code-generation pipeline. Per Moonshot’s published results, MiniTriton delivered performance on par with or better than Triton and torch.compile on supported roofline benchmarks. The model built a coherent end-to-end compiler rather than isolated kernels.

Chip design in 48 hours. K3 designed a chip for a nano model based on its own architecture, autonomously using open-source EDA tools on the Nangate 45nm library in a single 48-hour run. Per Moonshot’s published specs: within 4mm², closes timing at 100MHz, sustains over 8,700 tokens/s decode throughput in simulation, with 1.46M standard cells, 0.277MB SRAM, and an INT4 MAC array.

Astrophysics research reproduction. To reproduce I-Love-Q universal relations in computational astrophysics, K3 reviewed and cross-validated 20+ papers, implemented the full numerical pipeline, evaluated 300+ equations of state, identified inconsistencies in published formulas, generated 3,000+ lines of Python, and produced an interactive HTML dashboard. Moonshot says this took approximately two hours versus the typical one to two weeks for an experienced researcher. Vendor-reported claim.

42-year ASIC industry research report. An interactive research report built through 120+ rounds of recursive self-improvement, 2,800+ web searches and fetches, 1,100+ terminal data pulls, spanning 11,000+ pages from 87 quarterly reports and 99 original PDFs.

Kimi K3’s own teaser video. K3 edited its own launch video from 56 source clips, handling clip selection, motion-matched cuts, frame-accurate beat synchronization, audio processing, and multiple revision rounds. Moonshot estimates this would take an experienced editor one to two working days.

These are ceiling demonstrations. They tell you what the model is optimized for (long-horizon autonomous tasks, multimodal reasoning, coding that requires sustained context) rather than what a typical session will look like.

Kimi K3 Pricing and API

API Pricing

Per Moonshot’s published API pricing at platform.kimi.ai:

Token type	Rate
Input (cache miss)	$3.00 per million tokens
Input (cache hit)	$0.30 per million tokens
Output	$15.00 per million tokens

Moonshot reports a cache hit rate above 90% on coding workloads via their Mooncake disaggregated inference architecture. In practice, for long coding sessions with repeated context, the effective input cost is substantially lower than the $3.00 cache-miss rate. To illustrate: if your workload achieves roughly a 90% context-cache hit rate (similar to the coding workloads Moonshot discusses), your effective input cost would average about $0.57 per million input tokens (90% of $0.30 + 10% of $3.00). Actual costs depend entirely on your application’s cache hit rate.

That said, K3 is token-hungry compared to earlier models. Per independent observer commentary cited by eesel.ai at launch, K3 tends to consume more tokens than comparable models to complete the same task, especially with always-on max-effort reasoning enabled. At the $15.00 output rate, the effective cost per completed task can run higher than a raw per-token comparison suggests.

The max_completion_tokens default is 131,072 tokens, configurable up to the full 1,048,576-token context window. Set an explicit, smaller limit unless the task genuinely requires a long response.

One important note: the web search tool on the K3 API is flagged as “being updated” in Moonshot’s documentation as of launch and is not recommended for production use yet. Vision input via public image URLs is also not supported; send base64-encoded image data or use ms:// file references.

Consumer Subscription Access

K3 is available within Kimi’s paid subscription plans. Moonshot’s consumer pricing is primarily published in RMB and varies by region. See the official membership page at kimi.com/membership/pricing for current plans and regional pricing. A launch promotion runs through August 11, 2026 offering 10 to 30% bonus credits on API recharges.

Moonshot has signaled that Kimi and Kimi Code benefits may be split into separate products going forward. If you’re subscribing primarily for coding workflows, monitor the pricing page for that separation.

K2.5 and Moonshot-v1 Retirement

Per Moonshot’s platform notice: new users cannot access kimi-k2.5 or moonshot-v1 as of July 17, 2026. Both are marked for full retirement August 31, 2026. K2.7 Code is not in that notice and remains available at $0.95 input / $4.00 output per million tokens. For routine coding tasks that don’t require K3’s 1M context or max-effort reasoning, K2.7 Code remains the more economical default.

How to Use Kimi K3

Chat and agents: kimi.com or the mobile app (iOS, Android, HarmonyOS). K3 is now the default model for paid subscribers.

Kimi Work: Update to Kimi Work desktop version 3.1.0 or later. Available for Windows and Apple Silicon Macs.

Kimi Code (terminal): Run Kimi Code in your terminal. Select K3 with the /model command, then specify kimi-k3.

API: Base URL is https://api.moonshot.ai/v1. Model ID is kimi-k3. The API is OpenAI-compatible. Point any OpenAI-SDK client at the base URL and use your Kimi API key.

from openai import OpenAI

client = OpenAI(
    api_key="your-kimi-api-key",
    base_url="https://api.moonshot.ai/v1"
)

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "user", "content": "Your prompt here"}
    ],
    max_completion_tokens=8192  # set explicitly; default is 131,072
)

Important: Preserve the complete assistant message, including the reasoning history, across multi-turn and tool-calling sessions. Keeping only the content field (and dropping the thinking content) can make later turns unstable. This is documented as a known sensitivity in K3’s behavior.

Do not switch to K3 mid-session. K3 was trained in preserved-thinking-history mode. Switching from another model to K3 in the middle of a conversation can make generation quality highly unstable. Start a fresh session.

Open weights: Expected on Hugging Face under Modified MIT license by July 27, 2026. Self-hosting requires supernode configurations with 64 or more accelerators for practical inference efficiency, per Moonshot’s deployment guidance. Most teams will use the API rather than self-hosting at this scale. Moonshot has also contributed a KDA-compatible prefix caching implementation to the vLLM community, to be released alongside the weights.

Kimi K3 vs K2.7 Code: Which Should You Use?

The choice isn’t always K3.

Factor	Kimi K3	Kimi K2.7 Code
Context window	1M tokens	256K tokens
API input (cache miss)	$3.00/M	$0.95/M
API output	$15.00/M	~$4.00/M
Token consumption	Higher (always-on reasoning)	Lower
Best for	Long-horizon agentic tasks, large codebases, multimodal reasoning	Routine coding, smaller context, cost-sensitive workloads
Open weights	By July 27, 2026	Available now

Use K3 when: the task genuinely needs the 1M context window, requires extended multi-step autonomous reasoning, involves visual multimodal input, or pushes the boundaries of what K2.7 Code could complete. Long repository-spanning refactors, complex research synthesis, kernel optimization, chip-level engineering tasks.

Stick with K2.7 Code when: the task fits in 256K context, involves routine coding where max-effort reasoning would be overkill, or where API cost per task matters more than raw capability ceiling.

Kimi K3 vs Other Models

Factor	Kimi K3	Claude Fable 5	GPT 5.6 Sol	GLM-5.2
Total parameters	2.8T	Not disclosed	Not disclosed	744B
Context window	1M	200K	128K	1M
Open weights	By July 27, 2026	No	No	Yes (MIT)
API output price	$15.00/M	Higher	Higher	$4.40/M
Coding benchmarks	Below Fable 5/GPT 5.6 Sol; above Opus 4.8/GLM-5.2 (per Moonshot)	Strongest overall	Strongest overall	Competitive
Multimodal	Yes	Limited	Yes	No
Data routing	China (Moonshot)	US (Anthropic)	US (OpenAI)	China (Z.ai)

Moonshot explicitly states K3 trails Claude Fable 5 and GPT 5.6 Sol on overall performance. That’s a notable disclosure from a lab’s own product announcement. It sets honest expectations: K3 is the strongest open-weight model at this scale, not the strongest model overall.

Kimi K3 Limitations

Moonshot published these explicitly in the technical blog. Worth reading carefully.

Sensitivity to thinking history. K3 was trained in preserved-thinking-history mode. If the agent harness doesn’t pass back all historical thinking content, or if a session switches from another model to K3 mid-conversation, generation quality can become highly unstable. Use a verified-compatible harness (Kimi Code is recommended) and always start fresh sessions with K3.

Excessive proactiveness. K3’s training emphasizes long-horizon, challenging tasks. On tasks with minor ambiguities or unclear user intent, it may make unexpected decisions autonomously rather than pausing to confirm. If your application requires the model to stay within strict boundaries and avoid improvisation, impose explicit behavioral constraints in the system prompt or in an AGENTS.md file.

User experience gap. Despite competitive benchmark performance, Moonshot notes K3 “exhibits a noticeable gap in user experience compared with Claude Fable 5 and GPT 5.6 Sol.” This is vendor-reported, which makes it more credible, not less. It suggests that benchmark performance and conversational usability are not fully correlated at this generation.

Token consumption. K3 burns more tokens than earlier models on equivalent tasks, driven by always-on max-effort reasoning. At $15.00 per million output tokens, this matters for cost-sensitive workloads. The cache-hit discount mitigates input costs significantly on coding workloads, but output cost is uncapped.

Web search not production-ready at launch. The built-in web search tool is flagged “being updated” in official docs. Don’t build production workflows around it yet.

No public vision input via URL. Image inputs must be base64-encoded or sent as ms:// file references. Public image URLs are not accepted on the K3 API at launch.

Open weights delayed. The weights were promised by July 27, 2026. Until they land, K3 is API-only regardless of its open-weight designation.

Kimi K3 Frequently Asked Questions

Final Thoughts

Kimi K3 is the most technically ambitious release Moonshot has shipped. The architectural changes (KDA, AttnRes, 16/896 MoE sparsity) are genuine departures from K2, not incremental scaling. The 2.8T parameter count is real. The 1M context window is real. The benchmark results, by Moonshot’s own disclosure, sit below Claude Fable 5 and GPT 5.6 Sol but above Claude Opus 4.8 and GLM-5.2 on most evaluated tasks.

What’s still pending: the open weights (promised by July 27), independent third-party benchmark validation on standard leaderboards, and the full technical report that Moonshot says will accompany the weight release.

The practical read: if you’re doing long-horizon agentic coding, large-context research, or multimodal reasoning workflows that were pushing K2.7 Code’s limits, K3 is the model to test. If your workloads fit in 256K context and you’re cost-sensitive, K2.7 Code remains the more economical option at roughly a quarter the output cost.

Try it at kimi.com or via the API at platform.kimi.ai. The capability ceiling is genuinely higher. The token cost to get there is also genuinely higher. Whether the trade-off works for your specific task is something your own testing will answer faster than any benchmark table.

---

All benchmark figures in this article are from Moonshot’s published technical blog at kimi.com/blog/kimi-k3 unless otherwise noted. Benchmark comparisons across models use different evaluation harnesses (KimiCode, Claude Code, Codex) as specified in Moonshot’s footnotes; cross-harness comparisons require caution. Pricing per Moonshot’s published API pricing page at platform.kimi.ai, verified July 2026. Open-weight release status reflects information available at publication; verify current availability at the MoonshotAI Hugging Face organization. API details may change as Moonshot updates the platform post-launch.

Curated by Lorphic
Digital intelligence. Clarity. Truth.