Moonshot AI’s Kimi K3 is the first open-source model to reach 2.8 trillion parameters, a scale that, until now, has been the exclusive territory of closed, proprietary systems. Built for long-horizon coding, agentic knowledge work, and multimodal reasoning, it activates 104 billion of those parameters per token through a sparse Mixture-of-Experts architecture, keeping inference tractable while sustaining frontier-level capability. On SWE-Marathon, a benchmark measuring sustained autonomous software engineering, K3 scores 42.0, ahead of every model in the comparison set, including Claude Fable 5 (35.0) and GPT-5.6 Sol (39.0).

What makes K3 architecturally interesting is how Moonshot got here: two attention mechanisms, Kimi Delta Attention (KDA) and Attention Residuals (AttnRes), combined with a Stable LatentMoE framework that selects 16 experts out of 896, deliver roughly 2.5x better scaling efficiency than its predecessor, Kimi K2. The model also ships with a 1-million-token context window and native vision support via MoonViT-V2, making it a credible option for the kind of multi-step, tool-using agent workflows where context depth actually matters. Full weights are available under the Kimi K3 License, meaning you can inspect, deploy, and build on top of the model, not just call an API. 

And now, it’s available through DeepInfra.

What Makes This Model Different

Kimi K3 is the first open-source model to reach 2.8 trillion total parameters, described by both Moonshot and DeepInfra as the world’s first open 3T-class model. Despite that scale, only 104B parameters are active per token, achieved through a Mixture-of-Experts architecture that routes each token to 16 of 896 experts across a 93-layer network (1 dense layer, plus a mix of 69 Kimi Delta Attention layers and 24 Gated MLA layers). Training uses MXFP4 weights with MXFP8 activations via quantization-aware training, applied from the SFT stage onward.

Compared to Kimi K2, Moonshot reports roughly 2.5x improvement in overall scaling efficiency, the result of the KDA and Attention Residuals architecture combined with improvements in training methodology and data recipes.

Kimi K3 supports a 1,048,576-token context window natively, along with multimodal inputs (text, image, and video) via the MoonViT-V2 vision encoder (401M parameters). It’s built explicitly for long-horizon agentic tasks: extended coding sessions across large repositories, GPU kernel optimization, compiler development, vision-in-the-loop game development, CAD, and chip design, all coordinated through terminal tool use with minimal human oversight. For knowledge work, it produces deep research with interactive visualizations, widgets and dashboards, and motion design and video editing, powered by its native multimodal architecture.

On benchmarks, Kimi K3 sits just behind Claude Fable 5 and GPT-5.6 Sol overall, while outperforming Claude Opus 4.8 across most evaluated tasks. A few highlights:

SWE-Marathon is worth calling out specifically: at 42.0, Kimi K3 leads every model in this comparison.

One thing to be aware of: Kimi K3 always runs with thinking mode enabled and expects the complete assistant message, including the reasoning trace, passed back on every turn in multi-turn conversations and tool calls. Reasoning effort is configurable via the reasoning_effort parameter (low, high, or max), defaulting to max. The model can also be proactive in agentic settings, taking autonomous decisions when facing ambiguity, so explicit constraints in the system prompt or an AGENTS.md file are worth setting up for bounded workflows.

Getting Started on DeepInfra

Kimi K3 is available now on DeepInfra under the model identifier moonshotai/Kimi-K3 as a public endpoint, with a private endpoint deployment option also available. Pricing is straightforward: $2.85 per 1M input tokens, $14.25 per 1M output tokens, and $0.285 per 1M cached input tokens, a 10x discount on cache hits. The model supports JSON output, function calling, and multimodal inputs out of the box.

DeepInfra gives you access to Kimi K3 through an OpenAI-compatible API with zero setup and usage-based pricing, no infrastructure to provision, no cluster to manage. DeepInfra operates under a zero-retention policy and is SOC 2 and ISO 27001 certified.

Here’s everything you need to make your first call:

cURL

curl "https://api.deepinfra.com/v1/openai/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DEEPINFRA_TOKEN" \
  -d '{
      "model": "moonshotai/Kimi-K3",
      "messages": [
        {
          "role": "user",
          "content": "Explain the tradeoffs between MoE and dense transformer architectures."
        }
      ]
    }'
copy

Python

from openai import OpenAI

client = OpenAI(
    api_key="$DEEPINFRA_TOKEN",
    base_url="https://api.deepinfra.com/v1/openai",
)

response = client.chat.completions.create(
    model="moonshotai/Kimi-K3",
    messages=[
        {
            "role": "user",
            "content": "Explain the tradeoffs between MoE and dense transformer architectures."
        }
    ],
)
print(response.choices[0].message.content)
copy

JavaScript

import OpenAI from "openai";

const openai = new OpenAI({
  apiKey: "$DEEPINFRA_TOKEN",
  baseURL: "https://api.deepinfra.com/v1/openai",
});

const response = await openai.chat.completions.create({
  model: "moonshotai/Kimi-K3",
  messages: [
    {
      role: "user",
      content: "Explain the tradeoffs between MoE and dense transformer architectures.",
    },
  ],
});
console.log(response.choices[0].message.content);
copy

The only things that differ from a standard OpenAI call are the base URL (https://api.deepinfra.com/v1/openai), your DeepInfra token, and the model name. The official OpenAI Python and Node.js SDKs work without modification.

Conclusion

Kimi K3 is a meaningful data point in the ongoing shift toward open models that can compete at the frontier, not just on paper benchmarks, but on the kind of sustained, multi-step work that real engineering workflows demand. The combination of a 1M-token context window, native vision support, and leading SWE-Marathon numbers makes it a serious candidate for teams building coding agents, research pipelines, or document-heavy applications where context depth and task continuity are non-negotiable.

Developers who get hands-on with K3 now will have a head start on understanding how large sparse models behave in production agentic settings, which is increasingly where the interesting problems live. Head to the Kimi K3 model page to run it in the playground or pull your API key and start building.