The Nexus

Gemma 4 ships in five sizes, and each size ships as a base model and an instruction-tuned one; Qwen3.8-27B ships with thinking on by default and a switch to turn it off; gpt-oss OpenAI ships with a reasoning-effort dial marked low, medium and high. Before you have chosen a family you are already choosing among variants.

You have met this: the picker, again. A chat product's picker is this choice with the filenames taken off: often a fast model and a thinking one, sometimes a small one and a large one. The card's words are the picker's words, and the rest of this section is what they mean. A coding agent may expose the same sort of choice; a coder variant, where a family ships one, is a separate checkpoint and not a setting.

How it works. The loop the Origin tier gave you: predict the next token from all the tokens so far, pick one, append it, ask again, until the model emits its stop token. A chat is that loop, wrapped in the template from the Vector tier.

The words. Two paragraphs here, the variants and the context; the next section takes what the model emits, the dials and the two speeds.

The variants. A base model is the raw result of pre-training; it continues text and is not built to answer. An instruct or chat model has been post-trained to answer; the -it on Gemma's Google DeepMind names and -Instruct on Llama's Meta mean this, and Qwen's plain Qwen3.8-27B is already post-trained according to its card. A thinking or reasoning model spends tokens on working before its answer, which may be shown, hidden or summarised depending on the system; Qwen's Alibaba card calls it thinking mode and makes it default, gpt-oss calls it reasoning effort, and Gemma 4 offers a token budget for it in five fixed steps from 70 to 1,120 tokens. That working is output tokens, as the Vector tier said, and gpt-oss's card is explicit that it is not meant to be shown to end users. Vision or VL variants take images; on the hub the task tag image-text-to-text marks them, and Qwen3.8-27B, Gemma 4 and both Llama 4 models carry it. Coder variants exist as separate checkpoints in most families.

Context. The window is a token count from the card: 262,144 for Qwen3.8-27B and the larger Gemma 4 models, 131,072 for the Gemma 4 edge models and gpt-oss, 1,048,576 for DeepSeek V4 and Kimi K3 Moonshot; GLM-5.3's config exposes the same figure and its card evaluates at 1M without stating a headline context length. It is a limit on what the model can see, not on what it knows, and a bigger window costs memory for the cache that holds it. That cache, the KV cache, has its own guide; here it is enough to know it exists and grows with context. It is also request state: each active request needs cache space of its own, apart from any prefix the runtime can share, so the weights stay fixed while the cache grows with every request being served at once, and a server can become limited by cache space even though the weights are shared. vLLM prints both when it starts, the cache's capacity in tokens and an estimate of how many requests of a given length it can serve at once.

The anchors. Licence and gating as read from the hub on the day this guide was checked. Total parameters as counted in the safetensors files (the file), with the card's own total where it differs; active parameters and routing from the card; context as the maker advertises it on the card, which is the supported figure, since a config can expose a larger number than the maker will stand behind.

Three things in that table to notice. Almost every large model in this table is a mixture of experts, and the active counts are small next to the totals: Kimi's 2.8 trillion runs 104 billion per token, 16 of 896 experts plus 2 shared. The million-token context sits at the top of the table and Llama 4 Scout claims ten million. And the Gemma edge models carry two parameter counts, because the "E" means effective: the card says the E2B file holds 5.1 billion parameters of which 2.3 billion are counted as effective, the rest being per-layer embeddings kept out of the count. The trade's word for the small end of the table is small language model, or SLM, and it is a size, not a kind.

What runs it. The Qwen card names Transformers, vLLM, SGLang and TokenSpeed, and says the last three are for production and high throughput. The GGUF world, llama.cpp and the tools built on it (Ollama and LM Studio among them), is optimised first for local inference on one machine, though it can serve an API to several users; vLLM and SGLang are designed around high-throughput serving and batching. Both worlds advertise an OpenAI-compatible endpoint, an address that accepts requests in the shape one provider's API made common, which means a basic chat call can move between them, or to a provider's API, with little change; tool calling, reasoning controls, image input and structured-output extensions (4.6) differ between providers, and those parts of your code will not move as cleanly.

