Which LLM Should You Use? GPT, Claude, Gemini, Grok, Qwen, DeepSeek

A client asked me last month which model their new assistant should call: GPT, Claude, Gemini, or "one of the open ones". The honest answer is a table, not a name. Every family on the market is optimised for a different workload, and the cheapest way to build a good system is to understand which model to use for which job, how to combine them, and when self-hosting beats an API.

This post is the comparison I wish I had on that call. It covers the nine families that matter in November 2026: OpenAI GPT, Anthropic Claude, Google Gemini, xAI Grok, Meta (Llama and now Muse), Mistral, Alibaba Qwen, DeepSeek, and Microsoft Decision-1, a new kind of model that deserves its own post. It continues the series that started with Snowflake vs Databricks and Azure, Fabric, Databricks or Foundry, and it ends with the routing code I actually use.

The short answer

Pick by job, not by brand. For general agents and tool calling, start with GPT or Claude. For software engineering agents, Claude first. For images, video and very large document sets, Gemini. For real-time social and market signals, Grok. For anything that must stay on your own hardware, Qwen, DeepSeek, Llama or Mistral on vLLM. For classification, routing and grading at volume, Microsoft Decision-1. Then benchmark two candidates on your own data, because every claim below is a vendor's claim until your evaluation set says otherwise.

Everything here was checked on 6 November 2026 against the vendors' model pages and the AI Board research report of 26 October 2026, which lists a vendor source per line. Prices are public list prices per million tokens, input then output, excluding volume discounts and batch rates.

Why is there no single best LLM?

Because the families are optimised for different things. Some lead at complex reasoning and mathematics; some at reading and editing large codebases; some at video, audio and million-token documents; some at being cheap and fast for high-volume production work; and some publish their weights so you can run them on a GPU you control. A model that tops one of those lists is rarely first on the others, and the price spread between the top and the mid tier is five to ten times.

There are three kinds of provider, and the distinction matters more than any benchmark:

Open-weight does not mean open-source. Qwen and DeepSeek publish weights, but the licence, the training data and the commercial-use conditions differ per release, and some families publish only their smaller models.

Which flagship models are current in November 2026?

One flagship per lab, as the labs describe them. The EU column says whether the vendor documents a route to processing inside the European Union, which decides the question for many of my clients before quality does.

Three things to read off that table. The million-token window is now the norm at the top: six of the eight language-model flagships publish one million tokens or more. The price gap between the two most expensive flagships and DeepSeek is about eight times. And the newest OpenAI flagship reached a documented EU route only in late October, with conditions, while its previous generation had been in nine European Azure regions for months: the residency rule narrows your model choice, so check the specific model, not the vendor.

Which cheaper tiers sit under each flagship?

Most production traffic should not run on a flagship. These are the tiers I evaluate first, with their published prices.

What is each model family best at?

This is positioning from my own projects and reading, not a measured ranking. Treat every row as the first candidate to evaluate, not the winner.

Other families worth knowing: Moonshot Kimi K3 (reasoning and agents, 1,048,576-token window), Zhipu GLM-5.3 (reasoning and coding, MIT weights on GLM-5.2), Cohere Command A+ (Apache-2.0 weights, strong embeddings and rerankers for enterprise RAG), NVIDIA Nemotron 3 Ultra (open weights for enterprise inference) and Amazon Nova (the AWS native line, the only models in the AWS European Sovereign Cloud at the September 2026 check).

Proprietary API or self-hosted open weights?

This is the biggest architectural decision, bigger than the choice of model. Figure 1 shows both routes and the multi-model stack that combines them; tap a layer to read what it does.

Proprietary APISelf-hosted open weightsMulti-model routing

Your code calls OpenAI, Anthropic, Google or xAI directly, or the same models through Microsoft Foundry, Amazon Bedrock or Gemini Enterprise Agent Platform. The provider runs the GPUs.

1. Your applicationNext.jsFastAPI
2. OrchestrationLangGraphMCP tools
3. ModelsGPT-6 AstraClaude Fable 5.1Gemini 4 ArgonGrok 4.7
4. Enterprise platform (optional)Microsoft FoundryAmazon BedrockGemini Enterprise Agent Platform
5. RetrievalPostgreSQL + pgvectorAzure AI Search
6. InfrastructureProvider GPUsYour containers
7. EvaluationMLflowGolden test set
8. Security and dataAPI keys in a vaultData processing agreement

Typical use: Most products: fastest to ship, strongest models, no hardware to run; you pay per token and your data leaves your network under a contract.

Tap a layer to read what that technology does in this stack.

Proprietary API. Your code calls OpenAI, Anthropic, Google or xAI directly, or the same models through Microsoft Foundry, Amazon Bedrock or Gemini Enterprise Agent Platform. The provider runs the GPUs. Typical use: Most products: fastest to ship, strongest models, no hardware to run; you pay per token and your data leaves your network under a contract.

