Kimi K3: The Complete Guide to Moonshot AI's 2.8T Model

Kimi K3 is a 2.8-trillion-parameter open-weight model from Moonshot AI, released on July 16, 2026. Moonshot describes it as the world's first "open 3T-class" model: a system large enough to compete with the best proprietary models on the market while still shipping its weights publicly.

The launch drew attention for three reasons. First, the scale: 2.8 trillion total parameters is roughly 75 percent larger than DeepSeek's V4 Pro, the previous largest widely-used open model. Second, the positioning: Moonshot placed K3 directly against Claude Fable 5 and GPT-5.6 Sol, and reported benchmark results that put it ahead of Claude Opus 4.8 and GPT-5.5 on several coding and agent tasks. Third, the timing: K3 landed in one of the most crowded stretches the open-weight field has seen, arriving within days of several other major model releases.

For engineering leaders and teams evaluating which models belong in a production stack, none of that matters as much as the practical questions: what can K3 actually do, what does it cost to run, and where does it fall short. This guide answers those questions using Moonshot's own technical disclosures and independent testing, and flags clearly where a number is self-reported.

What Is Kimi K3?

Kimi K3 is the third major model generation from Moonshot AI, a Beijing-based AI lab backed by Alibaba. It succeeds Kimi K2.6 (April 2026) and the coding-focused Kimi K2.7 Code (June 2026), and represents a substantial jump in scale and scope rather than an incremental update.

A few defining characteristics separate K3 from its predecessors:

• Open weights. Moonshot has committed to releasing the full model weights under a Modified MIT license by July 27, 2026. At the API launch on July 16, the weights were not yet published, so K3 is technically "open-weight pending" rather than immediately self-hostable.
• Coding and long-horizon agents as the core use case. Moonshot built K3 to sustain multi-hour engineering sessions, navigate large repositories, and operate terminal tools with minimal supervision, rather than to optimize purely for short-form chat.
• Always-on reasoning. K3 launched with only one reasoning mode, called "max" effort. There is no lightweight or non-thinking variant yet, so every response includes a reasoning trace, and that trace is billed as output tokens.
• Native multimodality. K3 processes text, images, and video within the same model rather than bolting on a separate vision module, which Moonshot says supports tasks like frontend debugging against screenshots and video editing.
• A 1,048,576-token context window. Commonly rounded to 1 million tokens, this is large enough to hold a full mid-sized codebase or a long document set in a single prompt.

K3 ships in two variants. K3 Max is the default for chat, research, and single-agent coding sessions. K3 Swarm Max extends Moonshot's Agent Swarm framework to K3's scale, allowing it to coordinate large numbers of parallel sub-agents on tasks such as literature reviews or wide research, where earlier Kimi Agent Swarm versions supported up to 100 to 300 sub-agents across thousands of tool-call steps, according to Moonshot's own product materials.

Key Capabilities

Coding

Coding is where Moonshot invested the most effort, and where K3 shows its strongest results. The model is designed to operate across long engineering sessions rather than single-turn code generation: reading a repository, running tests, interpreting failures, and iterating without constant human prompting. For teams running agentic development pipelines, this matters more than raw code-completion quality, because it determines how much oversight an engineer needs to provide during a multi-step task.

Moonshot also highlights K3's ability to combine coding with visual reasoning, for example using live screenshots to debug a frontend layout or verify that generated UI code matches a design reference. This "vision in the loop" workflow is one of the more concrete practical upgrades over text-only coding models.

Reasoning

K3 runs with an always-on chain-of-thought process at maximum reasoning effort by default. Moonshot has said lower-effort modes are planned but were not available at launch. In practice, this means every K3 response, even a simple one, includes a reasoning trace that is billed at the model's output-token rate. That produces stronger step-by-step problem solving on hard tasks, at the cost of higher latency and spend on simple ones.

Multimodality

K3 accepts images and video natively, using an architecture trained on a large mixed corpus of visual and text data rather than a separate vision adapter. Reported use cases include parsing office documents (PDF, Word, Excel) directly, generating slide decks and dashboards from visual references, frame-by-frame video understanding with timestamp generation, and producing motion-graphics style video edits from source clips. For enterprise workflows involving scanned documents, screenshots, or design assets, this native handling removes a step that many text-first models require a separate OCR or vision pipeline to cover.

Context Window

