National Supercomputing Internet Access Kimi K3: 2.8-Trillion-Parameter Open-Source Model on the Path to Becoming National Infrastructure

The National Supercomputing Internet has connected Kimi K3.

Within the past two days, the National Supercomputing Internet officially launched the API calling service for the Kimi K3 model. Enterprises and developers no longer need to wrestle with environment configuration, fight for GPU cards, or build inference frameworks themselves—just log in to the official website, click a few buttons, and directly call this open‑source large model with 2.8 trillion parameters. The interface is compatible with both OpenAI and Anthropic API specifications—meaning you can basically run it by just changing the base_url and key in your existing code.

The symbolic meaning of this move is arguably more significant than the technical one. A state‑backed compute platform is providing official API access to an open‑source model released less than a week ago—this would have been unthinkable in the past.

What is Kimi K3

First, let’s introduce the main character. On July 16, Moonshot AI released Kimi K3, with a total of 2.8 trillion (2.8T) parameters, using an MoE architecture—currently the largest open‑source model (by total parameters) in the world. What does that mean? DeepSeek V3 has 671B parameters; even the dense Qwen3‑Max doesn’t reach this size. Kimi K3 has effectively raised the parameter ceiling for open‑source models by a large margin.

More importantly, it’s not just brute‑forcing parameters. K3 introduces two self‑developed architectural innovations:

• Kimi Delta Attention (KDA): a hybrid linear attention mechanism. Official data shows it achieves 2.5× better scaling efficiency than K2. In plain terms, it means that when processing long contexts, compute and memory demands grow much slower.
• Attention Residuals: dynamically weight attention outputs from different layers to mitigate information loss that comes with extremely deep networks.

It supports a 1‑million‑token context window, natively handles image and video inputs, and can “generate code from images”—for example, taking a design mockup and directly outputting front‑end code.

After launch, K3 shot up the leaderboards. On the Frontend Code Arena ranking, K3 took first place in 6 of 7 front‑end code test categories, outperforming all major closed‑source models. On the Text Arena overall ranking, it scored 1486 points and ranked 9th—making it the first open‑source model to enter the global top ten. The previous generation K2.6 ranked 38th, so this is a dramatic leap.

Of course, there’s still a reality check. The top model is still the closed‑source Claude Fable 5 (~1509 points). The Vision Arena multimodal rankings are still dominated by closed‑source models, and K3 hasn’t cracked the top 20 there. The gap between open and closed‑source models remains, but it’s narrowing. Some analyses conclude that “it tops specific sub‑tasks but overall trails frontier models by 2 – 3 months,” which seems reasonable.

Why the National Supercomputing Internet is doing this

A 2.8‑trillion‑parameter model has such a high deployment threshold that most teams wouldn’t even consider running it locally. Even with MoE (fewer active parameters), loading full weights and hosting inference still requires far more than a handful of GPUs. This creates an awkward situation: the model is open‑sourced, weights are hosted on Hugging Face for anyone to download, but very few teams can actually use them.

The National Supercomputing Internet fills this gap. It pools the underlying compute resources and offers the models as services—developers only need an API key. The platform already collects the major open‑source models from MiniMax, DeepSeek, Qwen, GLM, and Kimi, covering text, image, video, audio, and multimodal capabilities.

From a product perspective, it’s similar to commercial AI aggregation platforms—using a unified API to abstract away model heterogeneity. The difference is that the Supercomputing Internet is backed by the national computing network and operates as public infrastructure: pay‑as‑you‑go, domestic network access, guaranteed compliance—perfect for government, enterprise, research, and education scenarios where data export sensitivity is a concern.

An interesting part is protocol compatibility. Supporting both OpenAI and Anthropic standards is a very pragmatic decision. The OpenAI format is the de facto standard, while Anthropic’s Messages API is native to tools like Claude Code and Cursor. Supporting both means that applications migrating from either ChatGPT or Claude ecosystems can run seamlessly.

The era of unified invocation for open‑source models

Let’s zoom out. Over the past year and a half, the boom of Chinese open‑source large models needs no proof—DeepSeek, Qwen, GLM, MiniMax, and Kimi are all iterating quarterly. Yet on the user side, there’s long been fragmentation:

