Model Library

Qwen3-Coder-480B-A35B is a coding agent that does not think — deliberately. It supports only non-thinking mode and emits no reasoning blocks, which on a workload of hundreds of chained tool calls is a design decision rather than a limitation: every step is a direct action, and none of them pays for a deliberation pass. It carries 480 billion parameters across 62 layers with 35 billion active, a 262,144-token window extendable to a million, and a function-call format built specifically for it. Qwen shipped a command-line agent alongside the weights, adapted from an existing tool with prompts and calling protocols rewritten to match.

Qwen3-235B-A22B-Instruct-2507 is what happens when a dual-mode model is split in two. The original switched between thinking and non-thinking; this release took the non-thinking half and spent three months improving it alone, while a sibling did the same for the reasoning half. The result answers directly and emits no reasoning blocks — and the parameter that used to disable thinking is now accepted and ignored, so existing code upgrades without changes. It carries 235 billion parameters across 94 layers with 22 billion active, 128 experts with eight selected per token, and a 262,144-token context that is native rather than extended.

Qwen3-32B is the largest dense model in its generation, and the deliberate counterpart to a sparse sibling of almost identical total size. Where that model activates three billion parameters per token, this one activates all 32.8 billion — every layer, every weight, every time. Sixty-four layers with sixty-four query heads against eight key-value heads, and the same two-mode design as the rest of the family: reasoning and direct answering, switchable by writing a tag into the conversation. Tool calling is documented on both sides, which makes a two-speed agent a real option rather than a compromise.

Qwen3-Next-80B-A3B-Instruct activates three billion parameters out of eighty — under four percent, with ten experts selected from five hundred and twelve. The efficiency claim behind that ratio is measured rather than asserted: the base model outperforms a 32-billion-parameter dense predecessor at ten percent of the training cost and ten times the inference throughput on long context. Its layer layout interleaves three linear-attention blocks with one full-attention block, twelve times over, so only twelve of forty-eight layers pay quadratic cost. Native context is 262,144 tokens, extensible past a million.

Qwen2.5-72B-Instruct was pre-trained on eighteen trillion tokens, and its improvements in coding and mathematics came from a specific source Qwen name outright: specialised expert models in those domains, distilled in. It also claims something most cards do not — resilience to the diversity of system prompts, meaning it holds up when handed an unusual instruction structure rather than only a conventional one. That matters for role-play and for any application where the system turn is written by someone other than you. Input and output share a 32,768-token budget, with generation capped at 8,192, across twenty-nine languages including Arabic.

Qwen3-14B carries 14.8 billion parameters across 40 layers, and switches between reasoning and direct answering without changing models. The switch is a tag: write /think or /no_think into a message and the mode changes on that turn, which makes deliberation a per-turn decision rather than a per-integration one. Tool calling works in both modes, which most switchable models cannot claim — so a fast-path agent is a real option rather than a compromise. Native context is 32,768 tokens, extendable to 131,072 with positional scaling, across more than a hundred languages under Apache 2.0.

Gemma 3 4B fits in 2.6 gigabytes at int4 and carries the same vision encoder as the 27-billion-parameter model at the top of its family — frozen and shared across sizes, so perception does not shrink with the model. It reads text and images across a 128K context window on hardware where that combination is normally impossible: a phone, a single-board computer, an integrated GPU. Google describe it as competitive with the previous generation's 27B flagship. What it costs you is measurable and concentrated in hard reasoning, where the gap to the larger siblings is real.

Gemma 3 27B was built to be the most capable model you can run on one GPU, and the quantisation numbers make that literal: 54 GB at bfloat16 drops to 14.1 GB at int4, which fits a desktop RTX 3090. The saving comes from quantisation-aware training rather than a conversion applied afterwards, so quality stays close to full precision. Its 128K context rests on a 5:1 ratio of local to global attention layers — a design Google measured as cutting KV-cache overhead from sixty percent to under fifteen. It reads text and images across 140 languages, with an 8,192-token output ceiling.