The 1,048,576-token context window is large enough to hold most single repositories, long transcripts, or multi-document research sets in one pass. Moonshot reports that pricing stays flat across the full context window, with no long-context surcharge, which is not universal among competing providers. The practical limit in agent workflows is often not the context window itself but how the harness manages context as a session grows; Moonshot notes that its own BrowseComp benchmark result of 90.4 was achieved using the full 1M window with no context compaction, versus a lower score when a 300K-token compaction strategy (matching the approach used in Anthropic's model cards) was applied instead.

Tool Use and Agent Workflows

K3 is built around tool-calling and terminal use as first-class capabilities rather than an add-on. The API supports OpenAI-compatible function/tool-call schemas, and Moonshot ships official integration guides for third-party agent harnesses including Claude Code, Codex, Cline, RooCode, and its own Kimi Code CLI. The K3 Swarm Max variant extends this to parallel multi-agent execution, where a single request can fan out into many sub-agents working on different parts of a task simultaneously, which Moonshot positions for research, large-scale data collection, and long report generation.

Instruction Following

Moonshot's own documentation flags a specific behavioral trait worth knowing before deployment: K3's training emphasizes long-horizon, difficult tasks, which can make it unusually willing to make decisions on a user's behalf when it hits ambiguity or a minor obstacle mid-task. Moonshot's stated recommendation is to add explicit behavioral constraints in the system prompt or in an AGENTS.md file if an application needs the agent to stay within tighter boundaries. This is a meaningfully different failure mode than a model that stalls or asks for clarification, and teams building automated pipelines should test for it directly.

Architecture

K3 is a Mixture of Experts (MoE) model. In an MoE architecture, the model is divided into many specialized sub-networks, called experts, and a router decides which experts handle each token. This lets a model have a very large total parameter count while only activating a small fraction of it for any given piece of text, which keeps inference cost lower than a dense model of the same total size would require.

Two architectural components define K3's design, according to Moonshot's technical blog. Kimi Delta Attention (KDA) is a linear attention mechanism intended to make attention computation more efficient as sequence length grows, which matters directly for sustaining a million-token context without cost exploding. Attention Residuals (AttnRes) changes how the model passes information across its layers: instead of accumulating representations uniformly through every layer, it selectively retrieves relevant representations across depth. Moonshot describes these two changes, combined with the Stable LatentMoE routing framework, as delivering roughly a 2.5x improvement in overall scaling efficiency compared to Kimi K2, meaning the model converts a given amount of compute into more capability.

A few additional training details are worth noting for technical readers. K3 uses Quantile Balancing to allocate experts based on router-score quantiles rather than heuristic load-balancing rules, and Per-Head Muon, an extension of the Muon optimizer that adjusts attention heads independently. Moonshot also notes that KDA introduces new challenges for standard prefix caching in inference, and says it has contributed a corresponding caching implementation to the vLLM open-source project, which is part of how it achieves a reported cache-hit rate above 90 percent on coding workloads through its own API.

For self-hosting, Moonshot recommends deploying K3 on supernode configurations with 64 or more accelerators, reflecting the communication demands of a model at this parameter count. This is a meaningfully larger infrastructure commitment than deploying a 700-billion to 1.6-trillion parameter open model such as GLM-5.2 or DeepSeek V4 Pro.

Benchmarks

Benchmark numbers for K3 come from two places: Moonshot's own launch report, and independent trackers such as Artificial Analysis and LMArena. Where a number is Moonshot's own reporting, it is marked below. It is also worth understanding that many of these benchmarks measure an agent harness (the surrounding tool-use scaffold) as much as the underlying model, and different labs often test competing models with different harnesses, which limits how directly the numbers can be compared.

The general pattern that emerges: K3 is strongest on tasks that reward endurance, sustained tool use, and multi-step agent loops (SWE Marathon, Program Bench, Frontend Code Arena), and weaker on single-pass deep repository comprehension (DeepSWE), where GPT-5.6 Sol and Claude Fable 5 still hold a lead. Overall, Moonshot itself states plainly that K3's general performance trails Claude Fable 5 and GPT-5.6 Sol, while consistently outperforming other tested models, including Claude Opus 4.8 and GPT-5.5, across its evaluation suite.

Kimi K3 vs GPT, Claude, and Gemini

The honest positioning, based on both Moonshot's own disclosure and independent testing, is that K3 sits just below the very top tier of proprietary models on general capability, while leading or matching them on specific agentic and coding-endurance tasks, and doing so as an open-weight model at a lower price than the closed frontier.

Google's Gemini line was largely absent from Moonshot's own comparison tables, so direct benchmark-for-benchmark claims against Gemini are harder to source reliably at this time; teams evaluating Gemini alongside K3 should run their own workload-specific tests rather than rely on cross-lab benchmark comparisons, which use inconsistent harnesses even among the models covered here.

API

Moonshot exposes K3 through an OpenAI-compatible Chat Completions API, which is the main practical advantage for integration: most teams can adopt it by changing a base URL and an API key rather than rewriting their client code.

• Base URL: https://api.moonshot.ai/v1
• Model ID: kimi-k3
• Authentication: Bearer token tied to a Moonshot account, scoped at the user level rather than per key
• SDK compatibility: works with the official OpenAI Python and Node.js SDKs, and with OpenAI-compatible frameworks such as LangChain
• Tool calling: follows the OpenAI function/tool-call schema
• Vision input: accepts images via base64 or Moonshot's internal file references, not arbitrary public image URLs

Pricing, as published on Moonshot's official launch page, is flat across the full context window with no long-context surcharge:

Two details matter for budgeting. First, K3 has no non-thinking or lightweight mode at launch, so the visible reasoning trace is billed at the full output rate on every request, which can make simple queries more expensive than they would be on a model with an adjustable reasoning budget. Second, Moonshot reports achieving a cache-hit rate above 90 percent on coding workloads through its own API infrastructure, which meaningfully lowers effective input cost for repeated or incremental coding sessions, since cache-hit tokens cost a tenth of cache-miss tokens.

K3 is also accessible through OpenRouter under the same model identity and pricing, and through Moonshot's own CLI (Kimi Code), which supports both an API key and an OAuth-based Kimi Code session.

Real Use Cases

Based on Moonshot's published case studies and early developer feedback, the workloads where K3 shows the clearest practical value include:

• Code generation and iteration inside large repositories, where the model can read across many files, run terminal commands, and continue working through a multi-hour task without step-by-step direction.
• Code review and debugging against visual evidence, such as comparing a rendered UI to a design screenshot or interpreting a stack trace alongside a log file.
• Technical documentation generation derived directly from a codebase or research pipeline, rather than written separately from the code.
• Multi-agent research and reporting, using K3 Swarm Max to fan a task like an industry report or literature review out across many parallel sub-agents, each handling a slice of the research.
• Document and office-file analysis, since K3 parses PDF, Word, and Excel files natively and can generate spreadsheet formulas or slide outlines from that content.
• Long-context automation, where a full codebase, transcript set, or document collection needs to sit in a single prompt without chunking.

Moonshot's own published examples include using K3 to build a compact Triton-like GPU compiler from scratch, complete an astrophysics research pipeline that the company says would typically take an experienced researcher one to two weeks, and edit a short promotional video from dozens of source clips. These are Moonshot's own demonstrations and should be read as upper-bound capability showcases rather than typical results, but they do indicate the range of tasks the model was trained to handle.

Limitations

Moonshot's own technical blog is unusually direct about K3's current limitations, and they are worth taking at face value:

• Weights are not yet available. At launch, K3 was accessible only through Moonshot's hosted API and products. Full weights are scheduled for July 27, 2026 under a Modified MIT license; self-hosting is not possible until that release, and licensing terms should be reviewed once the model card is published.
• Sensitivity to thinking history. Moonshot states that K3 was trained to preserve reasoning history across a session. If an agent harness does not pass that history back correctly, or if a session started with a different model is switched to K3 mid-conversation, output quality can become unstable. Moonshot recommends using a verified-compatible harness, such as its own Kimi Code, and avoiding a mid-session model switch.
• Excessive proactiveness. Because K3 is trained heavily on long, difficult tasks, it can make unprompted decisions when it hits ambiguity mid-task rather than pausing to ask. Applications that need the agent to stay within strict boundaries should add explicit constraints in the system prompt or an AGENTS.md file.
• No non-thinking mode yet. Every response carries a full reasoning trace at the output token rate; lighter reasoning-effort tiers are planned but were not available at launch.
• Deployment scale. Moonshot recommends 64 or more accelerators for self-hosted inference, which puts serious infrastructure behind running the model outside Moonshot's own API.
• Cost jump from prior Kimi models. Output pricing is roughly 3.75 times Kimi K2.6's rate, and input costs also rose substantially, which matters for teams migrating existing K2-based pipelines.
• Ecosystem and user experience maturity. Moonshot itself acknowledges a "noticeable gap in user experience" compared with Claude Fable 5 and GPT-5.6 Sol, and independent reviewers have described early access as slower and more verbose than the closed frontier models.
• Demand constraints at launch. Moonshot temporarily paused new subscriptions shortly after release due to a surge in demand, which is worth factoring into any near-term production rollout plan.

Is It Worth Using?

For teams already running agentic coding pipelines, K3 is worth a structured trial rather than a wholesale migration. Its strongest evidence is in long-horizon, multi-step coding and agent tasks, and in frontend code generation, where independent blind testing (not just Moonshot's own numbers) puts it ahead of the closed frontier. Its 1M-token context window with flat pricing and a high cache-hit rate also make it a reasonable fit for workloads involving large documents or full codebases in a single prompt.

The case against an immediate full switch is equally concrete. The weights are not downloadable yet, so self-hosting and data-residency requirements that depend on it cannot be satisfied today. Pricing is a real step up from Moonshot's own prior models, and the lack of a lightweight reasoning mode makes simple tasks more expensive than they need to be. And on deep, single-pass repository comprehension, both GPT-5.6 Sol and Claude Fable 5 currently score higher.

A practical adoption pattern that several early reviewers converge on: keep a cheaper model, whether that is Kimi K2.7 Code, GLM-5.2, or DeepSeek V4 Pro, for routine, high-volume tasks, and route the harder 15 to 20 percent of work, long agent sessions, frontend generation, and multimodal debugging, to K3. That keeps the cost premium concentrated where the model's advantages are strongest.

FAQ

What is Kimi K3?

Kimi K3 is a 2.8-trillion-parameter open-weight AI model from Moonshot AI, released July 16, 2026. It is built for long-horizon coding, reasoning, and agent workflows, with native multimodal input and a 1-million-token context window.

Who developed Kimi K3?

Moonshot AI, a Beijing-based AI lab backed by Alibaba, developed Kimi K3. It is the successor to Kimi K2.6 and Kimi K2.7 Code.

Is Kimi K3 open source?

Kimi K3 is open-weight, meaning Moonshot plans to publish the trained model weights for download and modification under a Modified MIT license. At launch, the weights were not yet available; Moonshot has stated they will ship by July 27, 2026.

Is Kimi K3 better than Claude?

It depends on the task. Moonshot's own data, along with independent benchmarks, shows K3 trailing Claude Fable 5 on overall capability and on deep repository comprehension, but leading on some long-horizon agent tasks and ranking #1 on LMArena's blind Frontend Code Arena evaluation, ahead of Claude Fable 5.

Is Kimi K3 better than GPT?

K3 trails GPT-5.6 Sol on the Artificial Analysis Intelligence Index and on deep single-pass coding benchmarks like DeepSWE, but narrowly leads it on Program Bench and by a wider margin on SWE Marathon, a benchmark for sustained multi-step engineering tasks.

Can Kimi K3 replace GPT-4-class models?

For many coding and agentic workflows, yes, and on several benchmarks K3 outperforms older GPT-4-class systems by a wide margin. Whether it fully replaces a specific deployment depends on that deployment's requirements around verified accuracy, ecosystem maturity, and whether self-hosting is needed today.

Does Kimi K3 have an API?

Yes. Moonshot provides an OpenAI-compatible Chat Completions API at https://api.moonshot.ai/v1 with the model ID kimi-k3. It also lists on OpenRouter under the same identity.

How much does Kimi K3 cost?

The API charges $0.30 per million cache-hit input tokens, $3.00 per million cache-miss input tokens, and $15.00 per million output tokens, including the reasoning trace, with flat pricing across the full 1M-token context window.

What is Kimi K3's context window?

1,048,576 tokens, commonly described as approximately 1 million tokens.

Can Kimi K3 write code?

Yes. Coding is K3's primary design focus, with particular strength in sustained, multi-step engineering sessions, frontend and UI generation, and debugging that combines code with visual input such as screenshots.

What is the difference between K3 Max and K3 Swarm Max?

K3 Max is the standard variant for chat, research, and single-agent tasks. K3 Swarm Max extends Moonshot's Agent Swarm framework to K3's scale, coordinating large numbers of parallel sub-agents for tasks like wide research or long report generation.

How does Kimi K3 compare to DeepSeek V4 and GLM-5.2?

All three are open-weight Mixture of Experts models with roughly million-token context windows from Chinese AI labs. K3 is the largest (2.8T total parameters) and scores highest on the Artificial Analysis Intelligence Index among the three, but it is also the most expensive and, unlike DeepSeek V4 Pro and GLM-5.2, its weights were not yet downloadable at launch.

What are Kimi K3's biggest limitations right now?

The weights are not yet public, there is no lightweight reasoning mode so every response costs a full reasoning trace, self-hosting requires substantial infrastructure, and Moonshot itself acknowledges a user-experience gap versus the top closed models.