Naive-N0.5-Flash: Open coding model hits up to 2,100 tokens per second in testing

Chinese startup NaiveAI has released Naive-N0.5-Flash, an open coding model built for speed. Latent Space tested it against DeepSeek V4.1 Flash and GLM 5.3 Flash. It answers most questions much faster than either, but on hard problems it can think for a very long time.

Model releases Try it yourself Nov 10, 2026 7 min read Source: Latent Space

The key points in brief

Naive-N0.5-Flash is built on Xiaomi's MiMo-V2.5, a Mixture-of-Experts model with 310 billion parameters, 15 billion of which are active per token.
NaiveAI retrained the model on DeepSeek Sparse Attention using about 3.25 trillion additional tokens, roughly 3 trillion of them at a context length of 1 million tokens.
According to NaiveAI, the model reaches about 984 tokens/s while thinking, 1,816 tokens/s while answering and briefly up to 2,100 tokens/s on a server with eight Blackwell GPUs.
In Latent Space's test, the median response time was 3.1 seconds, compared with 5.3 seconds for GLM 5.3 Flash and 10.1 seconds for DeepSeek V4.1 Flash.
On hard questions with thinking enabled, the model used about 108,500 tokens on average, roughly nine to eleven times as many as its rivals.
Target API pricing is $0.10 per million input tokens and $0.40 per million output tokens.

What's going on

Chinese company NaiveAI has released Naive-N0.5-Flash, an open-weights model for programming tasks. That means anyone can download the weights. The model's main selling point is speed. NaiveAI says it should help development and research teams test and refine ideas faster. The company has bigger plans, too: it claims the model was largely built by AI itself and trained to do AI research. Its long-term goal is "recursive self-improvement", meaning an AI that keeps making itself better.

Tech blog Latent Space picked the model to kick off a new test series. It compared it with two popular Flash models that see heavy use on OpenRouter: DeepSeek V4.1 Flash 1017 and Z.ai's GLM 5.3 Flash. The test used Naive-N0.5-Flash's "Ultrafast" mode.

Where the model comes from

Naive-N0.5-Flash isn't built from scratch. It's a further development of Xiaomi's MiMo-V2.5, a sparse Mixture-of-Experts model. It consists of many specialized subnetworks ("experts"), and only a few of them do any work for each token. It has 310 billion parameters in total, but only 15 billion are active per token. MiMo-V2.5 was trained on 48 trillion tokens. Its language component combines sliding-window attention, where the model only looks at a slice of the text, with global self-attention, where it sees the whole thing.

NaiveAI kept training these weights in several stages and switched them over to DeepSeek Sparse Attention (DSA). With DSA, the model focuses only on the most important parts of the text, which makes long inputs cheaper to process. According to NaiveAI's technical blog, this took about 3.25 trillion additional tokens. Around 3 trillion of those were trained at a fixed context length of 1 million tokens with a constant learning rate. The goal was better reasoning over long texts. On top of that comes a custom inference engine called NaiveRT, the software that actually runs the model.

Vendor benchmarks compared

At the time of testing, Artificial Analysis didn't yet have an Intelligence Index score for Naive-N0.5-Flash. DeepSeek V4.1 Flash 1017 (Max) scores 45 there, GLM-5.3-Flash 43. Here are the benchmarks published by the vendors themselves:

Model	NL2Repo-Bench	DeepSWE v1.1	Agent's Last Exam (ALE)
GLM-5.3-Flash	56.3	63.4	26.3
DeepSeek V4.1 Flash 1017	68.2	77.0	35.4
Naive-N0.5-Flash	71.9	67.8	32.4

On coding, Naive-N0.5-Flash lands between its two rivals. It only takes the lead on NL2Repo-Bench, where a model has to build an entire software repository from a description. These numbers come from the vendors' model cards and blogs and haven't been independently verified.

Speed: fast, but sometimes very chatty

Latent Space gave each model 30 questions, 10 from each of three difficulty levels: easy ones from MATH-500, medium ones from GPQA-Diamond and hard ones from HLE-Diamond. The output limit was 256,000 tokens. The test measured tokens per second, the number of tokens generated and the total time to a finished answer. The code is available at github.com/gbeltramo/llm-verbosity.

