When you see “mini,” “nano,” or “pro” appended to a model name, you’re looking at a capability tier — a shorthand for the parameter count, context window, and inference cost relative to the flagship model in that family. These suffixes don’t follow a universal standard; each lab defines its own thresholds, but the pattern is consistent: smaller suffixes mean fewer parameters, shorter context, lower latency, and lower price, while “pro” or “ultra” marks the most capable (and expensive) variant. Understanding the actual differences lets you pick the right model for the job without overpaying for intelligence you don’t need.
How labs structure model tiers
Every major lab releases model families in at least three sizes. The naming varies — Google uses Nano/Flash/Pro/Ultra, OpenAI uses mini/nano (and previously turbo), Anthropic uses Haiku/Sonnet/Opus, Mistral uses Small/Medium/Large — but the underlying architecture is the same: a single training run produces a large teacher model, then distillation or early-stopping creates smaller students.
# Conceptual: how a lab derives tiers from one training run
class ModelFamily:
def __init__(self, base_checkpoint):
self.teacher = base_checkpoint # e.g., 1T+ params, full context
self.distilled = {
"nano": distill(teacher, target_params=1_000_000_000), # ~1B
"mini": distill(teacher, target_params=7_000_000_000), # ~7B
"pro": quantize(teacher, bits=4), # full size, 4-bit
"ultra": teacher # fp16/bf16
}Distillation preserves reasoning patterns but compresses knowledge. Quantization (pro/ultra) keeps the full parameter count but reduces precision. The result: nano models run on-device; mini models fit on a single GPU; pro/ultra models need multi-GPU or TPU pods.
What each tier actually buys you
| Tier | Typical params | Context window | Latency (ttft) | Cost per 1M tokens | Best for |
|---|---|---|---|---|---|
| Nano | 0.5–2B | 1k–32k | <50 ms | $0.02–$0.10 | Classification, extraction, on-device |
| Mini | 3–8B | 32k–128k | 50–150 ms | $0.10–$0.50 | RAG, summarization, structured output |
| Pro | 70B–200B+ | 128k–2M | 200–800 ms | $1–$5 | Complex reasoning, coding, long context |
| Ultra | 400B–1T+ | 1M–10M | 500 ms–2 s | $5–$30 | Research, agent loops, maximum accuracy |
These numbers shift every release cycle. Gemini 1.5 Flash (mini-tier) now beats Gemini 1.0 Pro on many benchmarks. GPT-4o-mini outperforms the original GPT-4 on MMLU. The only reliable signal is the lab’s own benchmark table — not the suffix.
Why the naming exists
Three forces drive this taxonomy:
- Inference economics. Serving a 1T-parameter model costs 100× more than a 7B model. Labs need price discrimination.
- Deployment constraints. Mobile apps need nano; edge servers need mini; data centers need pro/ultra.
- Developer mental models. “Pro” signals “use this for production”; “nano” signals “prototype here, upgrade later.”
The suffix is a contract: if you build against the mini API, you can swap to pro later without code changes. That promise holds only when the lab maintains API compatibility across tiers — which most do, but not all.
Concrete example: Gemini 1.5 family
Google’s current lineup illustrates the pattern cleanly:
{
"gemini-1.5-flash": {
"tier": "mini",
"params": "~7B (distilled)",
"context": "1_048_576 tokens",
"input_price_per_m": 0.075,
"output_price_per_m": 0.30,
"use_case": "High-volume RAG, classification, low-latency chat"
},
"gemini-1.5-pro": {
"tier": "pro",
"params": "~200B (quantized)",
"context": "2_097_152 tokens",
"input_price_per_m": 1.25,
"output_price_per_m": 5.00,
"use_case": "Long-document reasoning, code generation, agent workflows"
},
"gemini-1.5-ultra": {
"tier": "ultra",
"params": "~1T+ (full precision)",
"context": "10_000_000 tokens",
"input_price_per_m": 7.50,
"output_price_per_m": 30.00,
"use_case": "Research, maximum accuracy, video understanding"
}
}Flash is the workhorse. Pro handles the hard cases. Ultra exists for when cost is no object. Notice that Flash gets the same 1M context window as Pro — context length is no longer a tier differentiator for Google.
Common misconceptions
“Mini is just a quantized pro”
False. Mini/nano/flash models are distilled — trained from scratch with the larger model as teacher. Quantization (pro → 4-bit) preserves weights; distillation transfers behavior. A 4-bit quantized 70B model still needs 40 GB VRAM. A distilled 7B model needs 6 GB. They serve different hardware targets.
“Higher tier always means better quality”
Not on every task. Distilled models often beat their teachers on narrow benchmarks (classification, extraction, function calling) because distillation acts as a regularizer. The teacher’s breadth becomes the student’s focus. Run evals on your data before assuming pro > mini.
“Naming is consistent across labs”
Anthropic’s Haiku (mini) is 3× larger than Google’s Flash (mini). Mistral’s Small (mini) is 22B — larger than Llama 3 70B (pro-tier by parameter count). The suffix only means relative to that lab’s flagship. Compare specs, not names.
“You should always start with pro”
Starting with pro masks architecture problems. If your RAG pipeline fails on Flash, it will fail on Pro — just more expensively. Build against the cheapest tier that could work. Upgrade only when evals prove the cheaper tier hits a ceiling.
How to choose in practice
def select_tier(task: Task, budget: Budget, latency_sla: float) -> ModelTier:
# 1. Can nano do it? (classification, entity extraction, intent routing)
if task.type in {"classification", "extraction", "routing"}:
return "nano"
# 2. Does it need long context + structured output?
if task.context_tokens > 32_000 and task.requires_json_schema:
return "mini" # flash/haiku/sonnet handle this well
# 3. Complex reasoning, coding, agent loops?
if task.type in {"coding", "multi_step_reasoning", "agent"}:
return "pro"
# 4. Research, video, maximum accuracy, cost no object?
if budget.unlimited and task.type in {"research", "video_understanding"}:
return "ultra"
# Default: start mini, measure, escalate
return "mini"This heuristic works across labs because the capability boundaries are similar even when names differ. The key is measuring — not guessing.
What changes next
Two trends are collapsing the tier distinction:
- Distillation is getting scary good. GPT-4o-mini scores 82% MMLU vs GPT-4’s 86%. The gap is narrowing to single digits on academic benchmarks.
- Context windows are equalizing. Flash, Pro, and Ultra all offer 1M+ context in Gemini 1.5. The differentiator shifts to reasoning depth per token, not window size.
Soon the only real difference between tiers will be latency and price. The “pro” suffix may disappear entirely — replaced by “standard” and “high-throughput” variants of the same model.
Quick reference: current suffix map (2024)
| Lab | Nano | Mini | Pro | Ultra |
|---|---|---|---|---|
| — | Flash | Pro | Ultra | |
| OpenAI | gpt-4o-nano | gpt-4o-mini | gpt-4o | — |
| Anthropic | — | Haiku | Sonnet | Opus |
| Mistral | — | Small (22B) | Medium (123B) | Large (200B+) |
| Meta | — | Llama 3.1 8B | Llama 3.1 70B | Llama 3.1 405B |
| DeepSeek | — | DeepSeek-V2-Lite | DeepSeek-V2 | — |
| Qwen | Qwen2-0.5B | Qwen2-7B | Qwen2-72B | Qwen2-57B-A14B (MoE) |
Bookmark the lab’s pricing page, not this table. The numbers change monthly.
Bottom line
What mini, nano, pro mean in model names is a capacity contract: this tier fits this hardware, meets this latency, costs this much, and handles this complexity. The suffix saves you from reading the model card every time — but only if you verify the contract still holds for the current release. Run your evals. Measure your latency. Pick the cheapest tier that passes.