Kimi K3 on Mac: Open weights are here — why local use is still impractical

Kimi K3: A Detailed Look at Moonshot AI’s 2.8-Trillion-Parameter Model

Moonshot AI has introduced Kimi K3, its largest AI model so far. Kimi K3 is the official name; “Kimi 3” is commonly used as shorthand but is not the exact product name. The model combines 2.8 trillion total parameters, a one-million-token context window, native image and video understanding, and features aimed at long-running coding, research, and agent workflows.

Kimi K3 uses an extremely sparse mixture-of-experts design, Kimi Delta Attention, new Attention Residuals, and quantization-aware training. Moonshot says these changes allow K3 to convert training compute into capability more efficiently than Kimi K2. At the same time, this is not a model that ordinary users can simply download and run on a MacBook or Mac Studio.

The “open-source” label also needs precision. Moonshot calls K3 the first open model in the three-trillion-parameter class, and the official Kimi K3 repository now publishes the full weights, license, model summary, and technical report. That is an open-weight release, but it does not turn a 2.8-trillion-parameter model into a practical single-Mac download.

Kimi K3 is an open-weight model focused on long-horizon coding, tool use, research, and visual workflows. Its official benchmark results require cautious interpretation because evaluation harnesses differ and several results were produced by the vendor.

Kimi K3 at a glance

What is Kimi K3?

Kimi K3 is Moonshot AI’s model for tasks in which a system must plan over long periods, call tools, inspect intermediate results, correct mistakes, and complete complex projects. Moonshot primarily positions it in three areas:

1. Long-horizon coding: Large repositories, terminal operations, debugging, refactoring, and multi-hour engineering tasks.
2. Knowledge work: Research, document analysis, spreadsheets, presentations, reports, and interactive visualizations.
3. Reasoning and multimodality: Combining logical reasoning with text, images, screenshots, diagrams, and video.

K3 is designed for agentic systems. A standard language model may explain how a website should be built. An agentic model is expected to create the files, execute the code, inspect screenshots, identify visual defects, revise the implementation, and repeat the process.

Moonshot demonstrates these capabilities with browser-based 3D games, a GPU compiler created from scratch, scientific replication projects, and large industry reports. These are vendor-produced demonstrations rather than neutral product tests, but they reveal the kind of workload K3 is optimized to handle.

Architecture: How can a 2.8-trillion-parameter model be usable?

Sparse mixture of experts

Kimi K3 has 2.8 trillion total parameters, but it does not activate the entire network for every token. It uses a mixture-of-experts, or MoE, architecture in which a router selects a small set of specialized experts.

Moonshot says K3 activates 16 of 896 routed experts. This level of sparsity drastically reduces computation per token. It does not mean a local installation only needs to store the currently active experts. The full model normally needs to remain available across the distributed memory of the inference system.

The official model summary lists 104 billion activated parameters. The exact runtime footprint is still much larger because the complete expert system, shared components, metadata, runtime buffers, and cache must be available during inference.

Kimi Delta Attention

K3 is built around Kimi Delta Attention, or KDA, a hybrid linear-attention architecture. Conventional Transformer attention directly compares tokens across the context, with costs that grow rapidly as sequences become longer. Linear attention instead compresses earlier information into a bounded state, making long-sequence processing more efficient.

KDA extends the DeltaNet family with finer channel-wise forgetting. Individual feature dimensions can retain or discard information at different rates. Moonshot’s earlier Kimi Linear work reports that this approach can compete with full attention in controlled short-context, long-context, and reinforcement-learning comparisons.

K3 combines linear and conventional attention. Linear attention is not free: it saves computation and memory by compressing information into a limited state. Hybrid designs combine that efficiency with more precise retrieval from the context.

Attention Residuals

The second central component is Attention Residuals, or AttnRes. In a conventional deep network, representations are gradually accumulated through residual connections. AttnRes is designed to selectively retrieve representations from different depths instead.

In simplified terms, a later layer does not have to rely only on an increasingly accumulated representation. It can choose useful signals from earlier processing stages. Moonshot presents this as a way to improve information flow through exceptionally deep models.

Stable LatentMoE, Quantile Balancing, and Per-Head Muon

