GPT-5 naming explained: GPT-5, mini, and nano

OpenAI’s GPT-5 family introduces three distinct model tiers — GPT-5, GPT-5-mini, and GPT-5-nano — each optimized for different latency, cost, and capability targets. The naming follows a consistent size-based convention where “mini” indicates a distilled variant with reduced parameters and “nano” represents the smallest deployable footprint. This structure lets developers route requests to the appropriate tier without changing integration code.

How the naming maps to model architecture

OpenAI has not published exact parameter counts for GPT-5 variants, but the naming pattern aligns with established distillation practices. GPT-5 is the full-scale flagship model. GPT-5-mini is a knowledge-distilled version trained on GPT-5 outputs, preserving reasoning patterns at reduced parameter count. GPT-5-nano undergoes further compression — likely quantization-aware distillation or progressive pruning — to fit edge and ultra-low-latency constraints.

The API identifiers follow the pattern you would expect:

{
  "model": "gpt-5",
  "model": "gpt-5-mini",
  "model": "gpt-5-nano"
}

All three accept the same Chat Completions and Responses API surface. They share tokenizers, system prompt handling, and tool-calling schemas. The difference lives in the model weights served behind the endpoint.

Why the tiering matters for production systems

Model selection is a routing decision with direct impact on three axes:

Latency: GPT-5-nano targets sub-100ms first-token latency for simple completions. GPT-5-mini sits in the 200-400ms range. GPT-5 full runs 500ms-2s depending on context length and reasoning depth.

Cost per million tokens: Expect roughly 10x steps between tiers. If GPT-5 input costs $10/M tokens, mini lands near $1/M and nano near $0.10/M. Output tokens follow similar ratios.

Capability ceiling: GPT-5 handles multi-step agentic workflows, complex code generation, and long-context synthesis. Mini degrades gracefully on single-pass tasks — classification, extraction, summarization — but struggles with extended reasoning chains. Nano is reliable for intent classification, entity extraction, and template filling; it hallucinates more on open-ended generation.

This tiering lets you build a routing policy instead of hardcoding a single model:

def route_request(task_type: str, latency_budget_ms: int, context_tokens: int) -> str:
    if task_type in ("agentic", "complex_reasoning", "code_generation") and latency_budget_ms > 1000:
        return "gpt-5"
    if task_type in ("summarization", "classification", "extraction") and latency_budget_ms > 200:
        return "gpt-5-mini"
    return "gpt-5-nano"

Concrete example: support ticket triage pipeline

Consider a support system processing 50k tickets daily. Each ticket needs classification (billing, technical, account), priority scoring (P1-P4), and a draft response for human review.

Tier assignment:

• Classification + priority → GPT-5-nano (deterministic, high-volume, low-context)
• Draft response generation → GPT-5-mini (needs reasoning over ticket history, moderate latency budget)
• Escalation analysis for P1 tickets → GPT-5 (complex synthesis across multiple conversations, policy documents)

Cost projection (illustrative, not measured):

• Nano: 50k × 2 calls × ~500 tokens = 50M tokens/month → ~$5
• Mini: 50k × 1 call × ~2k tokens = 100M tokens/month → ~$100
• Full: 2k P1 tickets × 1 call × ~8k tokens = 16M tokens/month → ~$160

Total ~$265/month vs. ~$2,600 if everything routed to GPT-5. The nano tier handles 60% of token volume at 2% of cost.

Common misconceptions

“Mini and nano are just quantized versions of the full model.”
False. Quantization reduces precision (fp16 → int8/int4) on the same architecture. Distillation trains a smaller architecture to mimic the larger model’s outputs. GPT-5-mini and nano are distinct model checkpoints with fewer layers, attention heads, or embedding dimensions — not the same weights at lower precision.

“You can fine-tune mini or nano.”
As of this writing, OpenAI only offers fine-tuning on base models (GPT-4o, GPT-4o-mini). The GPT-5 family does not yet support fine-tuning on any tier. If you need domain adaptation, use few-shot prompting or RAG instead.

“Nano is just worse mini — never use it for anything important.”
Nano excels at high-volume, low-stakes classification where throughput matters more than nuance. Spam detection, language identification, and intent routing are legitimate nano workloads. The error profile differs: nano produces more false positives on edge cases but maintains consistent latency under load.

“The naming implies a linear quality gradient.”
Quality is task-dependent. On a 500-token summarization benchmark, mini may score 92% of full model quality at 10% cost. On a 50-turn coding agent task, mini might score 40%. The gradient is not uniform — test your specific workloads.

Routing directives and provider hints

When you route across tiers programmatically, you need observability on which model actually served the request. The response headers include the resolved model:

x-ratelimit-limit-requests: 10000
x-ratelimit-remaining-requests: 9997
x-request-id: req_abc123
openai-model: gpt-5-mini-2025-08-01

The openai-model header confirms the deployed variant (including date suffix). Some gateways — including n4n.ai — also forward provider cache-control hints so you can implement conditional requests against model versions without polling.

Migration checklist from GPT-4o family

If you’re moving from GPT-4o / GPT-4o-mini:

1. Update model strings — direct replacement, same API surface
2. Re-evaluate temperature defaults — GPT-5 family responds differently to temperature; 0.3 often works better than 0.7 for deterministic tasks
3. Test tool-calling schemas — function calling behavior improved; you may simplify prompt instructions
4. Adjust context window expectations — GPT-5 supports 256k context; mini and nano inherit this but effective recall degrades faster at smaller sizes
5. Update cost models — re-run your token accounting with new pricing tiers

When to use each tier — quick reference

The naming convention is deliberate: it tells you the relative capacity tier without requiring a spec sheet. Treat it as a routing signal — profile your workloads against all three, then codify the routing logic. Your infrastructure should make the tier decision invisible to product code.