The results:

Throughput: In both thinking modes, Naive-N0.5-Flash hit around 1,000 tokens per second or more. However, those numbers were measured directly on the server, while the rivals' figures come from OpenRouter. That's why Latent Space explicitly declines to name an exact speed advantage.
Verbosity: On the hard HLE questions, Naive-N0.5-Flash with thinking enabled produced about 108,500 tokens on average. That's roughly nine times as much as GLM 5.3 Flash (high) and eleven times as much as DeepSeek V4.1 Flash (high).
Median vs. mean: The median, the value right in the middle, was only about 3,200 tokens across all 30 questions. The mean, by contrast, was over 51,000 tokens. A handful of extremely long reasoning runs pull the average way up.
Response time: Naive-N0.5-Flash (thinking) took a median of 3.1 seconds, GLM 5.3 Flash (high) 5.3 and DeepSeek V4.1 Flash (high) 10.1 seconds. The averages are closer together: 45.3 seconds for Naive, 45.0 for DeepSeek and 86.9 for GLM. On the hard questions, Naive was actually slower than DeepSeek on average, at 89.8 versus 79.7 seconds.

Latent Space points out two caveats. The sample is small, and the answers weren't checked for correctness. Fast answers only help if they're right.

Where the speed comes from

The speed comes mainly from speculative decoding. A small helper model, the "drafter", guesses several tokens ahead, and the large model checks those guesses all at once. The drafter here is Naive-N0.5-Flash-FP8-Draft. According to NaiveAI, measurements were taken on a single server with eight Nvidia Blackwell GPUs, tuned for single-request speed rather than many concurrent users.

Without thinking, the large model accepts 70.6 percent of the drafter's proposals; with thinking, only 43.4 percent.
While thinking, the model reaches about 984 tokens per second; while answering, 1,816.
The peak of around 2,100 tokens per second was measured over a single second and should be read as an upper bound.

The engine also plays a big part. According to the developers, a full speculative round of drafting, verification, sampling and acceptance takes 3.4 milliseconds in NaiveRT, compared with 12.3 milliseconds in the widely used SGLang engine. That's 72.4 percent less.

Hands-on: three web apps

Every model had to build three web apps from the same prompt, each at low and high reasoning effort:

3D solar system: Naive-N0.5-Flash (thinking) delivered the best result here, complete with sunspots and city lights on Earth's night side. DeepSeek came a close second but was missing the asteroid belt and surface detail on Earth. GLM botched the lighting, and its speed sliders were too sensitive.
Procedural 3D tree in the wind: DeepSeek and Naive (thinking) did well. Without thinking, though, Naive didn't produce a usable app at all. In DeepSeek's version, thin branches broke off the tree in strong wind; in GLM's, the whole tree wobbled "like a jelly sculpture in an earthquake".
Raytracer based on the book "Ray Tracing in One Weekend": With thinking enabled, all three apps worked. DeepSeek won with the most efficient code. Naive's app worked correctly, but its JavaScript was less efficient. GLM again came last because of its bare-bones interface.

Pricing

For API use, NaiveAI is targeting $0.10 per million input tokens, $0.40 per million output tokens and $0.01 per million cache-read tokens, meaning inputs that are already cached. That puts the model in the usual Flash-class range of $0.20 to $0.60 per million output tokens. But because it generates so many tokens on hard tasks, Latent Space notes that a single question can end up costing a bit more.

What you need to try it

You're unlikely to run this model on your own machine at home. With 310 billion parameters, it needs roughly 190 GB of VRAM (video memory) even with 4-bit quantization, where the numbers are stored more coarsely. Only servers with several professional GPUs can handle that. Although only 15 billion parameters are active per token, all the experts still have to sit in memory. The advertised speeds also only apply to a server with eight Blackwell GPUs, NaiveRT and the matching drafter. The source doesn't say whether ready-made GGUF files for llama.cpp or Ollama exist. For most people, the API is the realistic route. Macs, CPU-only setups or Google Colab are practically out of the question.

Our take