Routing among 896 experts becomes a major optimization problem. Some experts can become overloaded while others remain underused. Moonshot lists several techniques intended to address this:

• Stable LatentMoE stabilizes the highly sparse expert system.
• Quantile Balancing derives expert allocation from router-score quantiles rather than sensitive heuristic balancing parameters.
• Per-Head Muon optimizes attention heads independently.
• Sigmoid Tanh Unit and Gated MLA are intended to improve activation control and attention selectivity.

Moonshot says the architecture, training methods, and data recipes together deliver an approximately 2.5× improvement in overall scaling efficiency over Kimi K2. The term means that additional training compute should translate into capability more efficiently; it is not a 2.5× speed claim.

Quantization-aware training

According to Moonshot, K3 used quantization-aware training from the supervised fine-tuning stage onward, with MXFP4 weights and MXFP8 activations. The goal is to make low-precision inference more stable and broadly compatible with accelerator hardware.

Four bits per parameter sounds compact, but 2.8 trillion parameters still imply roughly:

• 1.4 terabytes at 4-bit
• 2.8 terabytes at 8-bit
• 5.6 terabytes at 16-bit

Those figures cover raw weights only. Metadata, routing structures, runtime buffers, cache, and other overhead increase the total requirement. Moonshot consequently recommends supernode configurations with at least 64 accelerators for deployment.

A one-million-token context window

Kimi K3 supports 1,048,576 context tokens. This is useful for:

• large software repositories,
• long-running agent sessions,
• extensive PDF and document collections,
• research reports,
• logs and execution traces,
• multimodal projects containing many images or video data.

A large context window does not guarantee that every detail is recalled or weighted equally well. Real performance depends on information position, task structure, prompting, formatting, and the agent harness.

Moonshot’s API automatically caches repeated context prefixes. When a long prefix remains unchanged, later requests can attempt a cache hit without requiring users to manage a cache ID or time-to-live value. This helps coding agents that repeatedly work with the same repository.

Native image and video understanding

K3 is natively multimodal and processes text, images, and video within the same model. In the API, images can be supplied as Base64 data or through Moonshot file identifiers. Public image URLs are not directly supported at launch. Videos are uploaded through the Files API and then referenced with an ms:// URI.

Multimodality is especially useful for coding agents. A model can:

1. implement a user interface,
2. inspect a screenshot of the rendered page,
3. identify visual defects,
4. modify components and CSS,
5. render and inspect the result again.

Moonshot describes this as “vision in the loop.” Documented use cases include frontend engineering, games, CAD, charts, presentations, and video editing.

Benchmarks: How capable is Kimi K3?

Moonshot published a large table covering coding, agentic work, knowledge, reasoning, and vision. All reported K3 scores use maximum reasoning effort. Moonshot explicitly states that K3’s overall performance still trails the strongest proprietary models, Claude Fable 5 and GPT 5.6 Sol, even though it leads some individual tests.

Selected results

Where K3 looks strongest

Long-running coding: SWE Marathon, Program Bench, and FrontierSWE cover extended software tasks rather than isolated code snippets.

Research and browsing: Scores of 91.2 on BrowseComp and 95.0 F1 on DeepSearchQA indicate strong multi-step information retrieval.

Documents and spreadsheets: OmniDocBench and SpreadsheetBench 2 align with Moonshot’s focus on professional knowledge work.

Visual reasoning: K3 is close to the leading proprietary models in several vision evaluations and produces the highest OmniDocBench score in Moonshot’s comparison.

Where K3 trails

Results vary by benchmark. GPT 5.6 Sol leads DeepSWE. Claude Fable 5 leads FrontierSWE, GDPval-AA, HLE, and several Python-assisted vision evaluations. On HLE Full, K3 scores 43.5 compared with 53.3 for Claude Fable 5.

The results do not support the claim that K3 has “beaten every US model.” They are mixed and benchmark-dependent.

Why the benchmark table needs caution

Moonshot’s evaluation is unusually broad, but it is not fully neutral:

• K3 is sometimes tested with Kimi Code, while other models use Claude Code, Codex, or Terminus.
• Some competing-model results represent the best score across multiple harnesses.
• Several evaluations are internal Moonshot benchmarks.
• Claude Fable 5 may fall back to Claude Opus 4.8 in certain cases.
• Not every result was produced by the same organization, at the same time, with identical settings.
• The repository and technical report are now available, but independent results still depend on the chosen runtime, quantization, hardware, and evaluation harness.

The table does not establish a universal and definitive ranking.

Early independent measurements

Artificial Analysis ran an early independent evaluation shortly after launch. Kimi K3 received an Intelligence Index score of 57, with measured output speed of about 62 tokens per second and time to first token of roughly 1.99 seconds through the only provider initially available.

The measurement remains provisional because it occurred immediately after launch, serving infrastructure may change, and only one provider was measured. The test also observed unusually high token generation, which may translate into greater cost and longer responses.

Agentic coding and real-world projects

Moonshot presents several published case studies:

• K3 optimized GPU kernels across different accelerator platforms.
• It developed MiniTriton, a compact Triton-like GPU compiler.
• It produced a procedural browser-based 3D game.
• During a 48-hour autonomous run, it designed a small chip for a nano model.
• It reproduced a complex computational-astrophysics workflow using more than 20 papers, over 300 equations of state, and more than 3,000 lines of Python.
• It created large industry reports using thousands of web and terminal operations.

These demonstrations do not guarantee equivalent performance on every project. They document that Moonshot trained K3 for extended, open-ended tasks involving many tool calls. The intended unit of work is a project, not merely a single function.

Kimi K3 API: Pricing and features

The official API uses the model ID kimi-k3 and follows the OpenAI SDK’s Chat Completions format.

Pricing

There is no context-length pricing tier. A request containing 500,000 uncached input tokens and producing 50,000 output tokens would cost:

• Input: 0.5 × $3.00 = $1.50
• Output: 0.05 × $15.00 = $0.75
• Total: $2.25

If the same long prefix later receives a full cache hit, the input portion falls from $1.50 to $0.15.

Output is the most expensive component. Because K3 always operates in reasoning mode and can become highly verbose on complex tasks, production systems should monitor token use and impose suitable budgets.

Python example

import os

from openai import OpenAI

client = OpenAI(
    api_key=os.environ["MOONSHOT_API_KEY"],
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k3",
    reasoning_effort="max",
    messages=[
        {
            "role": "user",
            "content": "Analyze this Python project's architecture and identify its three largest risks.",
        }
    ],
)

print(response.choices[0].message.content)

K3 always reasons and does not offer a switch to disable that behavior. The documentation supports reasoning_effort values low, high, and max, with max as the default. The older K2 thinking parameter should not be used. In multi-turn conversations and tool-calling loops, applications must return the complete assistant message, including its reasoning history, without modification. Moonshot warns that quality can become unstable otherwise.

Additional API capabilities

Kimi K3 supports:

• streaming with separate reasoning and final-answer deltas,
• function calling and required tool use,
• dynamic loading of tool definitions,
• strict JSON Schema structured output,
• Partial Mode for continuing from a supplied prefix,
• automatic context caching,
• image and video input,
• exceptionally large completion limits.

The documentation lists a default max_completion_tokens value of 131,072 and allows up to 1,048,576. In practical applications, total context, runtime, and cost make such extreme outputs unusual.

Kimi K3 on the Mac

Kimi Work for Apple silicon

Moonshot offers Kimi Work for macOS (Apple silicon). Mac users can also access K3 through the browser or use Kimi Code from a terminal.

This does not mean the 2.8-trillion-parameter model runs locally. The desktop application provides access to the Kimi platform. Moonshot’s own recommendation of at least 64 accelerators for K3 deployment indicates that full inference is designed for data-center infrastructure.

Can Kimi K3 run locally on a Mac?

For the complete model, the realistic answer is no, not on a single ordinary Mac.

Even a theoretical 4-bit representation requires around 1.4 terabytes for raw weights alone. Apple silicon offers high memory bandwidth and unified memory, but a typical consumer Mac has nowhere near the required capacity. Streaming experts from SSD storage would also be far too slow for interactive use.

Future possibilities include:

• distilled versions,
• aggressive quantizations,
• smaller derivative models,
• local interfaces backed by remote inference,
• distributed research deployments across many machines.

The official release publishes the full K3 weights and deployment materials, not a small Apple-Silicon build. For Mac users, Kimi Work, Kimi Code, the web app, or the API remain the practical routes; local experimentation requires data-center-class hardware rather than a normal Mac.

Limitations and open questions

Moonshot identifies several limitations directly.

Sensitivity to reasoning history

K3 was trained to preserve its complete reasoning and tool-use history. If an agent returns only the visible answer text, or switches from another model to K3 mid-session, generation quality may become unstable.

Excessive proactiveness

K3 is optimized for difficult, long-horizon tasks. When requirements are ambiguous or a minor problem occurs, it may make decisions on the user’s behalf. Developers should use explicit system rules, permission boundaries, and a carefully written AGENTS.md.

Open weights are available, but local Mac use remains impractical

The official repository now publishes the full weights under the Kimi K3 License, a model summary, and a technical report. The release answers several launch-day questions, including the active-parameter figure and the license. It does not remove the practical hardware barrier for a normal Mac:

• the complete model still has 2.8 trillion total parameters,
• the published runtime format is designed for accelerator infrastructure,
• hardware requirements vary with quantization, serving stack, and context length,
• independent community measurements may differ across runtimes and providers,
• safety, privacy, and operational costs still need review for a production deployment.

Official web search is not yet recommended for production

Moonshot’s API documentation says its official web-search tool is being updated and is not recommended for near-term production workflows.

Privacy and cloud dependence

Using K3 through the official API or applications sends data to Moonshot’s infrastructure. Organizations handling private source code, personal information, or regulated documents need to review the privacy policy, processing agreements, data location, and internal compliance requirements.

Kimi K3 compared with Kimi K2.7 Code and K2.6

K3 does not automatically replace every older Kimi model. K2.7 Code may remain more economical for routine software tasks. K3 fits a workflow when it is exceptionally long, multimodal, complex, or error-sensitive enough to justify the higher output cost.

Who should use Kimi K3?

K3 fits:

• developers building large coding agents,
• teams working with extensive repositories,
• research and consulting workflows,
• document, spreadsheet, and presentation agents,
• multimodal frontend and design automation,
• long tool-calling chains,
• organizations evaluating a powerful open model.

It is less suitable for:

• simple chat or classification workloads,
• extremely price-sensitive high-volume use,
• fully local operation on one Mac,
• applications where an agent must never make autonomous decisions,
• production systems requiring independently reproducible open-weight inference immediately.

Assessment

Reported benchmarks place Kimi K3 near the strongest closed models in several tasks. Its practical strengths are the long context, native vision, tool use and coding performance.

The main Mac limitation is the hardware requirement. K3 is now an inspectable open-weight release, yet full inference remains a data-center-style deployment problem; on a normal Mac, the hosted apps, Kimi Code, or the API are the realistic access paths.

Conclusion: Sparse architecture, but no small download

Kimi K3 combines Kimi Delta Attention, Attention Residuals, exceptionally sparse expert routing, and quantization-aware training.

The official results vary by benchmark. K3 leads several coding, research, automation, and document benchmarks, while trailing Claude Fable 5 or GPT 5.6 Sol in others. Moonshot itself acknowledges this mixed overall position.

For Mac users, K3 is primarily a cloud model. Kimi Work, the web application, Kimi Code, and the OpenAI-compatible API make access straightforward. Full local inference on a single Apple silicon Mac is unrealistic because of the model’s size.

The weights, license, and technical report are published. Reliable operation outside Moonshot’s infrastructure now depends on the chosen serving stack and hardware budget.

Sources

• Kimi API Platform: Kimi K3 Quickstart, accessed August 15, 2026.
• Kimi Work, accessed August 15, 2026.
• Moonshot AI: Kimi K3 – Open Frontier Intelligence, published July 16, 2026.
• Kimi Linear: An Expressive, Efficient Attention Architecture.
• Kimi API Platform: Model List and K3 API guidance.
• Artificial Analysis: Kimi K3 – Intelligence, Performance & Price Analysis, early independent results from July 17, 2026.