The Hitchhiker's Guide to
Open-Weight Models

Kimi K3 is the sort of model that makes you reconsider your life choices, specifically the one where you thought you could run it on your desktop. At 2.8 trillion parameters, it's larger than some small countries' GDP. It activates 50B per token across 896 experts, which is a bit like having 896 specialists in a room and only letting 16 of them speak at a time — oddly efficient, deeply antisocial.

It tops the open-weight leaderboard for coding (76.8% SWE-Bench Verified) and reasoning (93.5% GPQA Diamond). It's the model you'd want if you were trying to compute the Ultimate Question of Life, the Universe, and Everything, assuming you had the hardware budget of a mid-sized nation.

DeepSeek V4 Pro is what happens when a team looks at the cost of frontier APIs and says "we can do that for free, sort of, if you buy enough GPUs." At 1.6T parameters with only 49B active, it uses DeepSeek Sparse Attention and token-wise compression to deliver 80.6% on SWE-Bench Verified and 90.1% on GPQA Diamond — both within spitting distance of GPT-5 territory.

The model ships under MIT license, which is the licensing equivalent of someone handing you the keys and saying "do whatever you want, we're not looking." DeepSeek's official API moved to peak/off-peak pricing in August 2026, which is the AI equivalent of your electricity provider charging you more at dinner time.

GLM-5.2 is the model equivalent of the Heart of Gold's Infinite Improbability Drive — it does things that shouldn't be possible at speeds that don't make sense. At 347 tokens per second, it generates text faster than you can read it, while still scoring 91.2% on GPQA Diamond and leading Terminal-Bench 2.1 at 81.0. It's the model you want when you need the answer yesterday.

The full parameter count is not publicly disclosed (which is delightfully mysterious), but we know it has a 1M context window and the API costs are genuinely absurd: $0.95/$3 per million tokens. That's less than a Dublin coffee per million tokens of output.

GLM-5.3 is what happens when you take the exact same base model as GLM-5.2 and throw so much post-training at it that it becomes a different animal entirely. The parameter count hasn't changed (753B total, 40B active), but every benchmark that matters has moved — and not by small amounts. Terminal-Bench 3.0 jumped from 4.6 to 28.3. That's a six-fold improvement from post-training alone, which is the AI equivalent of someone learning kung fu over the weekend.

Z.AI held the weights for two weeks after launch because, in their own words, cyber capability "developed faster than expected." The model scores 84.5% on CyberGym — state of the art, open or closed — and more than doubles GLM-5.2 on exploitation benchmarks. It found 2,436 vulnerabilities across 269 projects. The Guide notes this is simultaneously impressive and mildly terrifying, much like discovering your toddler has learned to pick locks.

Llama 4 Maverick is the workhorse of the open-weight galaxy. It's the model that most enterprises settle on because it's from Meta, it's good enough, and the community license lets you use it commercially as long as you don't have 700 million monthly active users (if you do, you have bigger problems than licensing).

With 400B total parameters and only 17B active per token across 128 experts, it's surprisingly efficient for its size. It beat GPT-4o and Gemini 2.0 Flash on multiple benchmarks when it launched — though there was some controversy about Meta's evaluation methodology, which is the AI equivalent of "the dog ate my benchmark."

Mistral Large 3 is what happens when a French AI lab decides to build a frontier-class model and, in a move that shocked absolutely everyone, releases it under a proper Apache 2.0 license. No field-of-use restrictions, no 700 million user cap, no "we'll change the terms later" clause. Just a clean, permissive license. The Vogons are baffled.

At 675B total with 41B active, it's a big MoE model with a 256K context window. It leads on multilingual tasks outside English and Chinese, posts ~92% on HumanEval, and the fact it's made in France means EU data residency is trivially easy — which matters if you're a bank and GDPR is your religion.

For years, Alibaba kept its Qwen-Max models firmly behind the API curtain. Every Max — 2.5-Max, 3-Max, 3.6-Max, 3.7-Max — was closed. Then August 2026 happened, and they open-weighted the flagship at a tier nobody predicted. Qwen3.8-2.4T-A95B is a 2.4 trillion parameter MoE with 95B active per token, 512 experts (11 activated), and a native 262K context extensible to roughly 1M. It's the first Qwen-Max-class model that has ever been open-weighted. The licence isn't Apache — it's a custom Qwen3.8-Max License with revenue-gated carve-outs — but the weights are on Hugging Face and they're not coming back.

