Naive-N0.5-Flash

Naive-N0.5-Flash is a 309B-parameter Mixture-of-Experts model from NaiveAI, released September 27, 2026, under the MIT license. It activates 15.5B parameters per token and carries a native 1,000,000-token context window. Weights and inference code are open. That combination, frontier-scale sparse capacity plus a permissive license, is the reason this model matters to anyone building locally.

The category it occupies is narrow and deliberate: coding and AI research and development. NaiveAI trained it to participate in its own R&D loop, writing code, running experiments, and iterating on results, with human researchers setting direction. That shows up in the benchmark suite the company reports (SWE-Bench Pro, Terminal-Bench 2.1, ALE-CLI, MLE-bench-30, PaperBench), which skews heavily toward agentic software engineering and research tasks rather than chat.

The headline architectural claim is that there are no full-attention layers anywhere in the 48-layer stack. NaiveAI replaced global attention with a hybrid of Sliding-Window Attention (SWA) and DeepSeek Sparse Attention (DSA), betting that a fully local-or-sparse network can hold coherence at 1M tokens. If it works, it removes the quadratic decoding cost that makes million-token inference impractical on most hardware. It is the first frontier-scale open-weight release to attempt this.

The numbers that govern local deployment:

• Total parameters: 309B
• Active parameters per token: 15.5B
• Transformer layers: 48 (eight six-layer modules)
• Attention composition: 39 SWA layers + 9 DSA layers, zero full attention
• SWA window: 128 tokens
• DSA token selection: top 2,048 tokens for backbone attention
• KV groups: 4 (GQA4), 16 indexer query heads
• Context length: native 1M tokens
• License: MIT

Active parameters are the number that determines compute per token, not VRAM. At 15.5B active, the FLOP cost of a forward pass is closer to a mid-size dense model than to a 309B one. That is the MoE efficiency story, and it is why NaiveRT can quote 50 tokens/s per user in Standard mode and up to 2,000 tokens/s in Ultrafast mode on NaiveAI's own infrastructure.

VRAM is a different problem. Every expert has to be resident somewhere, or fetched over PCIe at a cost that destroys throughput. The 309B total is what you have to fit, not the 15.5B.

The attention design is what makes 1M context tractable. Most layers use a 128-token sliding window with per-token decoding cost that does not grow with sequence length. The nine DSA layers replace global attention: a lightweight indexer scores the full history, and the backbone attends only to the top 2,048 selected tokens. The full KV cache is still retained and the indexer still scans the whole history, so this reduces attention compute and memory traffic rather than eliminating long-context cost entirely. NaiveAI adapted the model to this structure through continued pretraining: 50B tokens of indexer warmup, 3T tokens of sparse attention training, and 200B tokens of learning rate decay, 3.25T tokens total.

This is a text-only model. No vision, no audio. Its stated capabilities are chat, code, and reasoning, with the emphasis clearly on the first two-thirds of that list being applied to software.

Concrete workloads where it fits:

• Repository-scale agentic coding. A 1M-token window holds a large codebase plus tool output plus conversation history. NaiveAI's own evaluations ran it against Claude Code 2.1.207 with a 1M-token context, temperature 1.0, top-p 0.95, and only basic file I/O and Bash tools exposed. That is a realistic agent harness, not a toy.
• Long-horizon refactors and migrations. Tasks that require holding an entire module tree in view while making consistent edits across files.
• Automated research loops. Experiment generation, result analysis, and iteration, which is the training objective the model was built for.
• Terminal and CLI agents. Terminal-Bench 2.1 and ALE-CLI are both in the reported evaluation set.

It is not the right pick for latency-sensitive single-turn chat, for multimodal work, or for anything requiring a small memory footprint.

Weight size is the binding constraint. Approximate figures by precision:

Add KV cache on top. Even with GQA4 and sparse attention, the full KV cache is retained, and at 1M tokens it runs to tens of gigabytes. Budget headroom above the weight figure.

A single RTX 4090 (24 GB) cannot run this model at any usable quantization. Neither can an M4 Max at 128 GB, except at Q2 with heavy CPU offload and token rates that make it a science experiment rather than a tool.

Realistic configurations:

• 4x H100 80GB (320 GB): fits FP8 natively. This is the reference setup for full-precision serving.
• 8x RTX 6000 Ada 48GB (384 GB): fits FP8, or Q6 with room for a large KV cache.
• 8x RTX 3090 or 4090 (192 GB): fits Q4_K_M with a tight KV budget. Expect to tune context length downward for long sessions.
• Mac Studio M3 Ultra, 512 GB unified memory: Q4 and Q6 both fit. Token rates are the tradeoff; unified memory bandwidth is far below an H100 cluster, so expect single-digit to low-double-digit tokens/s depending on context length.

Expect roughly 20-40 tokens/s decode on an 8x4090 Q4 setup, higher on H100 clusters. The 2,000 tokens/s Ultrafast figure is NaiveAI's serving stack on their hardware (mega-kernel fusion, Programmatic Dependent Launch, speculative decoding), not a number you should expect from a workstation.

Q4_K_M is the right starting point for most local users. It cuts weights to roughly half of FP8 with modest quality loss and is the only precision that fits comfortably on 8x24GB cards. Move to Q6_K if you have 384 GB and care about reasoning fidelity. Avoid Q3 and below for coding tasks: the degradation shows up in exactly the multi-step agentic behavior this model is built for.

Ollama is the fastest path if a GGUF build exists for your target precision. Check that first, because the hybrid SWA-DSA stack is nonstandard: there are no full-attention layers, so generic attention kernels do not apply, and llama.cpp support depends on kernels for both the sliding-window and sparse paths. If GGUF support is not there, use NaiveAI's released inference code (MIT licensed) or a serving framework with a compatible implementation. Do not assume a stock vLLM build will load it without checking the architecture registry.

Against DeepSeek-V4.1-Flash, the closest open-weight competitor at this scale, the tradeoff is attention design. DeepSeek's sparse attention work is the direct ancestor of the DSA layers here, but Naive-N0.5-Flash pushes further by removing full attention entirely and pairing it with a 5:1 SWA-DSA layout. If your workload lives at 500K-1M tokens, that is the differentiator. If you run mostly short-context coding, the advantage narrows and you should compare on benchmark fit for your specific task.

Against Kimi-K3, another frontier-scale open-weight MoE, the decision usually comes down to hardware and license. Naive-N0.5-Flash is MIT, which is the most permissive option in this weight class and removes legal friction for commercial deployment. Kimi-K3's tooling ecosystem is more mature in some serving stacks.

Choose Naive-N0.5-Flash when you need a permissive license, million-token context, and strong agentic coding at a compute cost closer to a 15B dense model. Look elsewhere when you need multimodal input, a sub-100 GB footprint, or a validated serving path on a single consumer GPU.