Skip to content

LLM and AI model selection guide

  • 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.

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.

“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.

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.

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.

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.

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 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.

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.

Four-step model selection flow: choose the task category, then the tier, then the effort level, then evaluate quality, latency and cost on your own data and adjust.

  1. 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.
  2. Pick the category and a starting tier. Start small for narrow tasks, start capable for complex ones.
  3. 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.
  4. Run two neighboring tiers at two effort levels. Record quality, latency and cost per request for each.
  5. Choose the cheapest configuration that passes, and note the runner-up as a fallback.
  6. 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.

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) and deepseek-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
  • 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.
  • 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.

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

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.

  • 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.

Model names, prices and availability change. Verify before production decisions.