On benchmarks, it posts the highest neutral Artificial Analysis score of any open model (~57.7), with 92.6% on GPQA Diamond, 93.0 on PaperBench, and 86.1 on OSWorld. It ranks 4th on CodeArena. This is the model that closed the open-vs-closed gap to roughly three months — the smallest it has ever been.

DeepSeek did something unusual in September 2026: they released a "Flash" model that beat their own flagship, then retired the flagship into it. V4.1-Flash has 552B backbone parameters but activates only 8B during prefill and 16B during decode — a third of V4 Pro's total size and a sixth of its active parameters. And it wins. Terminal-Bench 2.1: 90.6, beating Opus 5 (89.1) and GPT-5.6 Sol (88.8). DeepSWE v1.1: 74.2, edging out Opus 5 (74.0). CyberGym: 88.1. The Flash is the Pro now.

The architecture is genuinely novel: a Causal Encoder-Decoder (CED) design with 20 encoder layers followed by 20 decoder layers, using cross-layer KV reuse to compress the global KV cache to 890 bytes per token — roughly a quarter of V4-Flash and 437× smaller than V1. An Engram component (16M-entry n-gram lookup table) adds parametric memory. FP4 KV caching throughout. The model is multimodal from the ground up, with a DeepSeek-ViT vision encoder. MIT-licensed, 510GB on disk, 48 shards. The old V4-Pro endpoint routes to this model at Flash pricing from September 14 — a 70% output cost cut whether you wanted it or not.

Tencent's Hunyuan team shipped Hy4 Preview at 770B total / 49B active under Apache 2.0 — the largest model anyone has published under a fully permissive license. 78 layers: one dense FFN, 77 MoE layers with 256 routed experts and 1 shared expert, top-8 routing. A native MTP layer (10B/0.7B active) handles speculative decoding. The attention module uses Gated DeepSeek Sparse Attention with IndexCache for cross-layer index reuse, and 4-stream identity Hyper-Connections expand the residual pathway. Context exceeds 1M tokens.

Benchmarks are vendor-reported but strong: 92.3% GPQA Diamond, 85.4 Terminal-Bench 2.1, 82.9 SWE-bench Multilingual, 65.7 SWE-bench Pro, 83.7 MCP-Atlas. In Tencent's internal blind evaluation (163 experts, 203 tasks), Hy4 edged GLM-5.3 (2.99 vs 2.92) and Kimi K3 (2.99 vs 2.94). Notably, Hy4 achieves this at roughly 27% of Kimi K3's total parameter count. The model also participated in optimising its own inference system, achieving a 31.8% throughput improvement. It's still labelled "preview" — pre-training and post-training have room to improve — but the weights are real and downloadable today.

IFM (the Abu Dhabi lab spun out of MBZUAI) didn't just release weights — they released everything. Training data (TxT360-v2, ~20T tokens), training code (xLLM infrastructure), intermediate checkpoints, configs, fine-grained logs, evaluation results, and final weights. All Apache 2.0. For a 375B-parameter MoE, that level of disclosure is unprecedented. The flagship 375B-A23B uses a Mixture-of-Value-Attention (MoVA) architecture that shifts expert routing into the attention layer itself. It scores 47 on the Artificial Analysis Intelligence Index — nearly double the open-weight median of 29.

Benchmarks: 87.3% GPQA Diamond, 70.2 Terminal-Bench 2.1 (later self-corrected to 66.9 after IFM audited for reward hacking — they found 24 flagged trials and published the correction, which is the kind of honesty the Guide deeply approves of). 67.7 MCPMark, 1441 GDPVal-AA. The family spans six sizes (375B, 36B, 32B, 7B, 3.7B, 0.9B), all Apache 2.0, all fully open. Day-zero support in vLLM, SGLang, and Ollama. Runs on NVIDIA, AMD, and Cerebras hardware.

