LLM and AI model selection guide
What you’ll learn
Section titled “What you’ll learn”- How to match a task to a model category before comparing brands.
- What separates a large language model (LLM) from a small language model (SLM), and when each wins.
- How tiers and reasoning effort work as two separate dials for quality, speed and cost.
- A repeatable selection method: constraints first, then a graded evaluation on your own data.
- How to size the monthly cost of a workload across providers before the architecture is fixed.
- The mistakes that inflate cost or break production.
Summary
Section titled “Summary”Choosing an AI model starts with the task, not the brand. First identify the category (language, vision, speech, embedding, image generation, moderation). Then pick a tier inside a provider’s lineup (fast, balanced or frontier), then tune reasoning effort. Confirm the choice with an evaluation on your own inputs, and keep the model ID in configuration because lineups change every few months.
The rule that survives every release: pick the smallest model that reliably succeeds on your task.
Model names and prices on this page were checked in November 2026 against each provider’s documentation. The method is stable; names are not, so use the official references before a production decision. Vendor-specific detail lives on the Anthropic, Google, Amazon and OpenAI pages.
Choose the category first
Section titled “Choose the category first”“AI model” is broader than “LLM”. Match the task to a category before comparing model names.
| Task | Category | Input to output |
|---|---|---|
| Write, summarize, explain, plan | Language model | Text to text |
| Write, review or edit code | Coding-capable LLM | Code and instructions to code |
| Classify or extract at volume | SLM or fast tier | Text to label or fields |
| Read a screenshot, chart or PDF | Vision-capable LLM | Image to text |
| Generate an image | Image model | Text to image |
| Transcribe audio | Speech-to-text | Audio to text |
| Narrate or hold a voice conversation | Text-to-speech or speech-to-speech | Text to audio, or audio both ways |
| Semantic search or RAG | Embedding model plus LLM | Content to vector |
| Reorder search results | Reranker | Passages to ranked list |
| Filter harmful content | Moderation model | Text or image to risk label |
Two notes on older terminology. “Reasoning model” used to mean a separate product line; today most frontier models reason before answering, and you control how much with an effort or thinking setting. “Vision model” is now usually a capability of the main LLM, not a separate model. Reading images and creating images remain different capabilities, and a provider’s main LLM usually has the first without the second.
LLMs and SLMs
Section titled “LLMs and SLMs”An LLM is the right choice when the task needs judgment: chat assistants, coding and review, long-document analysis, extraction from messy input, and agents with tools. An SLM is a smaller, faster model for narrow, repetitive work: classifying tickets, routing messages, extracting simple fields, running on a laptop or edge device, and very high volumes at low cost. It reasons less deeply, which on a well-defined task is not a drawback.
| Dimension | LLM | SLM |
|---|---|---|
| Cost and speed per call | Higher, slower | Lower, faster |
| Reasoning depth | Handles complexity and ambiguity | Limited on complex tasks |
| Context window | Often several hundred thousand to about 1M tokens | Often smaller |
| Local deployment | Usually needs cloud or large GPUs | Practical on modest hardware |
| Best fit | Judgment, coding, analysis, agents | Classification, extraction, routing |
The line has blurred: the fast tier of each hosted provider now fills the SLM role for many teams, with no hardware to run. Truly small open-weight models (Llama, Mistral, Qwen, Gemma, Phi and others) still matter when data must stay local. Check the license, not just the weights: “open weights” ranges from Apache 2.0 to custom licenses with user caps and field-of-use restrictions, and it can change between versions of one family. See Microsoft small language models and Running LLMs locally.
Categories that need a real decision
Section titled “Categories that need a real decision”Most categories are chosen once the task is clear. Four involve a design choice that changes cost, latency or quality.
Reasoning effort: selection inside a model
Section titled “Reasoning effort: selection inside a model”Frontier models expose a setting that changes how much the model thinks before answering. Anthropic calls it effort, Google calls it thinking level, and other providers have equivalents. It is a selection decision in its own right, and often a better lever than switching tiers.
| Effort | Use for | Cost |
|---|---|---|
| Low | Classification, extraction, short scoped edits, latency-sensitive chat | Lowest |
| Medium | Routine production work where quality is already sufficient | Moderate |
| High | Most intelligence-sensitive work | Higher |
| Very high or max | Hard debugging, migrations, risky reviews, long autonomous runs | Highest |
- Sweep effort before switching models. A cheaper tier at higher effort can match a stronger tier at low effort for less money.
- Raise output limits with effort. Thinking and the visible answer share one output budget, so a high-effort request with a small limit is cut off mid-answer.
- Defaults differ by model. Two models from one provider can have different default levels, so a request that omits the setting behaves differently after a model switch.
- Re-tune on every model upgrade. Settings rarely transfer between generations.
A hypothetical illustration of why the sweep matters: if a test-generation pipeline scores the same on your rubric at medium effort as at maximum, medium is the right setting, and the difference is paid in output tokens on every request. Only your own measurement tells you whether that holds.
Voice: pipeline or speech-to-speech
Section titled “Voice: pipeline or speech-to-speech”| Design | How it works | Trade-off |
|---|---|---|
| Three-part pipeline | Speech-to-text, then an LLM, then text-to-speech | Any LLM can be used and each stage can be inspected and logged as text; latency adds up and tone of voice is lost |
| Speech-to-speech model | One model listens and speaks | Lower latency and natural turn-taking; fewer model choices, and harder to audit and to apply text-based guardrails |
Choose the pipeline when you need a specific LLM, transcripts for compliance or text moderation between stages. Choose speech-to-speech when conversational latency is the product.
Embeddings and rerankers
Section titled “Embeddings and rerankers”An embedding model converts content to vectors; it does not write answers. Retrieval works in four steps: embed each document chunk, embed the question, find the closest vectors, and send the top results to the LLM. A reranker then reorders the candidates by relevance. Add one when vector search returns noisy matches, when answers miss the best passage, or when the collection is large.
Choosing an embedding model is a long-term commitment. Vectors from different models cannot be compared, so changing models means re-embedding the whole corpus, and a retired embedding model forces exactly that.
Moderation and safety
Section titled “Moderation and safety”Moderation models classify risk in text, images or prompts: user-generated content, abuse, prompt-injection screening, policy checks. They return a category and a score, and your application decides the action. Run them on input and on output that users see, and decide in advance what happens on a false positive.
Choosing a tier
Section titled “Choosing a tier”Every major provider sells a ladder: a fast tier, a balanced tier and a frontier tier, sometimes with a top tier above that. The names differ but the logic is the same.
| Tier | Use it for | Examples (November 2026) |
|---|---|---|
| Fast | Simple, repeated, high-volume tasks | Claude Haiku 5.5, Gemini 3.5 Flash-Lite, Amazon Nova 2 Lite |
| Balanced | Normal everyday production work | Claude Sonnet 5.5, Gemini 4 Hydrogen, Gemini 3.8 Flash |
| Frontier | Difficult, risky or ambiguous work | Claude Opus 5.5, Gemini 4 Argon |
| Top | The hardest problems, where cost is secondary | Claude Fable 5.2, Gemini 4 Carbon |
For coding work the same ladder applies: fast for classifying files and mechanical edits, balanced for small fixes, explanations and tests for clear code, and frontier for cross-file refactors, production incidents, risky reviews and framework migrations, where a mistake is expensive.
A selection method
Section titled “A selection method”
- Write down the constraints. Data location and compliance, latency budget, monthly cost ceiling, required modalities, and which cloud contracts already exist. These remove options before any quality comparison.
- Pick the category and a starting tier. Start small for narrow tasks, start capable for complex ones.
- Build a graded test set. Thirty to a few hundred real inputs with expected results or a scoring rubric, including the awkward cases. This is the most valuable asset in the whole process.
- Run two neighboring tiers at two effort levels. Record quality, latency and cost per request for each.
- Choose the cheapest configuration that passes, and note the runner-up as a fallback.
- Put the model ID and effort in configuration, mapped from a tier name, and re-run the test set on every model or prompt change.
Worked example: sizing the same workload across providers
Section titled “Worked example: sizing the same workload across providers”An invented shop, OrdersPortal, classifies one million support tickets a month, with about 2,000 input tokens and 100 output tokens per request: 2,000 million input tokens and 100 million output tokens a month. At list prices checked in November 2026 (per million input and output tokens):
| Model | List price | Input cost | Output cost | Monthly total |
|---|---|---|---|---|
| Claude Haiku 5.5 | $0.10 / $0.50 | $200 | $50 | $250 |
| Gemini 4 Hydrogen | $1.50 / $7.50 | $3,000 | $750 | $3,750 |
| Gemini 4 Argon, introductory | $2 / $10 | $4,000 | $1,000 | $5,000 |
| Gemini 4 Argon, from December 1, 2026 | $4 / $20 | $8,000 | $2,000 | $10,000 |
| Claude Opus 5.5 | $4 / $20 | $8,000 | $2,000 | $10,000 |
Three lessons come out of the arithmetic. The fast tier costs a fortieth of the frontier tier for the same tickets, so route upward only the cases the fast tier gets wrong. An introductory price is a date in your budget: the Argon row doubles on a fixed day. And list price is only the start: thinking tokens are billed as output, while caching and batch discounts cut the bill, which the Anthropic models page works through for one provider. These are illustrative list-price calculations, not measured results.
Other model families
Section titled “Other model families”Vendor pages cover Anthropic, Google and Amazon in depth. These notes cover the rest; all were checked in November 2026 and are for orientation only.
OpenAI
OpenAI’s documentation names its current GPT-6 family by tier: GPT-6 Astra (flagship), GPT-6.1 Sol, GPT-6.1 Terra and GPT-6 Luna (lightweight), alongside its Codex coding line. When checked in November 2026, OpenAI’s own pages differed on which of these were callable through the API and which were limited to its apps or to an access program, so confirm on the OpenAI models page before designing around one. See OpenAI models.
DeepSeek and Microsoft MAI
- DeepSeek documents two API models in November 2026:
deepseek-v4-pro(reasoning-focused) anddeepseek-flash(the efficient general model, currently DeepSeek-V4.1-Flash). Evaluate quality and data-governance fit before production use. - Microsoft MAI is Microsoft’s own model family, offered through different services: MAI-Thinking (reasoning, in preview) and MAI-Image in Microsoft Foundry, MAI-Transcribe and MAI-Voice through Azure Speech, and MAI-Code in GitHub Copilot. Version numbers move quickly; see Microsoft LLMs.
Image, speech, voice and embedding models
Families named in provider documentation in November 2026. Exact IDs and deprecation states change monthly, so take them from the linked provider pages when you build.
| Need | Families | Source |
|---|---|---|
| Image generation | OpenAI GPT Image models; Google’s image family (Nano Banana); MAI-Image | OpenAI, Gemini API and Microsoft Foundry model pages |
| Speech to text | OpenAI transcription models (Whisper also ships as open weights); MAI-Transcribe | OpenAI model pages; Azure Speech documentation |
| Speech-to-speech | OpenAI realtime models, Gemini Live, Amazon Nova Sonic (2 and 2.5) | Provider model pages |
| Text embeddings | OpenAI text-embedding-3-large and text-embedding-3-small; Gemini Embedding |
OpenAI and Gemini API model pages |
| Mixed-media embeddings | Amazon Nova Multimodal Embeddings | Bedrock model cards |
Common mistakes
Section titled “Common mistakes”- Using the strongest model for everything. The most common AI cost problem. In the worked example, the frontier tier costs forty times the fast tier for the same tickets. Use the fast tier where it passes and escalate only the hard cases.
- Using an LLM when you need search or data. “What was our third-quarter revenue?” needs a query against the data warehouse. A document corpus needs retrieval, not pasting into the prompt.
- Comparing only by public benchmark. Benchmarks indicate direction. Your prompts, documents, latency needs and budget decide.
- Hard-coding model versions across the codebase. Map each workload to a tier in configuration and resolve tier to model ID in one place.
- Treating an upgrade as a string swap. Re-run evaluations, recheck token counts and cost, and re-tune effort. Prompts written for an older model are often too prescriptive for a newer one.
- Budgeting on an introductory price. Record the date the price changes and the price after it.
- Ignoring non-functional constraints until late. Data residency, retention terms, rate limits and Region availability can rule out a model that won the quality comparison.
- Trusting the HTTP status. A response can stop at the output limit or be declined while still returning success. Check the stop reason.
- No plan for retirement or silent change. Providers retire models on published schedules, and an alias can start pointing at a new model. Pin exact versions, log the model reported in each response, and keep a qualified fallback for critical paths.
- Letting the test set decay. A test set built at launch stops representing real traffic. Refresh it from production samples.
When not to use an LLM at all
Section titled “When not to use an LLM at all”- A rule, lookup or classical model solves it. Validation, routing by a known field, fixed calculations and tabular prediction belong in code or conventional ML, which is cheaper and more testable. See AI and machine learning basics.
- A wrong answer is costly and nobody reviews it, or the budget is a few milliseconds. A probabilistic generator behind a network call is the wrong component for either.
Example architectures
Section titled “Example architectures”RAG chatbot
| Step | Component |
|---|---|
| 1. Preprocess documents | Chunking, cleaning, deduplication |
| 2. Create vectors | Embedding model |
| 3. Retrieve passages | Vector database |
| 4. Improve ranking | Reranker |
| 5. Generate the answer | Balanced LLM, citing the passages used |
| 6. Check for safety risk | Moderation model |
Coding agent
| Step | Component |
|---|---|
| 1. Read the repository | Coding-capable LLM with file tools |
| 2. Plan the changes | Frontier model at higher effort |
| 3. Edit files | Agent tools |
| 4. Run tests | Shell or CI tools |
| 5. Review the diff | A second model pass, then a person |
Interview questions
Section titled “Interview questions”1. How do you decide which model to use for a new feature? Start from the task and constraints, not the brand. Identify the category, list hard constraints (data location, latency, budget, modality), pick a starting tier, then run a graded test set of real inputs on two neighboring tiers and two effort levels. Choose the cheapest configuration that passes and keep the model ID in configuration.
2. What is the difference between changing the model tier and changing reasoning effort? The tier sets the capability ceiling and the price per token. Effort sets how much of that capability is spent on a given request, mainly by changing how much the model thinks. Effort is cheaper to change, needs no prompt migration, and should be swept before moving up a tier.
3. Senior scenario: design model routing for a support platform that handles simple questions, policy lookups and complex disputes, under a fixed monthly budget. Three paths. A fast-tier model classifies intent and answers simple questions from templates. A balanced model answers policy questions with retrieval, citing the passages used. Disputes go to a frontier model with the full case history and a human approval step. The router uses the classifier’s label and confidence, with low confidence escalating upward. Each path has its own graded test set, cost and latency logging, a budget alarm and a qualified fallback model, with IDs and effort in configuration by tier.
4. Senior scenario: a provider has deprecated the model behind three production features, with retirement in eight weeks. Walk through the migration. Inventory first: find every caller from usage exports and configuration, including batch jobs and other platforms such as Bedrock or Google Cloud, whose retirement dates differ. Read the provider’s migration guide for breaking changes: removed parameters, new thinking or tool-choice rules, tokenizer changes that alter token counts and cost, and different default effort. Run each feature’s evaluation set on the replacement with an effort sweep, fix prompt regressions, and re-estimate cost from measured tokens. Ship behind a flag to a small share of traffic, compare quality, latency, refusals and cost, then ramp. Keep the old model as fallback until two weeks before retirement, then remove it so the cut-over is not the retirement day itself. Afterward, add a scheduled lifecycle check so the next notice arrives as a ticket, not an outage.
5. Senior scenario: leadership asks to “standardize on one model for everything.” How do you respond? The goal, less operational complexity, is reasonable; the means is costly. One top-tier model for all work multiplies spend on simple tasks and adds latency, and one provider is a single point of failure. Standardize the interface instead: one internal gateway, a small approved set of tiers, shared evaluation tooling, and central logging and budgets.
Key takeaways
Section titled “Key takeaways”- Choose the category first, then the tier, then the effort level.
- Pick the smallest model that reliably succeeds, proven on your own graded test set.
- Sweep effort before upgrading tiers, and size output limits for thinking.
- Size cost per workload across providers, and record the date of any introductory price.
- Keep model IDs in configuration by tier; expect retirements and re-evaluate on every change.
- Some problems are better solved with rules or classical ML than with an LLM.
Related pages
Section titled “Related pages”- Anthropic models, Google models, Amazon models and OpenAI models
- Microsoft LLMs and Microsoft small language models
- AI models in 2026
- Running LLMs locally
- RAG vs agentic RAG
- AI and machine learning basics
Official references
Section titled “Official references”Model names, prices and availability change. Verify before production decisions.