Naive-N0.5-Flash is an interesting case: an open model that bets heavily on speed and largely keeps up with the most popular Flash models on coding tasks. In Latent Space's test, it was consistently faster on easy and medium questions. On hard problems, though, it burns through huge numbers of tokens, and the speed advantage disappears. Plenty of questions remain. The speed figures were measured on the server and aren't directly comparable with the OpenRouter numbers. Answer accuracy wasn't checked, and independent scores from Artificial Analysis are still missing. The big promises of self-improving AI are pure marketing so far. A more interesting point is one Latent Space highlights: cheaper generation thanks to DSA could speed up reinforcement learning, where models learn through trial and reward and text generation is the biggest bottleneck. If you care more about fast iteration than frugal token use, the model is worth a try.

Terms explained simply

Mixture of Experts (MoE): A model made up of many specialized subnetworks. Only a few of them work on each token, so it runs faster than its total size would suggest.
Speculative decoding: A small helper model guesses several tokens ahead, and the large model checks them in a single step. The more guesses are correct, the faster the text is generated.
DeepSeek Sparse Attention (DSA): An attention method in which the model focuses only on the most important parts of a long text. This saves compute.
Tokens per second: How many word pieces a model outputs per second. It's the standard measure of text generation speed.
Thinking mode: The model writes out an internal reasoning process before its actual answer. Answers are often better as a result, but take longer and use more tokens.
Inference engine: The software that runs a finished model and computes its answers. NaiveAI's is called NaiveRT.
Median: The value right in the middle when all measurements are sorted. Individual outliers distort it less than they distort the average.

Sources

Latent Space latent.space
dev.to #ai dev.to

#open-weights#coding#naiveai#speculative decoding#benchmark

Read the original source

Try it yourself: Naive-N0.5-Flash

Explained step by step, no prior knowledge needed – on your own computer or free in your browser.

What can I do with it?

Naive-N0.5-Flash is a language model specialized in programming. It writes code, builds complete small web apps from a description and solves math and knowledge questions. Its strength is speed: on the right hardware, it answers easy and medium tasks much faster than DeepSeek V4.1 Flash or GLM 5.3 Flash. In the vendor benchmarks, it sits between those two on coding and even leads at generating entire repositories (NL2Repo-Bench). In Latent Space's test, it built the most detailed 3D solar system with thinking enabled. Without thinking, however, it failed at a more complex 3D app. On hard problems it thinks for a very long time and uses a lot of tokens. With 310 billion parameters, running it locally only makes sense on large multi-GPU servers.

Who is it worth it for?

The model is interesting for teams and researchers with their own GPU servers who want to self-host a fast, open coding model. It's also worth a look if you research agent workflows or reinforcement learning. It isn't suitable for running locally on an ordinary PC or laptop. If that's you, use the API or go for a smaller model.

Ideas: What you can do with it

Prototypes in minutes

Describe a small web app, such as a calculator, a dashboard or a mini game, and have it generated as a single HTML file. Thanks to the high speed, you can request several variants in a row and pick the best one.

3D visualizations for the classroom

Have it build an interactive solar system or physics model with Three.js where you can rotate the camera and control the speed. In testing, the model did this in particularly rich detail with thinking enabled.

Fast code iteration for teams

Plug the model into a coding agent that makes lots of small changes in sequence. Because simple answers often arrive within a few seconds, you spend less time waiting on the AI.

Whole repositories from a description

Provide a project description and let the model create the folder structure, files and tests. On the NL2Repo-Bench benchmark, it beats DeepSeek V4.1 Flash and GLM 5.3 Flash, according to the vendor.

Experiments for AI research

Research teams can use the model for the many rollouts in reinforcement learning, where fast generation is the biggest bottleneck. The sparse attention it uses makes these runs cheaper.

Size310 B parameters (15 billion active)

Download87 GB (about 1.9 hr at 100 Mbit/s)

Licensemit

TypeLanguage model (text chat)

Hugging FaceNaiveAI/Naive-N0.5-Flash

What your computer needs

Graphics card (NVIDIA), fully in VRAM at least 97 GB VRAMservers only, with multiple data-center GPUs (e.g. 8× H100) – fastest; with less VRAM, see the next line

