Moonshot AI just launched Kimi K3, and this isn’t a routine upgrade to the K2 family.
The new flagship packs 2.8 trillion total parameters, a 1 million-token context window, native visual understanding, always-on reasoning, and an architecture built for the kind of long-running agent work that usually makes models lose the plot.
It’s available through the Kimi API right now under the model ID kimi-k3. Moonshot has also published an official setup guide for running K3 inside Hermes Agent.
There’s one important caveat: Moonshot is calling K3 an open-source model, but the downloadable weights and full technical report aren’t available yet. The company says both are coming within the next few days.
So, yes, K3 is live. But the open-source part of the launch hasn’t fully landed.
Kimi K3 at a Glance
- 2.8 trillion total parameters
- 1 million-token context window
- Native image and video understanding
- Always-on thinking mode
- 16 active experts out of 896
- OpenAI-compatible API
- Official integrations for Hermes Agent, Codex, Claude Code, Cline, and RooCode
- Model weights and technical report coming soon
K3 is Moonshot’s largest model by a ridiculous margin. The recently released Kimi K2.7 Code model has roughly 1.1 trillion total parameters and a 256K context window. K3 more than doubles the total parameter count and quadruples the available context.
Our previous K2.7 Code coverage was mostly about coding efficiency, speed, and price. K3 is aiming higher. Moonshot is positioning it as a frontier model for software engineering, deep research, multimodal work, and long-horizon agents that need to keep working without constantly compressing or forgetting what happened earlier.
What’s Actually New in Kimi K3?
The 2.8 trillion parameter count is the number that’ll grab the headlines, but the architecture underneath it matters more.
K3 uses Kimi Delta Attention, a hybrid linear-attention design Moonshot introduced through its earlier Kimi Linear research. It also adds Attention Residuals, which are meant to improve how information moves through deeper models and extremely long sequences.
The model uses a highly sparse Mixture-of-Experts architecture called Stable LatentMoE. It contains 896 experts, but only 16 are activated for each token. That’s how Moonshot can pack an enormous amount of capacity into K3 without firing up all 2.8 trillion parameters for every word it generates.
Moonshot says this combination gives K3 roughly 2.5 times the scaling efficiency of K2.
That’s still a vendor claim until the technical report and independent testing arrive. But it does explain how Moonshot is attempting to serve a model this large without turning every API call into a bonfire of compute.
It’s Built for Long-Horizon Coding Agents
Moonshot is calling K3 its strongest coding model, even though K2.7 Code remains the cheaper option built specifically for coding workloads.
The distinction matters. K3 isn’t just supposed to write better functions. It’s designed to keep making progress across long software-engineering tasks that involve tools, visual feedback, failed attempts, and a lot of moving parts.
That includes:
- Understanding large codebases
- Operating terminals and development tools
- Coordinating multiple tool calls
- Reading screenshots, logs, and test results
- Recovering when the first approach fails
- Moving between source code and rendered output
Moonshot specifically calls out frontend development, game development, CAD workflows, and infrastructure optimization as areas where K3’s combination of coding, vision, and spatial reasoning should matter.
That’s where coding agents are headed anyway. Writing a function isn’t the hard part anymore. The real test is whether a model can inspect a broken system, use the right tools, understand what changed, make several coordinated fixes, and recover without needing a human to restart the entire job.
K3 was built to attack that problem.
The Benchmark Claims Are Big
According to Moonshot’s own evaluations, Kimi K3 ranks behind only Claude Fable 5 and GPT-5.6 Sol in overall intelligence among the models it tested.
The company highlights three knowledge-work results:
- GDPval-AA v2: K3 scores 1687, ahead of Claude Opus 4.8 at 1600 and behind Fable 5 Max and GPT-5.6 Sol Max.
- AA-Briefcase: K3 scores 1527, placing second behind Fable 5 Max and ahead of GPT-5.6 Sol Max at 1495.
- BrowseComp: K3 scores 91.2 in a single-agent setup without context compression.
Those aren’t small claims, especially the BrowseComp result. A 1M-token context window gives K3 room to keep a huge amount of research material available without repeatedly summarizing, compressing, or throwing away earlier context.
But let’s keep the launch-day benchmark confetti under control.
The full technical report hasn’t been published. The weights aren’t downloadable yet. Independent evaluators haven’t had enough time to put K3 through real workflows. Until that happens, these numbers tell us what Moonshot believes it built, not the final verdict on how well it performs outside its own test environment.
Kimi K3 Pricing
K3 is live through Moonshot’s OpenAI-compatible API with the following pricing per million tokens:
| Usage | Kimi K3 Price |
|---|---|
| Cached input | $0.30 |
| Standard input | $3.00 |
| Output | $15.00 |
That’s significantly more expensive than Kimi K2.7 Code, which costs $0.19 for cached input, $0.95 for standard input, and $4.00 for output.
K3 is roughly 3.2 times more expensive for uncached input and 3.75 times more expensive for output than K2.7 Code.
The product split is pretty clear:
- Use K2.7 Code when coding throughput and cost matter most.
- Use K3 when the task needs Moonshot’s strongest reasoning, massive context, multimodal understanding, or long autonomous execution.
K3 also supports automatic context caching. You don’t need to manually create cache IDs or wire up a separate caching system. Reuse the same long prompt prefix and the API will attempt a cache hit automatically.
That could matter a lot for agents repeatedly working inside the same repository, research corpus, or long-running project. At K3’s standard input price, cache hits aren’t a cute optimization. They’re part of the cost strategy.
Kimi K3 Works With Hermes Agent
This is the part that makes the launch especially relevant around here.
Moonshot published an official Kimi K3 setup guide for Hermes Agent. The integration uses Kimi’s OpenAI-compatible API and the existing Kimi/Moonshot provider inside Hermes.
During setup, choose Kimi/Moonshot as the provider and set kimi-k3 as the default model.
Existing Hermes Agent users can reopen the provider setup wizard with:
hermes modelThe full provider-prefixed model identifier is:
moonshot/kimi-k3That means K3 can plug directly into Hermes Agent’s memory, tools, subagents, messaging integrations, and learning system. You don’t have to wait for Moonshot to build another closed agent wrapper around the model before you can put it to work.
For long research jobs and complex coding goals, Hermes Agent paired with a 1M-context model could be a monster combination. The real question is whether K3 can use that context intelligently over hours of work instead of merely stuffing more tokens into the prompt.
That’s what we’ll need to test.
What’s Still Missing?
Kimi K3 is live, but the launch isn’t complete.
Moonshot says the following are still coming:
- Full downloadable model weights
- The Kimi K3 technical report
- More architecture and training details
- Additional reasoning-effort levels
K3 currently runs with thinking mode permanently enabled, and the API only supports reasoning_effort="max". Moonshot says more effort levels are planned.
The documentation also warns that Kimi’s official web-search tool is being updated and isn’t currently recommended for production workflows. Custom tools and external search providers are still available through normal function calling.
That’s worth knowing before anybody points an autonomous research agent at K3 and assumes every part of the stack is production-ready on day one.
The Bottom Line
Kimi K3 looks like one of the biggest open-model launches of 2026, but the word “open” needs an asterisk until the weights actually arrive.
What’s available today is still substantial: a 2.8-trillion-parameter flagship with a 1M-token context window, native vision, long-horizon agent capabilities, an OpenAI-compatible API, and official Hermes Agent support.
It’s also priced like a frontier model, not a bargain alternative. K3 will need to prove that its extra intelligence, context, and agent endurance are worth paying several times more than K2.7 Code.
The next real test starts when the weights, technical report, and independent benchmarks land. Until then, the API is live, Hermes Agent support is documented, and K3 is ready for actual workflows instead of another round of launch-slide worship.
Sources
- Official Kimi K3 documentation
- Kimi API Platform and pricing
- Official Kimi K3 guide for Hermes Agent
