There is no absolute best AI model: the right choice depends on your task, budget, and data sensitivity. In November 2026, the three major publishers each offer a tiered range (a flagship model, an intermediate model, an economical model), and the price gap between these tiers often exceeds a factor of ten. The most reliable method remains to preselect two or three models based on objective criteria, then test them on your own examples.
This guide serves as a map of the subject. It explains what a large language model is, which criteria to compare, how to read prices and rankings, and when to prefer a proprietary, open, or locally installed model. It concludes with a testing protocol and a decision table. All price and range data were verified on the official publisher pages in November 2026; they evolve quickly, so check them before any binding decision.
The short answer: which model families to compare in November 2026?
The generalist model market is structured around a few families. Each offers several power levels, and it is often the level, more than the brand, that determines the value for money. The table below summarizes the ranges displayed by the publishers, with their API prices for one million input and output tokens.
| Publisher | Flagship model | Intermediate model | Economical model | Context window |
|---|---|---|---|---|
| Anthropic | Claude Fable 5.2 ($8 / $40); Claude Opus 5.5 ($4 / $20) | Claude Sonnet 5.5 ($2 / $10) | Claude Haiku 5.5 (from $0.10 / $0.50) | 1 million tokens |
| OpenAI | GPT-6 Astra ($10 / $50) | GPT-6.1 Sol ($2 / $10); GPT-6.1 Terra ($1 / $5) | GPT-6 Luna ($0.10 / $0.50) | 1.05 million tokens |
| Gemini 4 Carbon and Gemini 4 Argon ($2 / $10 until November 30, 2026, then $4 / $20) | Gemini 4 Hydrogen ($1.50 / $7.50) | Gemini 3.5 Flash-Lite ($0.30 / $2.50) | 1 million tokens (Gemini 4) | |
| Mistral AI | Mistral Large 4 (open weights) | Mistral Small 4 (Apache 2.0) | Ministral 3 (3B, 8B, 14B, Apache 2.0) | Not specified on the consulted page |
Sources”: “overview of Claude models“, OpenAI model catalog, Gemini API pricing and Mistral AI catalog, accessed November 14, 2026. The “flagship,” “intermediate,” and “economical” tiers are our interpretation of the announced positioning, not a classification by the publishers.
Some official benchmarks help to start. Anthropic recommends beginning with Claude Opus 5.5 for most uses and reserving Claude Fable 5.2 for demanding reasoning and long agentic tasks. OpenAI presents GPT-6 Astra as its flagship model for complex reasoning and code, and GPT-6 Luna for high-volume targeted tasks. Google describes Gemini 4 Carbon as its most powerful model, while indicating that Gemini 4 Argon remains better suited for most development and advanced office work, Carbon consuming more tokens for exploration and verification. To align these models side by side, the interactive model comparator on the site displays prices, context, and capabilities of two to four models in the same table, with data refreshed daily.
If your question concerns only consumer assistants, our ChatGPT vs Claude vs Gemini comparison details the offers, integrations, and tests on the three applications. This guide covers all models and the selection method.
How do large language models work?
A large language model (LLM, for large language model) is a neural network trained to predict the continuation of a text. The text is split into tokens, fragments of words or characters, and the model calculates at each step the most probable token given all preceding context. This simple mechanism, applied to billions of parameters and vast corpora, produces capabilities in writing, translation, reasoning, and programming.
Concepts to know before comparing
Four concepts appear in all technical sheets. The context window is the amount of text the model can consider at once, including instructions, documents, and history; Anthropic indicates that one million tokens correspond to about 555,000 words with the tokenization used by its current models. The maximum output limits the length of a response: 128,000 tokens for the Claude and OpenAI models listed above. Reasoning (or thinking) refers to tokens the model generates to think before answering; most recent models allow adjusting its intensity by an effort level, from “low” to “max.” Finally, tool calls allow the model to trigger a web search, code execution, or a function of your application. For more, read our article “Multimodal AI: models capable of understanding text, image, audio, and video.”
A model goes through two main phases. Pre-training teaches it language and broad general knowledge from texts. Post-training then adjusts it to follow instructions, refuse certain requests, and reason step-by-step, often by reinforcement learning. This second phase explains why two models of comparable size behave very differently with the same instruction.
It is also necessary to distinguish the model from the product. ChatGPT, Claude, or the Gemini application are interfaces that add memory, web search, connectors, and usage limits around one or more models. Comparing “ChatGPT and Claude” thus compares products; comparing “GPT-6.1 Sol and Claude Sonnet 5.5” via the API compares models. When the model acts alone over multiple steps with tools, it is called an agent: our complete guide to AI agents explains what this changes for model choice.
Which criteria to compare before choosing a model?
A useful comparison starts with a list of criteria set before looking at results. Otherwise, one ends up justifying the already preferred model. Here is the grid we recommend, from most discriminating to more secondary for professional use.
- Quality on your task: accuracy, respect for requested format, relevance. This is the only criterion that truly matters, and no public ranking measures it for you.
- Reliability: rate of factual errors, stability of answers from one trial to another, ability to say “I don’t know.”
- Total cost: price per token, but also number of tokens consumed, including reasoning tokens, and number of attempts needed to get a usable result.
- Latency: time before the first word and total duration, crucial for customer service or interactive interfaces.
- Context and formats: volume of documents to process, reading images, PDFs, audio, or video.
- Tools and integrations: function calls, JSON-structured outputs, connectors to your software.
- Data and compliance: use of your content for training, retention duration, hosting location, contract.
- License and dependency: possibility to download weights, change provider, run the model on your own infrastructure.
A numerical example: the cost of the same work depending on the model
Let’s take a typical workload: one million tokens sent to the model and 200,000 tokens generated, corresponding for example to a few hundred document summaries. At public rates recorded in November 2026, the calculation shows considerable differences.
| Model | Input (1M tokens) | Output (200,000 tokens) | Total |
|---|---|---|---|
| GPT-6 Astra | $10 | $10 | $20 |
| Claude Fable 5.2 | $8 | $8 | $16 |
| Claude Opus 5.5 | $4 | $4 | $8 |
| Gemini 4 Argon (rate from December 1, 2026) | $4 | $4 | $8 |
| GPT-6.1 Sol or Claude Sonnet 5.5 | $2 | $2 | $4 |
| Gemini 4 Hydrogen | $1.50 | $1.50 | $3 |
| GPT-6 Luna | $0.10 | $0.10 | $0.20 |
This calculation has two important limits. First, each publisher tokenizes text differently: the same document does not produce the same number of tokens at Anthropic, OpenAI, or Google. Second, reasoning tokens are billed as output tokens, and a model set to high effort can generate many more than the visible response. The price per token is thus only a starting point; only a test on your data gives the real cost per successful task. For an agent project, the AI agent cost calculator helps integrate the number of steps and calls.
Which LLMs to prioritize for writing, coding, and reasoning?
Publishers all claim excellence on the same grounds, making their announcements little discriminating. It is more useful to distinguish three levels of evidence: what the publisher claims, what independent evaluations measure, and what you observe on your own cases. The following table separates the first two levels for main uses.
| Use | Positioning announced by publishers | What independent measures say | Caution point |
|---|---|---|---|
| Code and development agents | Anthropic positions Claude Opus 5.5 on long-duration agentic code; OpenAI presents GPT-6 Astra as its flagship model for code; Google targets Gemini 4 Carbon on complex multi-step code. | Scores published by publishers cross: on some tests Anthropic leads OpenAI, on others the reverse, according to Anthropic’s own tables. | The tool (IDE, command-line agent) weighs as much as the model. |
| Writing and synthesis | OpenAI highlights natural writing for GPT-6.1 Terra; other publishers speak of broad knowledge work. | On Vectara’s hallucination ranking (document summaries), the most powerful models are not the most faithful. | Fidelity to source text must be tested; it cannot be deduced from model size. |
| Reasoning and analysis | Anthropic directs Claude Fable 5.2 toward demanding reasoning; Google presents Carbon as suited for open scientific research. | On Humanity’s Last Exam with tools, Anthropic publishes 67.7% for Claude Opus 5.5 versus 57.2% for GPT-6 Astra: a publisher figure, measured under its own conditions. | High reasoning effort multiplies cost and latency. |
| High-volume tasks (sorting, extraction, routing) | Anthropic targets Claude Haiku 5.5 for classification and extraction; OpenAI targets GPT-6 Luna for high-volume targeted tasks. | The most cited benchmarks focus on difficult tasks and provide little information on these uses. | A small well-scoped model often suffices; test it before paying for a large model. |
Writing and document synthesis
For writing, two qualities are measured separately: fidelity to sources and style quality. The Vectara hallucination ranking, updated October 22, 2026, has each model summarize over 7,700 articles and measures the share of summaries containing information absent from the original text. It records 6.5% for GPT-6 Sol, 8.7% for GPT-6 Astra, 9.9% for Claude Opus 5.5, and 12.1% for Gemini 4 Argon, while several small models do better. This test only covers short summaries evaluated by a judge model developed by Vectara; it says nothing about style. Our dossier on the best AI models for writing and summarizing documents offers a complete grid, and the hallucination issue of LLMs is the subject of a dedicated article. For more, see “The Best AI Models for Writing and Summarizing Documents.”
Programming
For coding, the essential distinction opposes assistance in the editor (completion, explanation, small corrections) and agentic tasks on an entire repository, where the model reads code, runs commands, and proposes a complete modification. Flagship models make the difference mainly on the second type of task. Our article on the best LLM for coding describes a reproducible comparison protocol.
Reasoning
So-called reasoning models dedicate tokens to thinking before answering. They excel on multi-step problems (math, planning, legal or financial analysis), but often add nothing on simple reformulation or translation. The functioning and limits of an AI reasoning model are detailed in a satellite of this guide, as are multimodal AI models capable of reading images, audio, and video. For a profession-based approach, also see our guide to the best AI model by use and profession.
How to interpret prices, context, and benchmarks?
Three figures dominate technical sheets: price per million tokens, context window size, and benchmark scores. Each is accurate, but each easily misleads if read in isolation.
Price: look beyond the base rate
Pricing grids include mechanisms that strongly affect the bill. At Anthropic, batch requests cost 50% less, and rereading cached context costs a fraction of the normal price (usually 10% of input price, 5% on Claude Opus 5.5 and Claude Sonnet 5.5, 2.5% on Claude Fable 5.2). At Google, Gemini 4 Carbon and Gemini 4 Argon benefit from a launch rate doubling on December 1, 2026, and documentation specifies that reasoning tokens are billed. A comparison of LLM API prices, a satellite of this guide, details these calculations.
Context”: “a capacity”, not a guarantee
A one-million-token window allows sending a full annual report or a medium-sized code repository. It does not guarantee that the model will exploit each passage with the same attention, nor that sending it is economical: each request bills all transmitted context. To regularly query a document base, a retrieval-augmented generation (RAG) architecture that sends only relevant passages is often more reliable and cheaper; the choice of document chunking is explained in our article on chunking strategy.
Benchmarks: rarely identical conditions
A benchmark score only makes sense with its measurement conditions. In the Claude Opus 5.5 announcement, Anthropic notes that its results are obtained at maximum effort, except exceptions, and that on Terminal-Bench 4.0 its model is measured at “xhigh” effort while GPT-6 Astra is at “high” effort, a figure taken from OpenAI; the announced standard error reaches ±2.6 points. Independent indexes harmonize more: Artificial Analysis aggregates nine evaluations in four equally weighted categories (knowledge work, code, sciences, general culture), with the same instructions for all models. Public vote rankings have their own biases: a 2025 study, The Leaderboard Illusion, showed that some publishers privately tested many variants on Chatbot Arena before publishing the best.
Most frequent reading errors
- Comparing two scores obtained with different effort levels, tools, or test harnesses.
- Taking a one- or two-point gap as a real difference, while it remains within the margin of error.
- Judging cost on price per token without counting reasoning tokens or failed attempts.
- Assuming a flagship model is better on everything: on summary fidelity, this is not the case according to Vectara.
- Forgetting the date: a ranking over three months old often describes a market that has already changed.
Our article on LLM benchmarks details test set contamination, score variance, and prompt sensitivity. To build your own evaluations, the guide to evaluating a language model explains how to score answers, calibrate a judge model, and track regressions.
Should you choose a proprietary, open, or local model?
Three access modes coexist. A proprietary model (Claude, GPT-6, Gemini 4) is only used via the publisher’s API or application, or via partner clouds. An open weights model (open weights) can be downloaded and run on your own servers, according to its license conditions. A local model is an open weights model running on your machine or infrastructure, without data leaving.
“Open” covers very different licenses. Mistral AI’s catalog publishes Mistral Small 4 and the Ministral 3 range under Apache 2.0 license, very permissive, but Mistral Large 4 under its own license, the Mistral Ecosystem Open Weight License, which governs redistribution and commercial use. The same catalog also references third-party models under MIT license, like GLM 5.3 from Z.ai and DeepSeek V4.1 Flash. According to Mistral, Large 4 has 1 trillion parameters, with 52 billion active per token: such a model deploys on servers equipped with multiple GPUs, not on a laptop. The comparison between open source, open weights, and proprietary LLMs, a satellite of this guide, specifies these legal distinctions.
Arguments for each option
| Option | Strengths | Limits | Typical cases |
|---|---|---|---|
| Proprietary API | Best flagship performance, no hardware to manage, continuous updates | Provider dependency, data sent to a third party, variable prices | Prototyping, complex tasks, low volumes |
| Open weights hosted (cloud or third-party provider) | Choice of host, possibility to change provider, often lower costs | Possible performance gap with flagship, license to verify | High volumes, sovereignty requirements |
| Local (on-premises) | Data confined, low marginal cost once hardware acquired, offline operation | Hardware investment, maintenance, smaller models on a workstation | Sensitive data, strong regulatory constraints |
Confidentiality also depends on the contract, not only access mode. At Google, the Gemini API pricing page indicates that content sent on the free offer is used to improve products, unlike the paid offer. Conversely, open weights do not guarantee European hosting: it depends on where you run them. To estimate which model your hardware can run, the local AI model calculator starts from your RAM and graphics card; our local AI and RAG guide then describes how to connect this model to your own documents.
Verify that the choice holds up
Before deciding, ask three concrete questions. What exact data will you send to the model, and does your contract allow their use for training? What monthly volume do you expect, and from what threshold does dedicated hosting become cost-effective? What happens if the chosen model is withdrawn or changes price? Anthropic publishes for each model a minimum withdrawal date (not before September 2027 for Claude Opus 5.5): this type of commitment deserves verification with each provider.
Testing method and decision table
A well-constructed in-house test is better than any ranking because it measures your task, with your instructions and quality criteria. It requires neither a research team nor a large budget: a few dozen examples suffice to differentiate two or three models.
The seven-step protocol
- Define the task in one sentence and list what constitutes a good answer (accuracy, format, tone, length).
- Gather 30 to 50 real examples, anonymized if necessary, including difficult cases and cases where the correct answer is “I don’t know.”
- Preselect two or three models using the criteria grid and a tool like our questionnaire to choose an AI model according to your task, which offers three recommendations based on your use, budget, and confidentiality constraints.
- Use the same instruction for all models, then an adapted version for each if you have time: formulation differences can invert a ranking.
- Repeat each trial at least two or three times to measure answer stability.
- Score blindly, without knowing which model produced which answer, with a preset grid.
- Record the actual cost and time of each trial, then calculate the cost per acceptable answer.
This protocol has limits: a small sample does not detect rare errors, and a model can degrade or improve after an update. Keep your example set and rerun it at each version change. For projects where the model acts with tools, our article on evaluating AI agents in business complements the method with trajectory and task success indicators.
Decision table
| Your situation | Suggested starting point | Priority checks |
|---|---|---|
| Personal use or small team, without integration | A consumer assistant (ChatGPT, Claude, or Gemini) in its entry-level paid version | Usage limits, training adjustment on your data |
| Complex and few tasks (analysis, code on repo, reasoning) | A flagship model: Claude Opus 5.5, GPT-6 Astra, Gemini 4 Argon or Carbon | Cost per task at high effort, latency |
| Medium volume production (writing, support, synthesis) | An intermediate model: Claude Sonnet 5.5, GPT-6.1 Sol or Terra, Gemini 4 Hydrogen | Answer fidelity, structured outputs |
| High volume of simple tasks (sorting, extraction, routing) | An economical model: Claude Haiku 5.5, GPT-6 Luna, Gemini 3.5 Flash-Lite | Error rate on your edge cases |
| Sensitive data or sovereignty requirement | An open weights model hosted by you or a trusted provider | License, hardware, maintenance |
| Agent chaining actions | A flagship or intermediate model with reliable tool calls | Cumulative cost of steps, safeguards |
This table provides a starting point, not a conclusion: your test decides. Two practices then improve results regardless of the chosen model, each the subject of a satellite of this guide: prompt engineering methods that truly improve answers, and techniques to reduce hallucinations. Finally, if you still hesitate to pay a subscription, our comparison between free and paid AI details what each offer level really changes.