• To use DeepSeek → go to DeepSeek’s platform
• To use Qwen → go to Alibaba Cloud Bailian
• To use Kimi → go to Moonshot’s platform
• To compare them → integrate three or four SDKs, manage multiple keys, and handle several billing systems.

This mirrors the early days of cloud computing—AWS, Azure, and GCP each had their own APIs until tools like Terraform unified abstraction layers. Large models are following the same trajectory, only faster: the protocol layer is now implicitly OpenAI‑compatible, and the race is on to gather all models behind one interface.

The National Supercomputing Internet is building the “public‑infrastructure” version of aggregation. In the market, many commercial aggregator platforms are doing similar things—for example, services like OpenAI Hub allow one key to call GPT, Claude, Gemini, DeepSeek, Kimi, etc., with domestic connections, token‑based billing, and OpenAI‑compatible formatting. New models like K3 are typically integrated right after release. For developers, a unified entry point means one less integration headache.

The value of aggregation isn’t just convenience—it’s in lowering model switching costs. When calling Kimi K3 or Claude Sonnet only requires changing one parameter, migration from closed‑source APIs to open‑source models becomes less of a slogan and more of a configuration tweak. For low‑complexity, high‑frequency tasks—summarization, classification, simple code completion—it makes economic sense to switch to cheaper open‑source models and save budget for truly frontier‑grade tasks.

What this means for developers

Some concrete takeaways:

1. Long‑context scenarios finally have a domestic option.
With a 1 million‑token context and “smart caching” that the team says cuts effective input costs to about one‑tenth of list price, applications dealing with long documents, large codebases, or multi‑turn conversations have a whole new cost model. Legal document analysis, repo‑scale copilots, long‑form content generation—this context length is sufficient.

2. Front‑end code generation is unexpectedly strong.
Securing six out of seven firsts in the Frontend Code Arena isn’t trivial—use‑cases like UI generation, component scaffolding, and design‑to‑code deserve serious benchmarking with K3.

3. Agent workflows now have a better mid‑tier option.
Before, you’d wince at Claude Sonnet’s price for high‑frequency steps, yet cheaper models weren’t smart enough for complex reasoning. K3 breaks into the top ten for instruction following and code generation, priced like an open‑source model—filling the middle ground perfectly.

4. An easier compliance path for sensitive data.
Using domestic infrastructure like the National Supercomputing Internet simplifies regulatory review versus calling foreign APIs. Teams in finance, healthcare, and government can rest easier.

Points to watch with caution

Hype aside, a few realities remain:

• Inference speed: At 2.8 T parameters even with MoE, throughput won’t match 671 B‑scale models. Low‑latency workloads still need benchmarking.
• Multimodality remains weak: In the Vision Arena, open‑source models still trail far behind; K3 hasn’t changed that—closed‑source remains dominant for visual tasks.
• Stability needs verification: It’s only been live a week. Stress tests, long‑term stability, and edge‑case behaviors all require time. Run staged rollouts before production use.
• Benchmarks ≠ business results: Arena scores reflect general preferences; for real applications, run your own evaluation sets.

A broader trend

Viewed on a longer timeline, a structure is taking shape:

Upstream — model builders racing on parameters, architecture, and multimodality;
Midstream — compute platforms turning models into services, APIs, and aggregates;
Downstream — developers combining models through unified interfaces.

Once these layers decouple, innovation in each accelerates—no more waiting on the others.

Kimi K3’s addition to the National Supercomputing Internet is just one node in that chain, but its signal is unmistakable: open‑source large models are no longer “download weights and tinker” toys—they are becoming general‑purpose capabilities, provided like utilities, hosted by public infrastructure, aggregated by commercial platforms, and callable on demand by developers.

For most developers, it means you can finally stop agonizing over “should I self‑deploy.”
Pick a convenient gateway, get a key, and start building.

References

• Hugging Face – Moonshot AI official model repository: official release location for Kimi K3 open weights and model card
• Zhihu – Technical analysis and community testing of Kimi K3: in‑depth discussion of KDA architecture and Attention Residuals
• linux.do – Practitioners’ feedback on Kimi K3 API integration: developer reports on the Supercomputing Internet’s API compatibility and stability tests