Note: This article is based on the information available on July 17, 2026. The model weights, pricing, availability, and benchmark positions can still change.
Kimi K3 Just Launched
Kimi K3 just launched, and it is already making noise.
Moonshot AI is positioning it as a serious model for coding, agents, large codebases, and long-running tasks. According to the official announcement, it has 2.8 trillion total parameters, a one-million-token context window, native visual understanding, and a mixture-of-experts architecture.
Those are big numbers, but the interesting part is what the model is meant to do. K3 can work across a repository, use terminal tools, review screenshots, and continue difficult engineering tasks with limited supervision. It is available through Kimi, Kimi Work, Kimi Code, and the Kimi API.
That puts it directly in competition with the strongest coding models from OpenAI and Anthropic.
What Is Different About K3?
K3 uses Kimi Delta Attention and Attention Residuals to handle information more efficiently across long contexts and deep models. Its mixture-of-experts design contains 896 experts but activates 16 at a time. This gives the model a lot of total capacity without using all 2.8 trillion parameters for every token.
At launch, the API only supports maximum reasoning effort. Pricing is $0.30 per million cached input tokens, $3 for normal input, and $15 for output. Caching can make long coding sessions cheaper, but K3 also appears to use a lot of reasoning and output tokens.
This is why price per token only tells part of the story. What matters is the cost of reaching a correct result.
The Benchmarks Look Impressive
K3 performs very well on coding, terminal, agent, and long-horizon benchmarks. Axios reported that launch-period blind comparisons placed it ahead of leading US models for frontend coding.
Moonshot also showed larger examples: optimizing GPU kernels, building a small compiler, reproducing scientific work, and running a chip-design task for 48 hours.
That is impressive, but benchmark comparisons need context. The models were not always tested with the same coding agent. Some results used Kimi Code, while others used Claude Code, Codex, or another harness. Those tools provide different prompts, permissions, retry logic, and context management.
So a benchmark is not only measuring the model. It is often measuring the model, the agent, and the test setup together.
Artificial Analysis independently placed K3 near the frontier, but also measured slower-than-average output and very high token use. The model can be powerful without being the fastest or cheapest choice for every task.
Early Experiences Are Mixed
K3 has only been available for a short time, so early user reports should be treated as anecdotes, not proof.
Some developers are impressed by its persistence. One user reported that it continued working on a visual coding task for around four hours instead of giving up. Others report good results on complex backend and compiler work.
At the same time, users also describe Kimi Code with K3 as slow, expensive in tokens, and limited by subscription quotas. Some still prefer the older K2.7 model for certain tasks.
Both experiences can be true. A model may generate tokens slowly but solve the complete task with fewer retries. Or it may work for hours and still produce something that cannot be accepted.
The useful measurement is not tokens per second. It is time to a tested, reviewed, and correct result.
Powerful Does Not Mean Reliable
This is the main takeaway for me.
AI models are becoming much more capable, but confident output can still contain serious mistakes. That risk becomes larger with agents because they can change many files and make decisions while we are not watching every step.
Moonshot itself lists two important limitations. K3 can become unstable if an agent does not preserve its complete thinking history, or if you switch to it halfway through an existing session. The Kimi Code documentation recommends starting a new session when changing models.
K3 can also be too proactive. When a requirement is unclear, it may make unexpected decisions on the user’s behalf. In a real codebase, that can mean changing unrelated files, choosing a dependency you did not ask for, or solving the wrong problem very convincingly.
Developers still need to review the diff, run the tests, understand the architecture, and verify the result. A model can speed up the work, but the team still owns the quality.
Why Open Models Matter
Moonshot says the full K3 weights will be released by July 27, 2026. Until that happens, I would describe K3 as a hosted model with a promised open-weight release, not as a model developers can already download and inspect.
If the weights arrive under useful terms, that still matters. More open models mean more competition, more choice, lower prices, and less dependency on a small number of providers.
K3 is far too large for most teams to run locally—the recommended deployment uses at least 64 accelerators—but open weights can still help researchers, hosting providers, and companies build specialized versions.
How I Would Evaluate It
I would not choose K3 from a leaderboard alone. I would test it on a small set of real tasks from my own codebase:
- Fix a real bug with existing tests.
- Add a feature that touches multiple files.
- Refactor a module without changing its public behavior.
- Navigate an unfamiliar part of a large repository.
- Compare total time, retries, review effort, and cost per accepted change with other models.
Every run should use the same agent harness, instructions, permissions, repository state, and acceptance criteria. The result should pass automated acceptance tests and the complete test suite, then survive a human code review. I would also work on an isolated branch so every agent change is easy to roll back.
The Real Takeaway
Kimi K3 looks like a serious new competitor. Its coding performance, long context, and ability to continue difficult tasks deserve attention.
But benchmarks are not reliability, and a powerful model is not automatically the right model for every job.
The AI race just gained another strong competitor. Developers gained another useful option—and another output stream they need to verify.