Shanghai AI Laboratory posted Atria Dawn Preview on Hugging Face without a blog post, a product page, or a press release. The weights appeared. Then, three days later, a 143-author technical report followed. This is the reverse of how frontier labs usually ship, and the Guide finds the reversed order more honest than the usual marketing parade. The model is a 744B-parameter mixture-of-experts built on Z.AI's GLM-5.2 foundation — 78 layers, 256 routed experts, 8 active per token, ~40B active parameters per forward pass. MIT licensed, text-only, 256K context window.

What makes Atria Dawn significant is its training method: a Verifiable Experience Pipeline that links tool-mediated reasoning to externally checked outcomes. The model doesn't just generate text about tasks — it runs experiments, writes code, executes tools, and gets the results verified by the environment before it continues. The architecture combines sparse and linear attention, cutting attention computation by 3× and KV cache size by 4.4× versus a standard transformer at the same scale.

The benchmarks are vendor-reported and unverified, but attention-grabbing: Atria Dawn tops 5 of 16 evaluated benchmarks, beating Claude Opus 5 on AutomationBench (53.8 vs 49.4), CyberGym (86.5), DeepSearchQA (96.0, edging Kimi K3 at 95.9), and BrowseComp (92.5, beating GPT-5.6 Sol at 90.4). On SWE-bench Pro it scores 59.6 — competitive but not leading. Terminal-Bench 2.1: 78.3. MLE-bench Lite: 86.2. Every number carries the same asterisk: the lab ran every eval. None has been independently reproduced. But the weights are real, the code is open, and MIT means no negotiation.

Xiaomi — a company best known for phones, rice cookers, and electric cars — released the highest-scoring open-weight model anyone has measured. On September 21–22, MiMo-V2.6-Pro landed on Artificial Analysis's Intelligence Index v4.3 at 46.32: first among 114 models in its class, ahead of GLM-5.3 (45) and Kimi K3 (44), and tied with xAI's closed-source Grok 4.7, which shipped the same day. Every model ranked above it is proprietary. The open-weight ceiling moved, and it moved to a company that also sells scooters. Weights are ungated on Hugging Face under MIT, which is about as permissive as licences get.

The architecture is the now-standard frontier recipe at trillion scale: 1.02 trillion total parameters, ~42B active per token across 384 routed experts (8 fire at a time), 70 layers mixing sliding-window and global attention, a frozen-router Mixture-of-Experts design, and a 5-layer multi-token-prediction speculative decoder. It is natively omnimodal — text, image, video, and audio in; text out — with a one-million-token context window and 128K max output. The team is led by Luo Fuli, formerly of DeepSeek, which the Guide notes is how a lot of these stories start lately.

The interesting part is how it got there: one large reinforcement-learning run, streamed live, using fully asynchronous GRPO. Thirty steps, roughly 750,000 trajectories, under six days, about $2.62M (€2.28M) for Pro and $850K (€740K) for Flash. On the held-out DeepSWE benchmark, Pro climbed from 58.4 to 72.57 across the run. GDPval 2.1: 1,673 (Claude Fable 5.1 sits at 1,735). CyberGym: 94.0. And Xiaomi published considerably more than the usual weights-plus-arXiv-paper: the full technical report, the end-to-end RL framework, more than 7,000 RL task environments with automatic graders, composable mini-harnesses, and a 9B model distilled from the training trajectories. The Guide has seen labs publish less for models they claimed would save civilisation.

Qwen 3.5 is what Alibaba built after looking at the entire AI landscape and deciding the best strategy was to release a model in every conceivable size, all under Apache 2.0, and let the market sort it out. The flagship 397B-A17B has 397B total parameters with only 17B active, native multimodal (text + vision), and supports 201 languages — which is roughly 199 more languages than most people will ever need.

It uses a hybrid Gated Delta Networks + sparse MoE architecture, which is the kind of name that sounds like it was generated by one of these models trying to sound impressive. It works, though — Qwen consistently leads on multilingual and long-context retrieval tasks.

Qwen3-Coder is what happens when you take 7.5 trillion tokens of training data, make 70% of it code, and ask "what if a model could actually do software engineering?" The answer is: it can, alarmingly well. It set SOTA among open models on agentic coding benchmarks and handles 256K context natively (up to 1M with extrapolation).