Memory floor. The weights, plus the KV cache for the context you will use, plus the runtime's own working space; a 15.5 GB file does not comfortably fit a 16 GB card. For Qwen3.8-27B: 16.46 GB for the Q4_K_M plus 0.93 GB for the vision projector, before any context. gpt-oss's own card gives its floors directly: the 120b on a single 80 GB card, the 20b within 16 GB, both because the MoE weights were post-trained at MXFP4. MXFP4 is the four-bit floating-point member of the Microscaling (MX) formats, which pair a narrow number type with a scale shared across a block of values; gpt-oss ships its MoE weights in it from the maker, rather than as a later third-party quantisation. For everything else, read the file sizes in the quantiser's folder and add room for the window you intend to use. Where the quantiser publishes quality measurements, look for perplexity or KL divergence against the BF16 or base model; that comparison is the measured loss the Vector tier meant. When the weights do not fit on one accelerator, runtimes can split the model across several; tensor parallelism, named at 2.12, is one common way to do it.

The licence trap. The same family carries permissive and restricted checkpoints side by side. On the day, Qwen3.8-27B was Apache 2.0 and Qwen3.8-Flash-Next, released two weeks later by the same lab, was under a Qwen community licence. "Qwen is Apache" is not a sentence; "this checkpoint is Apache" is.

