Naive-N0.5-Flash: A 309B MoE With Native 1M Context and Up to ~2,000 tok/s, Open-Sourced Under MIT by a Tsinghua-Background Team

309B total parameters, only 15.5B active per token. Native 1M context. Up to ~2,000 tok/s on the Ultrafast tier. MIT license, full weights released.

Four numbers, one message: Chinese open-source models just moved "fast" into a different league.

On September 27, 2026, NaiveAI, a Chinese AI company founded by a Tsinghua-background team, released Naive-N0.5-Flash. On NL2Repo-Bench, the official model card reports 71.9. In the comparison compiled by Latent Space, DeepSeek V4.1 Flash scores 68.2 and GLM 5.3 Flash scores 56.3. It handles text and code only, and within that lane it goes deep and fast.

This is not another "bigger parameter count" story. It is a story about response speed. When a model emits thousands of tokens per second, writing code, running Agents, and reading a repository stop being "waiting for it to think" and become "it has already answered."

The short version

• Publisher: NaiveAI (naive.ai), official X account @naiveailab, released 2026-09-27.
• License: MIT, open weights, with very low barriers to commercial use and derivative work.
• Scale: a 309B-parameter MoE that activates 15.5B parameters per token.
• Context: native 1M.
• Speed: about 50 tok/s on the official Standard tier, up to about 2,000 tok/s on the Ultrafast tier, powered by the in-house inference engine NaiveRT.
• Boundary: text and code only. No image input.
• Benchmark: NL2Repo-Bench 71.9, ahead of DeepSeek V4.1 Flash at 68.2 and GLM 5.3 Flash at 56.3 (official model card data, compiled by Latent Space).

Who built it: NaiveAI, founded by a Tsinghua-background team

NaiveAI is a Chinese AI company founded by a Tsinghua-background team. According to media reports, founder Dai Jifeng is an associate professor in the Department of Electronic Engineering at Tsinghua University. Naive-N0.5-Flash is a NaiveAI company product.

A team with academic depth chose to release its weights in full under MIT, then pushed speed to the limit with its own inference engine. Among Chinese large models, that route stands out.

Standing on open-source shoulders, then pushing speed to the limit

Naive-N0.5-Flash does not hide where it came from, and it says so with pride.

The official position: it is built on Xiaomi's MiMo-V2.5 as its base and draws on DeepSeek's DSA sparse attention. On top of that sits NaiveAI's in-house inference engine, NaiveRT. Three things stack together:

1. MiMo-V2.5 supplies a solid base. The previous leg of Chinese open-source models already laid the foundation.
2. DSA sparse attention supplies the long-context approach. DeepSeek published the method, so later teams can build directly on it.
3. NaiveRT squeezes the engineering. The official Standard (about 50 tok/s) and Ultrafast (up to about 2,000 tok/s) tiers show that the same model capability can be delivered in different service forms. NaiveRT is the engine behind the high tier.

That is the open-source relay at work. Xiaomi ran the first leg, DeepSeek handed over a method, and NaiveAI took the baton and sprinted for speed. Nobody reinvents the wheel; everyone carries someone else's result further. That is open source at its best: each leg faster than the last.

Key specs

Item	Details
Display name	Naive-N0.5-Flash
Official API model ID (main)	naive-n0.5-flash
Official API model ID (thinking off)	naive-n0.5-lite (same model, thinking turned off)
Publisher	NaiveAI (naive.ai)
Release date	2026-09-27
License	MIT, open weights
Architecture	MoE, 309B total parameters, 15.5B active
Layers	48 layers: 39 sliding-window attention (SWA) + 9 DSA sparse attention
Context	Native 1M
Speed (official)	Standard about 50 tok/s; Ultrafast up to about 2,000 tok/s
Inference engine	In-house NaiveRT
Input types	Text and code only. No image input
Base model	Xiaomi MiMo-V2.5

Architecture: why it is big, long, and fast

309B total, 15.5B active: large capacity, small compute

The MoE (Mixture of Experts) idea is blunt. The model can be huge, but each token wakes only a small subset of experts. Naive-N0.5-Flash has 309B total parameters and activates 15.5B per token. Knowledge capacity comes from 309B, while the per-step compute bill is only 15.5B. The knowledge of a big model at the step rate of a small one is the structural base for its high throughput.

39 SWA layers + 9 DSA layers: a precise split between local and global

Of the 48 layers, 39 use sliding-window attention (SWA). They look only at the local neighborhood, so their cost does not balloon with context length. 9 use DSA sparse attention, which picks the truly important positions across the whole context. Most of the computation goes to lightweight local layers, and a few global layers hold long-range dependencies together. This split is what makes native 1M context something you can actually use, not just a number in a spec table.

Native 1M: read the whole repository in one pass

What does 1M context mean? A mid-sized code repository, a full set of technical documents, or a very long conversation history can go into a single request without chunking. For code tasks, that removes a layer of information loss compared with "retrieve first, then stitch together." The model sees the complete context, not assembled fragments.