Layer	Technology	What it does
Your application	Next.js, FastAPI	The product the user sees and the API that serves it.
Orchestration	LangGraph, MCP tools	Agent loops, tool calling and state live in your code, whichever model answers.
Models	GPT-6 Astra, Claude Fable 5.1, Gemini 4 Argon, Grok 4.7	The current flagships of OpenAI, Anthropic, Google and xAI as of 6 November 2026, each behind its own API; cheaper tiers sit under each one.
Enterprise platform (optional)	Microsoft Foundry, Amazon Bedrock, Gemini Enterprise Agent Platform	One contract, one bill and one identity system for several vendors’ models, plus evaluation and governance.
Retrieval	PostgreSQL + pgvector, Azure AI Search	The documents the model is allowed to read, chunked, embedded and indexed on your side.
Infrastructure	Provider GPUs, Your containers	No GPUs of your own: you run the application containers, the vendor runs inference.
Evaluation	MLflow, Golden test set	The same questions and documents run against every candidate model before and after each vendor release.
Security and data	API keys in a vault, Data processing agreement	Zero data retention or regional processing is a contract setting, not a default: ask for it in writing.

Self-hosted open weights. You download published weights and serve them on GPUs you control, with vLLM, SGLang or Ollama. No per-token bill, full control of the data path, and all the operations. Typical use: Private or regulated data, fine-tuned models, predictable high volume, or a residency rule that no vendor endpoint meets.

Layer	Technology	What it does
Your application	Next.js, FastAPI	Unchanged: the application talks to an OpenAI-compatible endpoint that happens to be yours.
Orchestration	LangGraph, MCP tools	Same agent code as the API route; only the base URL changes.
Inference server	vLLM, SGLang, Ollama	Batching, KV cache, quantisation and an OpenAI-compatible API; Ollama for a laptop or a single box, vLLM or SGLang for production throughput.
Open-weight models	Qwen3.8-27B, DeepSeek-V4-Flash, Llama 4, Mistral Medium 3.5, gpt-oss	Weights you can download: Apache-2.0 (Qwen3.8-27B), MIT (DeepSeek V4), the Llama 4 community licence, Mistral’s modified MIT. Read the licence before the model card.
GPUs	NVIDIA GPUs, AWS / Azure / GCP GPU instances, On-premises	Rented GPU instances in a region you choose, or your own servers; capacity planning becomes your job.
Retrieval	PostgreSQL + pgvector, Open embedding model (bge-m3)	Embeddings also run locally, so no document ever leaves the network.
Evaluation	MLflow, Golden test set	Fine-tunes (LoRA, QLoRA) are only worth it if this test set says so.
Operations	Kubernetes, Monitoring, Patching and upgrades	Scaling, monitoring, security patches and model upgrades: the hidden cost of the no-token-bill route.

Multi-model routing. One application, several models: a cheap decision model classifies and routes, a reasoning model handles the hard steps, a multimodal model reads images, open weights serve the private parts. Typical use: An enterprise assistant that reads documents, answers customers, runs workflows and has to stay cheap at volume.

Layer	Technology	What it does
Request	Customer, employee or API	Every request enters through the same door, whatever it needs.
Decision and routing	Microsoft Decision-1	Intent, priority and the route, as calibrated probabilities over fixed options, in one cheap single-pass call; a low top probability sends the case to a person.
Reasoning and code	Claude Opus 5.5, GPT-6 Sol	Multi-step analysis, planning and code generation, where the expensive tokens earn their keep.
Images, video and documents	Gemini 4 Argon, Azure AI Document Intelligence	Scanned invoices, screenshots and video go to a multimodal model or a document service, not to the text router.
Private inference	Qwen3.8-27B on vLLM, DeepSeek-V4-Flash	Sensitive fields and bulk extraction stay on your GPUs.
Real-time signals	Grok 4.7	Social and market chatter when the use case needs what is happening now.
Retrieval and tools	Vector store, SQL, CRM / ERP APIs	Facts come from your systems; the models only read and act on them.
Verification	Microsoft Decision-1, LLM judge	Approve, reject or escalate each generated answer or action against a rubric before anything is executed.
Execution	Workflow (n8n, queue), Human approval	Update the CRM, send the notification, create the report; writes that matter wait for a person.

What can you run on a 16 GB GPU?

A rule of thumb for a laptop with 16 GB of GPU memory, before production sizing. Memory depends on quantisation, context length, KV cache and architecture, so treat these as orders of magnitude.

For production you would not use a laptop anyway: vLLM or SGLang on dedicated GPU instances, with batching and the KV cache tuned for your context lengths.

Dense, mixture of experts, reasoning or decision model?

Not every model works the same way, and the architecture decides memory, latency and what the model is good for. Figure 2 puts the four kinds side by side.

The categories overlap: DeepSeek-V4-Pro is a mixture of experts and a reasoning model, and Decision-1 is post-trained from a dense 9B Qwen model.

Which model should you evaluate first for each project?

Starting candidates, not guaranteed winners. The right-hand column is the reason the candidate is on the list.