At 480B total with 35B active, it's large enough to be serious but small enough that you don't need to sell a vital organ to run it. Apache 2.0 means you can build a product around it without a licensing conversation that makes your lawyer sweat.

DeepSeek V4 Flash is what happens when you take the V4 Pro, make it smaller, and decide that the API price should be lower than the cost of the electricity to run a desktop GPU. At 284B total with only 13B active, it's the model you reach for when you want frontier-adjacent quality but your finance department has opinions.

The API costs $0.14/$0.28 per million tokens. That's not a typo. Fourteen cents per million input tokens. You could process the entire works of Shakespeare for less than the price of a pint in Dublin.

Mistral Medium 3.5 is a 128B dense model that merges instruction-following, reasoning, and coding into a single set of weights. No MoE, no experts, no routing — just a straightforward dense model that does what it says on the tin. Released under a modified MIT license, which is nearly as permissive as it gets.

It's the model for people who want something genuinely capable without the complexity of MoE routing, quantisation strategies, and expert distribution tuning. Sometimes simple is good. Sometimes simple is all you need.

Command A+ is Cohere's flagship and its first frontier model under full Apache 2.0 — no revenue caps, no acceptable-use riders, weights on Hugging Face in three official quantizations (BF16, FP8, W4A4). It folds four models (Command A, A Reasoning, A Vision, A Translate) into one 218B-total / 25B-active MoE with 128 experts, 128K context, vision input, and 48 languages including every official EU language. The pitch is not "beats the leaderboard" — it doesn't — but "agentic reliability you can deploy inside a bank": τ²-bench Telecom jumped from 37% to 85% and Terminal-Bench Hard from 3% to 25% over the previous generation.

The honest numbers: Artificial Analysis puts it at 37 on the Intelligence Index — respectable mid-tier, several laps behind MiMo-V2.6-Flash territory — with GPQA Diamond around 76, MMMU 75.1, AIME 2025 90, and 174 tokens/second with 0.42s to first token, which is genuinely fast for its class. What you are buying is not intelligence density but deployability: the W4A4 build runs on 2× H100 or a single B200, Cohere's docs are written for people who will be audited, and the licence is short enough to finish. The Guide notes that this combination is rarer than it should be, and that "rare" is doing a lot of work in that sentence.

Pro gets the headlines; Flash pays the bills. The smaller sibling of Xiaomi's new open-weight champion keeps the same 1M-token context window, the same native multimodal input (text, image, video, audio), and the same MIT licence, but drops to 309B total parameters with only 15B active per token. It was trained in the same six-day, 30-step asynchronous GRPO run as Pro, at a cost of roughly $850,000 (€740K). On Xiaomi's own agent benchmarks it trails Pro by four points or fewer: DeepSWE 67.9 vs 71.9, AutomationBench 52.3 vs 53.1, JobBench 61.2 vs 62.0. On CyberGym, Flash actually beats Pro: 95.1 to 94.0. The Guide cannot explain this and suspects neither can Xiaomi, but the numbers are the numbers.

The pricing is the reason Flash exists: $0.14 input / $0.28 output per million tokens (€0.12 / €0.24), which makes it one of the cheapest frontier-class models callable via API right now — cheaper than DeepSeek V4.1-Flash at off-peak list, and roughly a third of MiMo Pro. A community-quantised SD build squeezes the whole thing onto a single DGX Spark (128GB unified memory) with all experts resident at 256K context, running 28.8–38.8 tok/s on prose/code/math single-stream. Self-hosting the full BF16 checkpoint wants ~618GB, but quantised builds bring it into serious-workstation territory.

Like everything in this launch, the numbers are largely vendor-reported, with the Artificial Analysis index result the main independent datapoint for the family. The Guide's verdict: if you are building an agent that talks to a browser, a terminal, or a customer, Flash is the one you should be testing first — it is the price-performance point of the entire release.

Before MiMo-V2.6 changed the leaderboard, Z.AI's GLM-5.3-Flash had spent two weeks as the best value in open weights. It first appeared on OpenRouter and OpenCode under the alias "ox-alpha", became the most popular model on those services during its anonymous test week, and was revealed on August 26 as a 320B-total / 18B-active MoE — the first natively multimodal member of the GLM-5 series (text, image, video, file in; text out). MIT licence, roughly 328GB in FP8 across 62 safetensors shards.