Qwen3.5-9B fits a 262,144-token window and a vision encoder onto a single 24 GB card. Thirty-two layers, twenty-four of them linear attention carrying sequence state at constant cost, with full attention on every fourth — a layout the configuration publishes explicitly as a per-layer list rather than leaving implicit. The vision tower is the same twenty-seven-block encoder its much larger siblings use, which means perception does not shrink with the model. It is the smallest dense member of its family that keeps reasoning and tool calling intact, across 201 languages under Apache 2.0.

Gemma 3 12B reads images the way a person does when the print is small: it looks at the whole thing, then looks closer at the parts. Its vision encoder compresses every image into exactly 256 tokens at 896×896 — efficient, and destructive on a wide screenshot or a tall document. Pan & Scan solves that at inference time by cutting the image into non-overlapping crops and processing each separately, worth a measured 8 to 17 percent on tasks that require reading text from images. The 128K context comes from interleaving five local attention layers per global one, so only one layer in six carries a large cache, at a perplexity cost under five percent.

Compared with GLM-4.5, GLM-4.6 brings several key improvements: Longer context window: The context window has been expanded from 128K to 200K tokens, enabling the model to handle more complex agentic tasks. Superior coding performance: The model achieves higher scores on code benchmarks and demonstrates better real-world performance in applications such as Claude Code、Cline、Roo Code and Kilo Code, including improvements in generating visually polished front-end pages. Advanced reasoning: GLM-4.6 shows a clear improvement in reasoning performance and supports tool use during inference, leading to stronger overall capability. More capable agents: GLM-4.6 exhibits stronger performance in tool using and search-based agents, and integrates more effectively within agent frameworks. Refined writing: Better aligns with human preferences in style and readability, and performs more naturally in role-playing scenarios.

Qwen3.6-27B is a dense 27-billion-parameter model that outperforms the previous generation's 397-billion-parameter flagship on every major coding benchmark — including an eighteen-point margin on SkillsBench. It is dense by choice: no expert routing, no MoE complexity, a stack that deploys straightforwardly across llama.cpp, SGLang, and vLLM. Sixty-four layers, three quarters of them linear attention. And it introduces thinking preservation, an option to retain reasoning traces across conversation turns rather than discarding them — which on a multi-turn coding session means the model stops re-deriving what it already worked out.

Qwen3.5-35B-A3B holds thirty-five billion parameters and works three per token, across forty layers where three quarters carry sequence state at constant cost and one quarter does exact retrieval. Two hundred and fifty-six experts, nine active. A twenty-seven-block vision encoder handles images and video in the same stack, trained by early fusion rather than attached afterwards. The result is a natively multimodal model with a 262,144-token window that runs at a small model's compute — released February 2026 under Apache 2.0, across 201 languages.

Qwen3.5-27B runs Gated DeltaNet as its primary attention mechanism across three quarters of its layers, paired with sparse mixture-of-experts — which is how a model at this scale holds a 262,144-token window without the memory cost that usually implies. Its reinforcement learning was scaled across million-agent environments with progressively harder task distributions, aimed at behaviour that transfers to real workloads rather than to benchmarks. It fits on a single 80GB card at FP8, extends past a million tokens with positional scaling, and ships under Apache 2.0.

Qwen3-VL-30B-A3B-Instruct runs the same vision stack as the flagship of its series on roughly three billion active parameters. DeepStack, interleaved multi-axis positional encoding, timestamp-grounded event localisation, and OCR across 32 languages — all present, none reduced. What scales down is the language reasoning over what it sees, not the seeing itself. That combination is unusual and it decides the workload: document archives, receipt pipelines, video indexing at volume, where per-page cost determines whether the corpus gets processed at all rather than how well.

Qwen3-VL-235B-A22B-Instruct is the vision-language flagship of its series, and three named mechanisms explain what it does differently. DeepStack fuses features from multiple levels of the vision encoder rather than reading only its final layer, which is where fine detail survives. Interleaved-MRoPE allocates positional frequency across time, width, and height together for long-horizon video. And text–timestamp alignment grounds events to the second rather than to the clip. Its OCR covers 32 languages and is built for low light, blur, and tilt — real photographs rather than clean scans. It answers directly, with no reasoning blocks.