How do you route between models in production?

Do not hard-code one model into every feature. A routing layer selects the model per task, and the task type is only the first signal. Mine looks like this in its simplest form:

class ModelRouter:
    """Picks the model per task; the strings are deployment names in Foundry or vLLM."""

    def select_model(self, task: str) -> str:
        if task == "classification":
            return "microsoft-decision-1"
        if task == "complex_reasoning":
            return "gpt-6-sol"
        if task == "coding":
            return "claude-sonnet-5-5"
        if task == "multimodal":
            return "gemini-4-argon"
        if task == "private_inference":
            return "qwen3.8-27b"
        if task == "social_intelligence":
            return "grok-4.7"
        if task == "cost_efficient_reasoning":
            return "deepseek-v4-flash"
        return "gpt-6.1-terra"

In production the router weighs more than the task type:

1. Expected quality on that task, from your own evaluation set, not a leaderboard.
2. Price per million tokens, input and output, including cached-input rates where the vendor publishes one.
3. Token counts of the request: a 300K-token prompt rules out Grok's standard rate and Decision-1's 32K input limit.
4. Latency requirements: a decision model answers in milliseconds, a flagship reasoning model in seconds.
5. Context window and whether the usable window is as long as the advertised one.
6. Data sensitivity: private fields go to the self-hosted route; the rest may use an API under the agreed terms.
7. Availability of each provider, with a fallback model and a retry policy.
8. Retirement dates of each model name, so a shutdown becomes a one-line change.

Example: a multi-model invoice pipeline

An accounting application that receives 10,000 invoices a month does not need a flagship for every step. The benefit of a multi-model design is that expensive tokens go only where they earn their keep, and arithmetic goes to Python.

What changed in September and October 2026?

New models arrive every week, and every so often an old one is switched off. These are the releases of the eight language-model labs plus Microsoft between 10 September and 26 October 2026, as listed by the AI Board report of 26 October with a vendor source per line.

Which models are retiring, and when?

A model is deprecated when the vendor announces an end date and still answers; it is retired on the day every call fails. The notice period is the only window in which a migration is cheap: OpenAI promises at least six months for generally available models, Anthropic at least 60 days, Google Cloud at least 45 days for short-lived models.

Named production models have run twelve to twenty-two months before shutdown. Plan for six to eighteen months of useful life per model version, and keep the evaluation set that chose the model so you can rerun it on the successor.

Which model should you choose?

Figure 3 is the decision flow I walk through with clients. Four questions cover most cases; the footnote covers the rest.

When not to switch:

• A new model is rarely a reason to switch. The successor gives different answers on your documents even when it is better; rerun the evaluation set before moving.
• Do not write "always the latest model" into a policy. The flagship of September 2026 costs eight times more per million input tokens than the flagship of a year earlier.
• Do not pay for reasoning on grounded summarising. Reasoning helps on open problems and can hurt on tasks where the answer is in the retrieved passage; only your own test tells you which case you are in.
• Do not send a fixed-option decision to a flagship. A decision model or a small open model does it in milliseconds for cents.

What should an AI architect learn?

The skill is combining models, not calling one API. This is the order I would study in.

The practical project that teaches all of it: a multi-model enterprise platform with Microsoft Foundry as the model management layer, GPT, Claude and Gemini as external providers, Qwen and DeepSeek on vLLM, Microsoft Decision-1 for routing and classification, LangGraph for orchestration, PostgreSQL with pgvector for retrieval, Redis for caching, FastAPI for the API, Docker and Kubernetes for deployment, and MLflow for evaluation. That is an enterprise architecture, not another chatbot.

Sources

• AI Board, AI Models for Executives 2026, research report published 8 September 2026 and updated 26 October 2026: the flagship table, the release and retirement lists, prices, context windows and EU routes, each line with the vendor's own source. Read on 6 November 2026.
• Microsoft Learn, Foundry Models sold by Azure (page dated 21 September 2026, updated 29 October 2026): the Microsoft-Decision-1 entry, and Use the Azure OpenAI Decisions API (21 October 2026).
• Microsoft, Microsoft-Decision-1: Our model for fast decision-making, announcement of 9 October 2026: base model, price, latency and accuracy claims.
• Vendor model pages read on 6 November 2026 for the September and October releases: OpenAI (GPT-6.1 Terra), Anthropic (Claude Opus 5.5, Sonnet 5.5, Haiku 5.5), Google (Gemini 4 Argon), xAI (Grok 4.7), Meta (Muse Wonder, Muse Spark Open), DeepSeek (V4.1-Flash), Mistral (Large 4 preview), Alibaba (Qwen3.8-Max, Qwen3.8-27B), with the model cards on Hugging Face for the open-weight sizes and licences.
• My own study notes of November 2026 on use-case positioning, the routing signals, the invoice pipeline and the learning path, written from the projects on this site. Positioning is my reading, not a measurement; prices and availability change monthly and the vendors' pages are the source of truth.