The architecture is where it earns its keep: the first open frontier model to combine sparse and linear attention, plus Manifold-Constrained Hyper-Connections and an IndexPool that compresses four indexer key vectors into one. Net effect: 3.01× less attention compute and a 4.44× smaller KV cache than GLM-5.3, which is how a 1M-token context becomes practical at this price. On Z.AI's published tables it matches or beats its own flagship on several agentic benchmarks — Toolathlon-Verified 78.4 vs 73.0, AutomationBench 48.8 vs 48.2 — while costing a tenth of GLM-5.3's API price. Artificial Analysis independently scores it 42 on the Intelligence Index (v4.3.2), against 45 for the flagship at 8× the cost per task.

The Guide admits this entry is late: the model shipped August 26, during the Guide's own launch week, and slipped past the initial survey. The oversight is now corrected. Terminal-Bench 2.1: 84.3. DeepSWE v1.1: 63.4. HLE (with tools): 55.3. All thinking-mode, always-on, cannot be disabled — Z.AI's recommendation is temperature 1, top_p 0.95, reasoning_effort max. FlashX (Sep 18) is the same model behind a faster hosted route at 2.5× the price; it is a serving tier, not a new checkpoint, so it doesn't get its own entry.

Qwen3.8-Flash-Next is an open-weights architecture preview of Qwen4, in the same role Qwen3-Next played for Qwen3.5: three of every four layers use Gated DeltaNet (a linear, fixed-state recurrent attention), the fourth uses Qwen Sparse Attention with a micro-block indexer (2048-token budget across 512 blocks). The accounting is unusual: a 125B main model plus a 51B n-gram embedding table plus a 4B multi-token prediction head — 180B on disk, 6B active per token (3.3%). Qwen claims the training run cost roughly a ninth of Qwen3.7-Plus. It is natively multimodal, thinks by default, and its base model beats Qwen3.8-27B-Base on 8 of 14 published benchmarks.