Up to ~2,000 tok/s: NaiveRT's answer

The official service has two tiers: Standard at about 50 tok/s and Ultrafast at up to about 2,000 tok/s. Behind Ultrafast is NaiveAI's own inference engine, NaiveRT. The model architecture is responsible for "computing less," and the inference engine for "computing fast." You get this number only when both are done right.

What speed actually changes

2,000 tok/s sounds like just a number. Put it into real development work and the picture changes.

Real-time completion in the IDE. You type a comment and the whole implementation fills the screen almost in sync. No spinner, no "thinking." The cursor stops and the code has already landed. Completion goes from "waiting" to "breathing," developers call it more often, and the difference compounds over a day.

Dozens of Agent calls. An Agent reads files, edits code, runs tests, reads results, and edits again. One task can take dozens of rounds. Save a few seconds per round and you save minutes per task. With faster steps, the same time budget lets the Agent try more, verify more, and has more room for the success rate to rise.

A long repository, read in one go. 1M context plus high throughput means you can hand the model an entire codebase and ask for a complete refactoring plan, instead of repeatedly slicing within a window limit. Reading everything and answering fast is what long context should look like.

Batch jobs, in parallel. Code review, documentation generation, and test completion can run in parallel. With high throughput, total time drops directly.

Trading time for quality. When it is fast enough, there is room to let the reasoning chain run longer. "Thinking longer" used to be a luxury. Now it can be a routine option.

Speed is not the goal. It changes the rhythm of working with a model, from "submit, then wait" to "talk, then keep going."

Why this matters for Chinese open source

Discussion of Chinese open-source models has often stopped at "how many parameters" and "where it ranks." Naive-N0.5-Flash opens a new angle: among open models, who can make inference fast enough to surprise developers.

That angle has three layers.

First, open source is more than releasing weights. The MIT license means teams can deploy, fine-tune, and integrate on their own, without layers of licensing restrictions. With the weights in hand, the choice stays with the developer.

Second, engineering becomes the competitive edge. The base comes from MiMo-V2.5, and the sparse-attention approach comes from DeepSeek's DSA. Both are publicly available building blocks in the open-source ecosystem. NaiveAI put its effort into the inference engine NaiveRT and made "the same blocks, assembled for more speed" its own signature. In the open-source era, engineering excellence is itself a moat.

Third, Chinese open source has formed a relay. One team's result becomes another's starting point, and one team's method is verified, improved, and released again by the next. The loop keeps speeding up, and every user benefits: more models to choose from, a lower cost of trial and error, a faster pace of iteration.

Four keywords to read the technical report card

If you want to remember only the technical essentials, these four words are enough.

MoE. 309B total parameters are the "knowledge warehouse," and 15.5B active parameters are the "real compute per step." A big warehouse means ample capacity. Touching only a small part per step means speed.

SWA. Sliding-window attention, 39 of the 48 layers. It lets most layers focus on nearby content, keeping cost under control.

DSA. Sparse attention, the remaining 9 layers. It picks key positions from the whole context and pulls back the distant information that actually matters.

NaiveRT. The in-house inference engine, the link that turns architectural advantage into "tokens per second."

Strung together, the logic is clear: MoE to compute less, SWA to contain long-context cost, DSA to keep the global view, NaiveRT to deliver the speed.

Ways to use it worth imagining

The following are usage ideas based on the official specs and capability boundaries. They do not describe any case that has actually happened.

• Code review pipeline: put the whole repository into context at once and get cross-file change suggestions. Native 1M shows its value most clearly here.
• IDE assistant: completion, explanation, and refactoring suggestions return almost in sync, so waiting does not interrupt the developer's attention.
• Multi-step Agent: read, modify, test, and review in a loop. The faster each step, the smoother the whole chain.
• Docs and code in sync: load long documents and the codebase into context together and check whether interface descriptions match the implementation.

These scenarios share one trait. They amplify the two strengths, speed and context length, and they all stay within text and code, matching the model's capability boundary.

What third parties say: the Latent Space review

On November 10, 2026, Latent Space published a review written by Gabriele Beltramo. All data below comes from that article. It is not a test run by Guishu Intelligence.

Benchmark results

NL2Repo-Bench scores (official model card data, compiled by Latent Space):

Model	NL2Repo-Bench
Naive-N0.5-Flash	71.9
DeepSeek V4.1 Flash	68.2
GLM 5.3 Flash	56.3

Measured speed

The Latent Space review reports:

• a measured peak of about 2,100 tok/s, slightly above the official 2,000 tok/s;
• about 984 tok/s in the thinking phase and about 1,816 tok/s in the answering phase;
• a median end-to-end time of 3.1 seconds, against 10.1 seconds for DeepSeek.

Application case

In the "generate a solar system app" case, Naive-N0.5-Flash performed best. On tree-structure tasks, it was close to DeepSeek.

Reading the numbers with care

Keep the three conditions given in the original review in mind:

• Naive's speed was measured on the official server, while the other models went through OpenRouter, so the two paths differ;
• average times were close, at 45.3 seconds and 45.0 seconds;
• on hard problems, average times were 89.8 seconds versus 79.7 seconds, because of longer reasoning chains.

Chinese media are also watching this model. QbitAI (量子位) relayed it in a WeChat article on November 13, 2026. That article is a secondhand roundup, so defer to the original Latent Space piece for the numbers.

Who it fits, and for what

A strong fit:

• latency-sensitive interactive code completion and in-IDE Q&A;
• repository-level understanding and rewriting that needs a large context;
• teams that need private deployment and want a permissive license (MIT);
• Agent loops with frequent calls, where every wait gets multiplied.

Boundaries to know up front:

• it handles text and code only, so tasks needing image input require a different model;
• official benchmark scores are a reference, and real business results should still be judged on your own tasks.

How developers can connect a model like this through a compatible API

For models served through an API that follows the Chat Completions style, the approach is broadly the same: configure the endpoint, key, and model ID, and send requests with streaming. Below is a generic example. The endpoint and key are placeholders. Follow the official API documentation and the instructions of the service you use.

curl -N "https://<your-provider-or-official-endpoint>/v1/chat/completions" \
  -H "Authorization: Bearer <your API key>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "naive-n0.5-flash",
    "stream": true,
    "messages": [{"role": "user", "content": "Write a thread-safe LRU cache in Python"}]
  }'

Before integrating, check each of these:

1. Model ID: the official main model is naive-n0.5-flash, and the thinking-off version is naive-n0.5-lite;
2. Streaming: use streaming, especially for a high-throughput model, or you will not see the speed;
3. Input type: send text only, no images;
4. Timeouts and retries: long-context requests and long reasoning chains both need wider timeouts;
5. Your own eval set: run real tasks first, then decide whether to switch.

What makes an evaluation convincing? Pick 20 to 50 real tasks from your own codebase. Record time to first token and total time separately, and compare naive-n0.5-flash with naive-n0.5-lite. For code tasks, run the tests and look at the pass rate. Then put a real repository into the 1M window and test it as its own round. The conclusions you get are data you can put into your own technology-selection document.

Guishu Intelligence is following developments in fast open-source models like this. It is currently in the evaluation stage and makes no commitment on availability dates.

FAQ

Who made Naive-N0.5-Flash? It was released by NaiveAI, a Chinese AI company founded by a Tsinghua-background team. According to media reports, founder Dai Jifeng is an associate professor in the Department of Electronic Engineering at Tsinghua University. Naive-N0.5-Flash is a NaiveAI company product, released on September 27, 2026.

Was it trained from scratch? The official statement confirms it is built on Xiaomi's MiMo-V2.5 as its base and draws on DeepSeek's DSA sparse attention. Together with the in-house inference engine NaiveRT, the focus is on optimizing inference speed to the limit.

Is it open source? What is the license? The weights are open, under the MIT license.

What is the API model ID? The main model is naive-n0.5-flash. naive-n0.5-lite is the same model with thinking turned off.

Where does 2,000 tok/s come from? The official claim is up to about 2,000 tok/s on the Ultrafast tier, backed by the in-house inference engine NaiveRT. Latent Space measured a peak of about 2,100 tok/s.

Does it support 1M context? Yes, native 1M context. Architecturally it comes from 39 sliding-window attention layers plus 9 DSA sparse attention layers working together.

Does it support image input? No. It focuses on text and code.

What is it good for? Code generation, repository-level understanding, Agent loops, and latency-sensitive interactive development.

Wrap-up

MIT open source. A 309B MoE that activates only 15.5B. 39 SWA layers plus 9 DSA layers carrying native 1M context. The in-house NaiveRT pushing speed to an official peak of about 2,000 tok/s. A score of 71.9 on NL2Repo-Bench.

Xiaomi's MiMo-V2.5 as the base, DeepSeek's DSA as the idea, NaiveAI taking the engineering to the limit. It is a fine relay for Chinese open-source models, and it gives a new answer to "how fast can a code model be?"

The keywords for this model are open weights, long context, and response speed. When all three show up in one model, every team building code tools, Agents, or developer platforms should take a serious look.

For developers, the best response is to try it yourself: read the official documentation, run your own tasks, and let the data speak.

References

• NaiveAI official research page: https://naive.ai/en/research/
• Hugging Face model page: https://huggingface.co/NaiveAI/Naive-N0.5-Flash
• NaiveAI API quick start: https://platform.naive.ai/docs/api-quick-start
• NaiveAI official X (@naiveailab): https://x.com/naiveailab/status/2104247060186951725
• Latent Space review (Gabriele Beltramo, 2026-11-10): https://latent.space/p/naiveai/
• QbitAI WeChat article (2026-11-13, secondhand relay): https://mp.weixin.qq.com/s/d2PycGL_WwpYgcdB9dssMQ