What people get wrong. Choosing by leaderboard rank. The rank measures the vendor's benchmarks on the vendor's settings, and a smaller model that fits your card with room for context beats a larger one that spills. Choose by fit, then by the languages you need (Gemma 4's card claims 35+ supported and 140+ in pre-training; test yours), then by the task, and only then by the table.

New here: attention, the KV cache and the Transformer. How the next-token prediction is computed, why context costs memory, and what "Gated DeltaNet" on the Qwen card means belong to neural networks, and to attention and the KV cache. Nothing here needs them.

What it emits. Before the dials make sense, one paragraph on what the model produces. For each position it emits a score, a logit, for every token in its vocabulary. Those scores are turned into a probability distribution. Then a token is chosen from it: greedy decoding takes the most probable one every time and is deterministic; a sampler draws from the distribution, and temperature, top-p, min_p and the penalties reshape the distribution before the draw. That draw is why the same prompt gives a different answer twice; a fixed seed improves reproducibility on the same runtime and hardware, but kernels, batching and parallel execution can still make two runs differ.

The dials. The Ollama entry for qwen3.8:27b lists the parameters it applies: a temperature, a min_p, a presence penalty, a repeat penalty and a draft count of four. Every runtime exposes some version of these. Temperature and the p-cutoffs shape how the next token is picked from the prediction, the penalties discourage repetition, and the context length setting decides how much of the window the runtime actually reserves. The draft count is speculative decoding: the runtime guesses several tokens ahead and checks them in one pass. A model shipped with MTP heads, extra output layers trained to guess several tokens ahead (4.2), can do the guessing itself with no second model, and this one is. Runtimes also carry toggles for the attention kernel and for quantising the context cache; their documentation names them.

Same word, different thing: parameters. A parameter is one of the model's learned numbers, which is what 27B counts. The parameters a runtime lists are its settings: temperature, min_p, the penalties. One set is in the file and fixed; the other is on the dial and yours. A card that says "parameters" means the first, and a runtime page almost always means the second.

Two speeds. Time to first token is usually dominated by the prefill: the whole prompt read at once, compute-heavy, plus whatever queueing and overhead the server adds. Tokens per second after that is the decode: one token at a time, and often limited by how fast the parameters can be read from memory rather than by arithmetic. At low concurrency, when decode is bound by memory bandwidth, a useful ceiling is memory bandwidth divided by the bytes that must be read for each generated token; batching reuses those weight reads across more work, raising aggregate throughput rather than making one request proportionally faster. The point here is that a model can be fast at one and slow at the other, and a benchmark quoting only one is hiding the other.

The FLUX.2 Black Forest Labs [klein] 4B card says the model fits in about 13 GB of VRAM and runs on an RTX 3090 or 4070 and above. The FLUX.2 [dev] card describes a 32-billion-parameter rectified flow transformer. Same family, two months apart, an eight-fold gap in size, and the smaller one has the number you can act on.

How it works. An image model starts from noise and removes it in steps, steered by a text description. The steering needs the text turned into numbers first, so the folder holds one or more text encoders, commonly from the CLIP or T5 families; Stable Diffusion 3.5's Stability card lists three, two CLIP encoders and a T5. These are encoders, not chat models, which is one reason prompting them differs. The image is built in a compressed space and decoded to pixels at the end by a third component, the VAE, a small model that squeezes a picture into a compact form and expands it again.

Same word, different thing: step. Here a step is one denoising pass at generation time. In a training log a step is one update of the weights. Same word, different clock.

The words. Steps are denoising passes; more is slower and, up to a point, better. Guidance (CFG on the older cards) is how hard the model is pushed towards the prompt. The sampler or scheduler is the update rule that takes each step, and the noise or timestep schedule decides which noise levels the steps visit; tools name them separately and the two are often confused. A seed makes a run reproducible under the same deterministic setup. Negative prompt is what to steer away from. Inpainting fills a masked region, outpainting extends the canvas, image-to-image starts from a picture rather than noise, and an edit model takes an instruction about an existing image; on the hub, text-to-image and image-to-image are the task tags. ControlNet and its relatives condition the image on a pose, a depth map or an edge drawing. A LoRA here is a style or a character. A turbo or distilled checkpoint is one trained to need far fewer steps (the Apex tier has a box on the other thing "distilled" means): Z-Image-Turbo's card claims eight function evaluations and sub-second latency. An upscaler is a separate model.

The architecture words on the cards are MMDiT (Stable Diffusion 3.5's card), rectified flow transformer (FLUX.2's), and MoE (HunyuanImage 3.0's card: 64 experts, 80 billion parameters, 13 billion active). You do not need any of them to choose; DiT and flow matching are the family names, and the Apex tier lists them with the rest.

The anchors. Parameters as counted in the safetensors files; the hub's diffusers library tag on every one except HunyuanImage 3.0 (transformers) and Sana (sana).

What runs it. The diffusers library is the reference runtime and is what most cards give code for. ComfyUI is the node-based front end that the FLUX.2 [dev], Stable Diffusion 3.5, LTX-2.5 and Wan 2.2 Alibaba cards point to by name, and it is where LoRAs, ControlNets and upscalers get wired together.

Memory floor. From the cards: FLUX.2 [klein] 4B at about 13 GB. The other cards in the table do not state a figure, and the 32B and 83B models plainly need more than a consumer card without offloading. The rule is the same as for language models, parameters times bytes, plus working space that grows with resolution rather than context.

The licence trap. Look at the table. Every Stability and Black Forest Labs "dev" checkpoint is under a custom licence with automatic gating; the Apache 2.0 checkpoints are the Chinese labs' and Black Forest Labs' small ones. "Non-commercial" in a licence name means what it says, and the commercial licence is a separate purchase.

What people get wrong. Prompting an image model like a chatbot. It does not converse. Classic text-to-image prompts are descriptions; edit models are often instruction-following; either way the card's examples show the form its text encoders were trained on. Read them before writing your own.

The LTX-2.5 card offers the model at no cost for commercial use to organisations under ten million dollars in annual revenue and points larger ones to a separate agreement. Mochi 1's card gives three memory figures for one model: 60 GB on a single card, 42 GB for the highest-quality example, 22 GB with a lower-precision variant and a small drop in quality. Both facts are typical of the family.

How it works. The same denoising as image generation, with time as an extra dimension: the model generates a block of frames together so they agree with each other. The compressed space is bigger by the number of frames, which is why memory floors sit an order of magnitude above image models. The newest models generate the soundtrack in the same pass: LTX-2.5 lists text-to-audio, audio-to-video and video-to-audio among its modes.

The words. Text-to-video, image-to-video (animate a still) and video-to-video are the task tags. Reference-to-video conditions on a subject. Temporal coherence is whether the frames agree. Resolution and length limits are on the card and are the numbers that matter: Wan 2.2's TI2V-5B card says 720p at 24 frames per second, and its 14B models list 480p and 720p. Wan 2.2 also puts a mixture of experts inside a video diffusion model, which its card says was borrowed from language models.

The anchors.

What runs it. The diffusers library on the LTX Lightricks, Mochi and CogVideoX cards; the makers' own code on Wan (wan2.2) and HunyuanVideo; ComfyUI on the LTX and Wan cards.

Memory floor. The cards say it themselves, and the numbers above are theirs: 14 GB minimum for HunyuanVideo 1.5 with offloading, 24 GB for the small Wan, 80 GB for the large one as shipped, 22 to 60 GB for Mochi. Offloading, moving parts of the model to system memory between steps, is what makes the low figures possible and is why the same model has three.

The licence trap. Revenue caps. The LTX-2.x community licence is the clearest case, but the pattern is a "community" licence whose terms depend on who you are. Read the card's licence section, not the badge.

What people get wrong. Assuming the successor will ship on the same terms. Between LTX-2 and LTX-2.5 the licence name changed and gating went from none to automatic; the family name stayed. Anchor on the checkpoint you have, and read the next one's card as if it were a stranger's.

Whisper OpenAI large-v3 hears thirty seconds at a time; its card says so, and anything longer is cut into thirty-second windows and stitched. It transcribes and translates, lists 99 language codes on its card, and does not say who was speaking. For that you download a second model, and for deciding where speech starts and stops, a third.

How it works. A listening model usually converts audio into time-frequency or learned features and reads them the way a language model reads tokens, emitting text; Whisper's card describes its spectrogram input, a picture of which frequencies are present at each moment, and other architectures differ. A speaking model runs the other way: it predicts an acoustic or latent representation, a compressed internal form, that a decoder or vocoder turns into waveform audio. Diarisation is a separate model that clusters the audio by voice and labels the segments; it does not know what was said.

The words. ASR and STT both mean speech to text; the hub's task tag is automatic-speech-recognition. WER, word error rate, is its number. Streaming means transcribing as the audio arrives; batch means after. Real-time factor is how long it takes per second of audio. TTS is text to speech; its task tag is text-to-speech, it has no single number (listening-test scores such as MOS, intelligibility and speaker-similarity metrics are all used), and voice cloning is producing a voice from a sample (the Qwen3-TTS card says three seconds of audio is enough for its base model). Voice design is producing a voice from a description. VAD, voice activity detection, is the gatekeeper that tells the others when there is speech at all. Conversational speech models take both text and audio as input and generate speech that fits the conversation, the CSM card being the reference. Inverse text normalisation turns "two hundred" into "200" and is on the card as a feature when it is there.

Same word, different thing: batch. Three of them. In 2.2 a batch is how many requests a runtime is serving at once, which is a count. Here it is the opposite of streaming: transcribing after the audio has arrived rather than as it does, which is a timing. In 4.6 it is a file of requests sent together and returned within hours at a reduced rate, which is a price. Nothing on a page tells you which; the sentence around it does.

The anchors.

What runs it. Transformers for the Whisper family and Moonshine, NVIDIA's NeMo for Parakeet, Canary and Sortformer, the pyannote-audio library for pyannote, and each TTS model's own library or code; the library field on the card says which. Qwen3-ASR ships its own vLLM-based toolkit.

Memory floor. Most listening models are small: the largest listening model above is 2.35 billion parameters and most are under one billion, so a few gigabytes of memory or a CPU is enough for one stream and the cost is in throughput, not fit. Speech generation ranges wider; the table runs from 82 million to 5.77 billion parameters, and the large end needs a GPU.

The licence trap. The Creative Commons family. CC BY 4.0 is permissive with attribution; CC BY-NC and CC BY-NC-SA are non-commercial, and three of the popular speech models above carry them. A speech pipeline is three or four models, and the deployment has to comply with every licence in it; one non-commercial component constrains the whole use case.

What people get wrong. Expecting one download to transcribe, diarise, detect speech and stream. Whisper itself does not natively provide diarisation, voice activity detection or streaming; wrappers add chunked streaming around it, and the other two are separate models. Build the pipeline, then read every licence in it.

The Qwen3-VL-32B card claims the model can operate PC and mobile interfaces, recognise elements and complete tasks, and ground objects in two and three dimensions. The SAM 3 Meta card claims the model can detect, segment and track objects in images and video from a text prompt or a point, box or mask. They are answering different questions with the same word, vision.

How it works. Understanding models come in two shapes. The older shape is task-specific: an image goes in, a label, a set of boxes, a mask or a string of text comes out, and the task tag on the hub names which (image-classification, mask-generation, zero-shot-image-classification). The newer shape is a language model with a vision encoder attached, the VLM: image and text go in, text comes out, task tag image-text-to-text, and the same model reads a document, describes a scene and answers questions about a chart.

The words. Classification names the image. Detection draws boxes. Segmentation draws masks; promptable segmentation lets you say which object. OCR reads text out of pixels; document understanding reads structure too. ViT is the vision transformer, the image-side architecture most of these share. CLIP and its successors (SigLIP Google DeepMind is one) are pairs of encoders, one for images and one for text, trained so that matching pairs land close; the CLIP card describes the contrastive training, and that pairing is what gives zero-shot classification, naming a category the model was never trained on. Grounding is pointing at where in the image something is.

The anchors.

The Gemma 4 and Qwen3.8 language models from the first section are also on this list by task tag. A VLM is its own checkpoint, with vision components inside it, and runs on the language-model runtime family; the task tag is how you spot one.

What runs it. Transformers for all of the above except PaddleOCR-VL, which lists its own library. The VLMs run on the same engines as language models, vLLM and llama.cpp included, because that is what they are.

Memory floor. The task-specific models are small, from 87 million to about a billion parameters. The VLMs are language-model sized and follow the language-model rule: the file plus the context, and images cost tokens.

The licence trap. SAM 3 is under a custom licence with manual approval while its predecessor is Apache 2.0. CLIP's OpenAI card states no licence field at all, which is not the same as permission.

What people get wrong. Using a VLM for pixel-precise work. It describes and it grounds; it does not draw a mask to the pixel. For that, the task-specific models exist, and they are a tenth the size.

all-MiniLM-L6-v2 is 23 million parameters, Apache 2.0, and on the day this guide was checked showed a download count in the hundreds of millions, more than any language model in this guide. It generates nothing. It turns a sentence into 384 numbers.

How it works. An embedding model reads text and outputs a fixed-length list of numbers, a vector, positioned so that texts with similar meaning land near each other. Search is then geometry: embed the query, find the stored vectors closest to it. A reranker is the second stage, a model that reads the query and a candidate together and scores how well they match; it is slower and more accurate, so it runs on the shortlist the embedding search produced. This two-stage search is what the Apex tier calls retrieval, and RAG is a language model reading its results.

The words. Dimensions is the length of the vector: 384 for MiniLM, up to 1,024 for Qwen3-Embedding-0.6B, 768 for EmbeddingGemma. Matryoshka (MRL on the cards) means the vector can be truncated to a shorter one and still work; EmbeddingGemma's card lists 512, 256 and 128, and Qwen's says any length from 32 to 1,024. Cosine similarity is the usual measure of "near". Bi-encoder is the embedding shape (query and document encoded separately); cross-encoder is the reranker shape (encoded together). Semantic search is search by meaning; keyword search is by exact terms; hybrid is both, merged. Multimodal embeddings put images and text in the same space; on the hub the task tag visual-document-retrieval marks the ones built for pages and screenshots. MTEB is the benchmark: eight task types, 58 datasets and 112 languages in the paper that defined it, with a public leaderboard on the hub.

The anchors.

What runs it. The sentence-transformers library is the library field on most of these cards and is the reference runtime. Several also run under the language runtimes in an embedding mode; the card's usage section says which.

Memory floor. Near zero. Everything above except the Qwen 4B and 8B fits in a couple of gigabytes, and CPU is a normal place to run them.

The licence trap. Two of the best-known families ship under CC BY-NC (Jina) and a custom gated licence (EmbeddingGemma). The embedding model is the one component you cannot swap later without re-indexing everything, so its licence is the one to settle first.

What people get wrong. Changing the embedding model between index time and query time. Every vector in the index (the stored collection of vectors, not the index file of 1.3, which lists tensors) was made by one model; a different model's query vector lands in a different space and matches nothing. Pin the model, and re-index when you change it.

The scikit-learn user guide's table of contents is a map of the machine learning that ran the world before 2020 and still runs most of it: linear models, support vector machines, nearest neighbours, decision trees, ensembles of trees (gradient boosting, random forests), clustering, dimensionality reduction, outlier detection. Almost none of it is distributed as a model card on the hub, and it is less often what current AI marketing means by AI, though classifiers, recommenders and vision systems are AI by any older definition.

How it works. A classifier sorts an input into categories. A regressor predicts a number. A clustering method groups things without labels. An anomaly detector flags what does not fit. A recommender ranks items for a person. A forecaster predicts the next values of a series. Each is trained on a table of examples, produces a model that is usually kilobytes to megabytes, and runs on an ordinary processor fast enough that nobody measures it in tokens per second.

The words. Supervised means the examples had labels; unsupervised means they did not; semi-supervised is in between; the scikit-learn guide is organised by exactly that split. Features are the columns. Gradient-boosted trees are the workhorse for tabular data. Overfitting is memorising the examples rather than learning the pattern. Reinforcement learning is a way of training, not a kind of model, and the Apex tier places it.

Why it is here. Three reasons. It remains widespread in production. None of the VRAM story applies to it. And it is the anchor for a reader whose own organisation already runs it under some other name: fraud scoring, churn prediction, demand forecasting.

What people get wrong. Reaching for a language model to sort a table. If the inputs are columns and the answers are categories, the model that does it is in the scikit-learn guide, runs on a laptop, and does not hallucinate in the generative sense; it can still be confidently wrong, which is what its evaluation metrics measure.

The families from this tier, with what the folder holds, what opens it, the memory it needs, and the checkpoint that anchors it on the day this guide was checked.