Mistral Nemo was built jointly by Mistral AI and NVIDIA as a drop-in replacement for Mistral 7B — same interface, thirty-two times the context, and a substantial capability gain with no code to change. Its 128k window comes from a rotary embedding theta of one million, a hundred times the conventional value, rather than from positional scaling applied afterwards. Grouped-query attention at four to one keeps the key-value cache small, and a 131,072-token vocabulary makes it efficient across the nine languages it was trained for. Apache 2.0, and supported across three inference frameworks including NVIDIA's own.

Mistral Small 3 is the model that established the line: 24 billion parameters, described by Mistral as knowledge-dense enough to fit on a single RTX 4090 or a 32GB MacBook once quantized. Its 32k context and text-only input mark it as the first generation — vision and the longer window came later. Two things distinguish it operationally: strong adherence to system prompts, which the model card treats as the primary control surface, and a published example system prompt that injects the current date and instructs the model to ask for clarification rather than answer an ambiguous question. Apache 2.0, ten languages.

Mistral Small 3.2 is a minor update that fixes three specific things, and the most valuable of them is measured: infinite generations — where a model repeats itself until it hits the token ceiling — were halved on long, repetitive prompts. Instruction following tightened, and the function-calling template was rebuilt to be more robust. Everything else matches or slightly improves on the release before it. It reads text and images across a 128,000-token window, covers twenty-four languages, and ships under Apache 2.0 with a recommended temperature of 0.15 — unusually low, and directly connected to the repetition fix.

gpt-oss-120b is OpenAI's largest open-weight model and the first release of its kind since 2019. It carries roughly 117 billion parameters and activates about five per token, which is what lets a model of this capability run on a single 80GB card rather than a cluster. Reasoning effort is set as plain text in the system prompt across three levels, and the full chain of thought comes back unredacted — OpenAI published the accuracy-versus-length curve across all three settings, so the cost of deliberation is measured rather than implied. It ships under Apache 2.0 with no copyleft, no patent conditions, and no user ceiling.

Claude Opus 4.8 answers directly unless asked to think — the opposite default from the generation that replaced it, and the reason some integrations still prefer it. A plain request returns text immediately, with no reasoning blocks ahead of the answer and no deliberation budget to account for. Adaptive thinking is available per request when a task needs it, and switching it off works at any effort level rather than only below a threshold. It carries a million-token context window with a 128,000-token output ceiling, reads text and images, and offers a fast mode that runs at roughly two and a half times normal speed through a research preview.

gpt-oss-20b is OpenAI's smaller open-weight reasoning model, and the one that fits on hardware you already own — 21 billion parameters with 3.6 billion active per token, loading in about 16 GB of memory. Reasoning effort is set in the system prompt as plain text rather than through a parameter, and the full chain of thought comes back unredacted, which makes debugging a model's mistakes possible in a way closed reasoning models do not allow. It ships under Apache 2.0 with no copyleft or patent conditions, is designed to be fine-tuned, and carries built-in support for browsing, Python execution, and function calling.

Gemma 4 31B is the largest dense model in Google DeepMind's open family, and it is built to read as much as it reasons. A 256,000-token context window takes entire codebases or large sets of images in one prompt, with a vision encoder that accepts variable aspect ratios rather than forcing everything into a square — which is why it handles UI screenshots, charts, and handwriting recognition rather than approximating them. Thinking is configurable rather than fixed, function calling is native, and the model was pre-trained on more than 140 languages with 35 supported out of the box. Apache 2.0, and it fits on a workstation.

Llama 3.1 70B is the release that brought long context to Meta's open models — sixteen times the previous generation's window, from 8,192 tokens to 131,072, in a single step. It carries fifteen trillion pre-training tokens, grouped-query attention, eight supported languages, and a knowledge cutoff of December 2023. Its direct successor shares every one of those specifications and differs only in post-training, which makes the choice between them unusually simple: same size, same window, same cost, improved behaviour. This model remains the foundation a great many fine-tunes were built on.