Graphics card + system memory (MoE offloading) from approx. 9 GB VRAM + 128 GB RAMdie Experten liegen im Arbeitsspeicher, nur der Kern auf der Grafikkarte (llama.cpp/LM Studio). Langsamer als komplett im VRAM, aber auf normalen PCs machbar

Mac (Apple Silicon M1–M5) from 192 GB unified memoryThe GPU and CPU share the memory – the model can use about 70% of it

CPU only (no graphics card) Very slow without a graphics cardan estimated 2 words per second on a current desktop PC (MoE: only 15 billion parameters active per word). This requires at least 128 GB of RAM.

Storage approx. 89 GB freeModel download plus programs

Google Colab too big for Colabeven the largest Colab GPUs aren't enough

According to the source, there's the main model Naive-N0.5-Flash and the drafter Naive-N0.5-Flash-FP8-Draft for speculative decoding. The advertised speeds only apply when both run together with the NaiveRT engine on a server with eight Blackwell GPUs. The source says nothing about official quantized variants or GGUF files. At 4-bit, expect roughly 190 GB of VRAM (video memory), and correspondingly more at higher precision.

The vendor's figures (around 984 to 1,816 tokens/s, peaking at 2,100) were measured on a single server with eight Nvidia Blackwell GPUs.
310 billion parameters in total: even with 4-bit quantization you need roughly 190 GB of VRAM, meaning several data center GPUs.
Only 15 billion parameters are active per token. That makes the model fast, but not small, because all experts have to be held in memory.
The model is trained for a context length of 1 million tokens. Long contexts take up a lot of additional memory.
Full speed requires the NaiveRT engine and the Naive-N0.5-Flash-FP8-Draft drafter. With SGLang, a speculative round takes 12.3 instead of 3.4 milliseconds, according to the vendor.
Consumer GPUs, Apple Silicon Macs, CPU-only setups or Google Colab are practically not enough for this model.

Groß (310 B parameters, MoE): running entirely on the GPU takes a lot of VRAM (video memory). With MoE offloading, a regular graphics card plus plenty of RAM is enough (see table). Colab Free isn't enough.

How do I find out what my computer has?

Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
Linux: Type nvidia-smi in the terminal (shows your graphics card and its memory) and free -h for system memory.

Guide

Google Colab (in your browser, no installation)

Google Colab is a free service from Google. It gives you a computer with a graphics card in your browser for a few hours. All you need is a Google account. For this model: too big for Colab – even the largest Colab GPUs aren't enough.

Download the notebook. Click the button and save the file.
Download colab.ipynb
Open Colab. Go to colab.research.google.com and sign in with your Google account.
Upload the notebook. In the window that appears, click Upload on the left (or choose File → Upload notebook at the top) and select the file colab.ipynb.
Turn on the GPU. In the top menu, go to Runtime → Change runtime type → under Hardware accelerator, select T4 GPU (with Colab Pro: L4 or A100) → Save.
Start everything. Runtime → Run all (keyboard shortcut Ctrl + F9). If you see the warning “This notebook was not authored by Google,” click Run anyway.
Wait. The cells run one after another. A green checkmark appears to the left of each cell when it's done. Installation and download take about 33 minutes here.
Try it out. The result appears below the last cell. To test something else, change the text in the cell and run it again with Shift + Enter. The last cell starts a proper chat with an input field.
Clean up. When you're done: Runtime → Disconnect and delete runtime. This saves your free quota.

Good to know: The free GPU is limited (usually a few hours per day). After about 90 minutes of inactivity, Colab disconnects, and you'll have to start everything over.

Windows 10 / 11

The easiest way is Ollama, a free program that launches AI models with a single command.

Update your graphics driver (NVIDIA cards only): Install the NVIDIA app or the latest driver. For AMD cards, use the latest Adrenalin driver.
Install Ollama. Download the file OllamaSetup.exe from ollama.com/download/windows, double-click it, and choose Install. Afterward, a small llama icon appears in the taskbar at the bottom right.
Open a terminal window. Press the Windows key, type PowerShell and press Enter. A blue or black window opens.
Start the model. Copy this command ("Copy" button), paste it into the window with a right-click, and press Enter:
```
ollama run hf.co/AMAImedia/Naive-N0.5-Flash-Mixed-Quant-GGUF:Q8
```
The first time, Ollama downloads the model (87 GB (about 1.9 hr at 100 Mbit/s)). After that, it's instant.
Start typing. Once >>> Send a message appears, type your question and press Enter. Type /bye to end the chat.