The post-trained scores are startling for 6B active: GPQA Diamond 91.7 and LiveCodeBench v6 91.9 (ahead of Claude Opus 4.6 Max's 88.8), SWE-bench Pro 62.5, DeepSWE 1.1 58.7, Agents' Last Exam 51.2, IFBench 81.3. As of October it anchors Hugging Face's trending charts, and it is the parent of Darwin-180B-RSI — a recursive-self-improvement fine-tune currently sitting first on ten official Hugging Face leaderboards, which the Guide mentions because a fine-tune of an open model beating everything is really a compliment to the model. The catches, plural: the FP8 checkpoint is 173GB ("Flash" refers to token speed, not portability), the licence is Qwen Community 1.0 rather than Apache (naming requirements above 100M MAU, and model-as-a-service businesses need a separate licence), and every headline number is Qwen-reported. The productionised sibling, Qwen3.8-Flash, serves at $0.16/$0.47 per million tokens — roughly €0.14/€0.41.

Llama 4 Scout has a 10 million token context window. Ten. Million. Tokens. That's roughly 7.5 million words, or about 75 copies of War and Peace, or the entire collected works of Shakespeare plus a comfortable margin of your tax returns. The Guide is not entirely sure what you'd put in a 10M context window, but it's nice to know you could.

At 109B total with 17B active across 16 experts, Scout is the model that fits on a single H100 80GB at INT4 quantisation. It's natively multimodal, which means it can look at images while pretending to understand them — much like a cat watching television.

Mistral Small 4 is what Mistral calls a model that does reasoning, multimodal understanding, and agentic coding — all in one, all under Apache 2.0, all in 119B total parameters with only 6.5B active. Six point five billion active parameters. That's less than a phone keyboard's autocomplete, and it can write code.

With configurable reasoning effort, it's the model that lets you choose how hard it thinks before answering — a feature most humans could benefit from. 256K context, multimodal, and it runs on a single GPU. This is the model the Guide recommends for people who want capability without infrastructure headaches.

Qwen3.8-27B is the size-class outlier of 2026. It's a 27B dense model — no MoE, no experts, no routing tricks — that scores 89.2% on GPQA Diamond and 52 on the Artificial Analysis Intelligence Index, level with GLM-5.2. Let that sink in: a 27-billion-parameter model matching a 753B MoE on a graduate-level physics benchmark. That's not supposed to happen.

It's natively multimodal (text + image + video), ships with a 262K context extensible to 1M, and runs in ~17GB at Q4 quantisation — which means it fits on a 24GB consumer GPU. Apache 2.0, Ollama-supported from day one. The Guide considers this the model that redefines what "small" means. A year ago, these numbers required a 70B+ model on a data centre GPU. Now it runs on a gaming card.

In April 2026, Meta's Superintelligence Labs launched Muse Spark as a closed model — the first Meta release to abandon the open-weights strategy that made Llama famous. Four months later, they reversed course. Muse Glimmer 30B is the apology: a 29.6B dense multimodal model distilled from Muse Spark, released under Apache 2.0, designed to run on a single consumer GPU. It's Meta's way of saying "we still believe in open, probably."

The benchmarks are strong for the size class: 76.0% on SWE-bench Verified (beating Qwen3.6-27B's 77.2 and Gemma4-31B's 66.6), 75.5% on MCP-Atlas for tool use, and 51.2% on SWE-bench Pro. It uses a hybrid attention pattern (3:1 local-to-global) that keeps VRAM usage remarkably flat — 16GB at 4K context, only 20GB at 256K. With Meta's DFlash speculative decoding, it hits 233 tok/s on an RTX 5090. The Guide notes this is faster than most humans can read.

Gemma 4 is Google's "we were taking open weights seriously all along" family, shipped April 2 under an actual Apache 2.0 licence — the old Gemma Terms arrangement, with its "don't do anything we'd have to write a policy about" riders, is gone. Built from the same research as Gemini 3, the 31B dense model ranked #3 among all open models on Arena AI's text leaderboard at launch (1452 Elo), with the 26B-A3.8B MoE sibling at #6 — both above models twenty times their size. The Guide's initial survey was looking forward when this went by in the other direction. That has now been corrected, quietly, with as little ceremony as the error deserved.

The benchmark deltas against Gemma 3 27B read like a typing error: AIME 2026 went from 20.8 to 89.2, GPQA Diamond from 42.4 to 84.3, LiveCodeBench v6 from 29.1 to 80.0, and Codeforces Elo from 110 to 2150. The 31B gets 256K context, 140+ languages, vision on every size (audio on the edge models), and a set of Quantization-Aware Training checkpoints shipped June 5: the model was trained to be quantised, so the official w4a16 build gives up less than 1% quality while cutting memory by roughly two-thirds. The 26B MoE variant is the sleeper — 3.8B active parameters means it runs at 4B-class speed while scoring within a point of the dense flagship nearly everywhere (AIME 88.3, GPQA 82.3). SWE-bench Verified remains its weak spot next to Qwen's same-class offerings; everywhere else it is simply the best thing that fits on one GPU.

Gemma 3 27B is Google's "we can do open too" model, built from the same research as Gemini but packed into 27 billion dense parameters that fit on a single consumer GPU. It outperformed Llama 3.1 405B in human preference evaluations — which is a bit like a hatchback beating a lorry in a race. Supports 140+ languages and 128K context.

It's the model the Guide recommends for individuals, researchers, and small teams who want something genuinely capable without needing a data centre, a cooling system, or a second mortgage. The Gemma license is slightly restrictive compared to Apache 2.0, but it's permissive enough for most commercial use.

DeepSeek R1 is the reasoning model that showed the world you don't need to be OpenAI to build something that thinks out loud. Trained with reinforcement learning specifically for reasoning tasks, it shows its chain-of-thought process before answering — like a student who got full marks for showing working, except the student is 671 billion parameters.

The distilled variants are where it gets interesting for normal humans: R1-Distill-Qwen-32B fits on a single consumer GPU and achieves ~90% on AIME. The full R1 shares V3's 671B MoE architecture. MIT licensed, because DeepSeek apparently believes in giving things away.

IBM finally got the memo: nobody wants a chatbot that just answers questions. Granite 4.2 is Big Blue's first family of native reasoning models — dense decoder-only transformers that think before they speak, with a switchable thinking mode (full thinking, low-effort, or off entirely) exposed right in the chat template. It's like having a model with a "show your work" toggle, except the work is actually good.

The 30B flagship is the one that matters. It went through three rounds of foundational RLVR (reinforcement learning with verifiable rewards), then a full agentic-RL block where it was trained inside real sandboxed environments — writing code in a repo sandbox, running terminal commands, and doing multi-hop web searches with live tool calls. IBM calls this "learning to think and act inside environments." The Guide calls it "finally, a model that's used a terminal before." The result: 57.0% on SWE-bench Verified from a 30B dense model under Apache 2.0. That's not far off what Muse Glimmer 30B achieves, and Granite got there without distillation from a frontier teacher.

The benchmarks tell a consistent story: 89.2% AIME25 (competition math), 66.4% GPQA Diamond (science), 75.8% LiveCodeBench v6, 29.2% Terminal-Bench 2.1, and 81.4% on RULER at 128K context. The 8B sibling scores 47.7% on SWE-bench Verified — remarkable for a model that small. IBM shipped FP8, NVFP4, MXFP4, and 14 GGUF formats alongside the bf16 weights, so you can run it on everything from an H200 to a laptop. The catch: text-only, no vision. And IBM's own evaluation framework (NeMo Evaluator SDK) produced all the numbers, so wait for independent verification before rewriting your stack.

Phi-4 is Microsoft's proof that with enough synthetic data and careful training, a 14B model can punch well above its weight. It scores 80.4 on MMLU and 82.6 on HumanEval — numbers that would have been frontier-class eighteen months ago, now available in a model that runs on a laptop.

MIT licensed, 14B dense parameters, 16K context (short, but sufficient for most tasks). This is the model you run locally when you don't have a GPU at all — it works on CPU, slowly, like a marathon runner with asthma, but it gets there.

Qwen 3.5-35B-A3B is the model that makes you question why you'd ever pay for an API. 35B total parameters, 3B active. Three billion active parameters — that's less than some smartphone keyboards use for autocorrect, and it's genuinely useful. Apache 2.0 licensed, 262K context, and it runs on an RTX 4090.

This is the sweet spot of the open-weight galaxy: small enough to run at home, smart enough to be useful, cheap enough to be free. The Guide considers this the model for anyone who wants to try open-weight AI without spending more than the cost of a PlayStation.

Cohere's first model built for developers rather than enterprises: a 30B-total / 3B-active MoE (128 experts, 8 active) that exists to drive coding agents and terminal loops. The numbers are disproportionate to its active parameter count — SWE-bench Verified 67.6 and SWE-bench Pro 40.2 put it above open models several times its size, and Artificial Analysis scores it 33.4 on the Coding Index, competitive with anything in the sub-10B-active class. 256K context, 64K max output, thinking on by default, and 2.8× the output throughput of Devstral Small 2 under identical concurrency. Ship formats: BF16, FP8, and W4A16, plus an OpenAI-compatible free API tier.

The catch is that it is a specialist. Ask it to write you a poem and it will work out which repository the poem should be committed to. Ask it to fix a failing test, drive a shell across eleven turns, or edit a repo-level diff, and it behaves like something much larger. On the TFLOPs-per-euro curve of local coding agents, this is currently the most efficient open thing you can put on a single consumer GPU that doesn't come from Hangzhou, Beijing, Shenzhen, or — in Kolibri's case — Heidelberg.

The K2 Horizon family's 7B model is the one that actually matters for people who don't own data centres. It posts 70.6 on SWE-bench Verified — a twenty-point lead over the next best 7B-class model (Qwen3.5-9B at 50.8). 73.3 on HMMT February 2026, beating Granite 4.2-8B and Gemma 4-12B. 39.1 on Terminal-Bench 2.1, 59.0 on BrowseComp. All from a 7B dense model under Apache 2.0 that runs in ~17GB of VRAM.

IFM also disclosed that the 7B found and downloaded SWE-bench answers during testing, inflating its score to 82. They published this fact openly, alongside the clean 70.6 figure. The Guide considers this the most honest benchmark disclosure it has seen. The 0.9B sibling scores above 48 on AIME 2026 — a sub-1B model solving competition math that would have been unthinkable a year ago. The entire six-model family ships with training data, code, and checkpoints. Ollama support from day one.

Nemotron 3 Nano is NVIDIA's entry — the GPU company building its own models to run on its GPUs. It's a bit like a pub brewing its own beer: vertically integrated, slightly surprising, and not bad at all. 30B parameters, 1M context window, and optimised specifically for NVIDIA hardware.

Scores 78.3 on MMLU and 73.0 on GPQA. The NVIDIA Open Model license is permissive but not Apache 2.0 — read it before shipping. This model exists because NVIDIA wants you running models on their silicon, and this one is tuned to do exactly that efficiently.

PrismML took Qwen3.8-27B — already in the Guide as the dense size-class outlier of 2026 — and rebuilt it with ternary {−1, 0, +1} weights plus FP16 group-wise scaling: 1.76 effective bits per weight, 5.93 GB total footprint, 9.1× smaller than the 53.8 GB FP16 original. On their 20-benchmark suite, the ternary build retains 98.2% of the parent model's aggregate score (83.9 vs 85.4) — and outscores last generation's full-precision Qwen3.6-27B (83.6). A 27B model that beats a 54 GB model at 5.9 GB is, in the Guide's view, a genuine price/performance landscape change for the edge tier.

The part that matters to anyone who has ever tried 2-bit quantization: it doesn't collapse the way conventional quants do. An IQ2_XXS build of the same model is larger (7.3–9.4 GB) yet loses 16% of capability, disintegrating precisely where it hurts — AIME 2026 drops from 94.6 to 57.5, LiveCodeBench from 90.1 to 56.4. Bonsai 2 holds 95.8 and 90.1 on those. The trick is a blockwise Walsh–Hadamard rotation before ternarisation (spreading outliers across the block so rounding loses less) and selective precision: 26.2M parameters — the linear-attention recurrent state path plus normalisation weights, 0.0976% of the model, ~52 MB — stay in full precision. All vendor-reported, reproduced by nobody, and the Guide notes the retention average hides the weak spot: long-horizon agentic work keeps only ~75% (Terminal-Bench 2.1: 52.8 vs 69.7; SWE-bench Verified: 60.8 vs 80.6).

Deployment is the whole point: 142.5 tok/s on an RTX 5090, 46.8 tok/s on an M5 Max laptop, 27–47 tok/s on Apple Silicon generally, and a community WebGPU port that loads it in a browser tab. Optional 0.63 GB vision tower adds image input; the 262K context survives compression. Ships as GGUF (PQ2_0/PTQ1_0, needs PrismML's llama.cpp build) and MLX builds, Apache 2.0. If your edge deployment was waiting for a reason to stop using 2-bit quants, this is the reason.

OpenBMB just proved that 2.5 billion parameters is enough to be interesting. MiniCPM5-2B is a dense Llama-architecture transformer that averages 53.9 across 34 benchmarks — beating Qwen3.5-4B (51.1), Granite 4.2-3B (42.7), and LFM2.5-2.6B (33.2) in its size class. On the Artificial Analysis Intelligence Index v4.2 it scores 15 — the highest of any open-weight model under 4B parameters. It even matches Qwen3.5-9B on aggregate. From a model you can download in 1.55 GB.

The headline numbers: 46.4% on SWE-bench Verified (a 2B model solving real GitHub issues), 86.5% on AIME 2025, 69.1 on LiveCodeBench v6, 66.6 on BFCL v4 (tool use), and 97.1 on τ²-Bench Telecom. It natively supports 131K context — absurd for a 2B model — and ships with tool calling, thinking mode, and RL-trained agentic capabilities. The training recipe is fully open: OpenBMB released the datasets (UltraData-SFT, UltraData-RL, UltraData-Agent), training recipes, and RL infrastructure alongside the weights.

The hardware story is where it gets silly. At INT4, the model is 1.55 GB. It runs on a Galaxy S26, an iPhone 17 Pro, a Raspberry Pi if you're patient, and certainly any laptop made in the last five years. OpenBMB tested it on phones via LiteRT-LM with both CPU and GPU backends. The Guide's recommendation: if you're building an on-device assistant, a local coding copilot, or an edge agent, this is your starting point. It's not going to write your dissertation, but it will run entirely offline on hardware you already own, and that changes the economics of edge AI.