Prefer automatic? A script that picks the right variant for you

Download both files into the same folder: try_windows.ps1 demo.py
Open the folder in File Explorer, right-click an empty spot and choose Open in Terminal.

Paste this command and press Enter:

powershell -ExecutionPolicy Bypass -File try_windows.ps1

If needed, the script installs Ollama via winget, measures your VRAM (video memory) and downloads the matching variant.

macOS

Macs with an Apple chip (M1 to M5) are ideal. Older Intel Macs are very slow.

Install Ollama. Download it from ollama.com/download/mac, open the file, and drag Ollama into your Applications folder. Launch Ollama once – a llama appears in the menu bar at the top.
Open Terminal. Press Cmd + Space, type Terminal, and press Enter.
Start the model. Paste the command (Cmd + V) and press Enter:
```
ollama run hf.co/AMAImedia/Naive-N0.5-Flash-Mixed-Quant-GGUF:Q8
```
The first time, the model is downloaded (87 GB (about 1.9 hr at 100 Mbit/s)).
Start typing. Type your question and press Enter. Quit with /bye.

Pick the right variant automatically

try_mac.sh

cd ~/Downloads
bash try_mac.sh

Linux

Check your GPU. nvidia-smi should show your card. If it doesn't, install the driver on Ubuntu and restart:
```
sudo ubuntu-drivers install
```

Install Ollama:

curl -fsSL https://ollama.com/install.sh | sh

Start the model:
```
ollama run hf.co/AMAImedia/Naive-N0.5-Flash-Mixed-Quant-GGUF:Q8
```
Exit with /bye. Use ollama ps to check whether the model is running on the GPU.

Or let it pick the right variant automatically:

try_linux.sh

bash try_linux.sh
# mit Python/transformers statt Ollama:
MODE=hf bash try_linux.sh

Try it

Write a Python function that checks whether a string is a palindrome, and briefly explain it.

Create a single HTML file with a Pomodoro timer, start, pause and reset buttons and a clean design.

Build an interactive 3D view of the solar system with Three.js where you can rotate the camera and adjust the orbital speed. Generate all textures in code, without image files.

Port the raytracer from 'Ray Tracing in One Weekend' to a browser app with a progress bar, quality levels and PNG download.

Here's my project description for a small task manager with a REST API and SQLite. Create the complete folder structure and write all the files.

Tips for better results

Use thinking mode for complex projects and turn it off for simple questions. That way you get fast answers without wasting tokens.
Describe apps in as much detail as in the test: which features, which controls, which library, no external files. The model follows precise specs well.
Have the generated code reviewed for efficiency afterwards. In the raytracer test, Naive's code worked but was slower than DeepSeek's.
When comparing speed, look at total response time rather than just tokens per second, because a verbose model can take longer despite high throughput.

If something goes wrong

Without thinking mode, the model failed at a complex 3D app in testing. Turn on thinking mode for demanding coding tasks.

With thinking mode, hard tasks can consume huge numbers of tokens (around 108,500 on average in testing). Set a sensible token limit, or time and costs will spiral.

The advertised speed only comes with NaiveRT and the matching drafter. With standard engines, the model is significantly slower.

With thinking mode, the large model accepts only 43.4 percent of the drafter's proposals (70.6 percent without). Speed during thinking is therefore about half that of the answer phase.

The source doesn't mention a license, Hugging Face repo or GGUF files. Check the vendor's Model Card before deploying.

“out of memory,” a crash, or your computer freezes

The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.

It runs, but extremely slowly

Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).

“ollama” or “python” is not found

Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.

Windows: "Running scripts is disabled on this system"

Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.

Error message when loading the model (version, "trust_remote_code", unknown architecture)

Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.

Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: mit.

Ask the AI assistant

Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.

Connecting …

The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.

Comments

What do you think? Already tried it? Write it here, no sign-up needed.

Loading comments …

Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.