How to Choose an LLM in 2026 - OpenAI, Anthropic, Google or Open Weights (Prices, Testing, Routing)

There's no single best LLM - there's the best model for a specific task at your budget and with your data requirements. In October 2026, the cheapest models cost 10-30 cents per million input tokens and the most capable ones $2-10, a difference of up to a hundred times. So instead of picking a "favorite vendor", match the model tier to the task, compare the cost of the whole task rather than the token price, and always check your choice on your own data.

The current GPT-6, Claude 5.5, Gemini 3 and open-weight lineup with prices from official price lists, which model fits which task, how to calculate the cost of a whole task, a one-hour selection test and a multi-model router in code.

In this guide I cover the current lineup from OpenAI, Anthropic, Google and open-weight models (with prices from official price lists), how the vendors differ, which model fits which task, how to calculate the real cost, how to test candidates on your own data in an hour, and how to build a router that sends queries to different models.

The most common mistakes when choosing a model

• Choosing by leaderboards. General benchmarks measure general skills, not your task. A model at the top of a leaderboard can lose on your data.
• One model for everything. Using the most expensive model to classify emails burns budget, and using the cheapest for complex analysis risks errors.
• Comparing token prices alone. What counts is the cost of the whole task: how many tokens the model uses, how much it writes in the response and whether you can use caching.
• Hard-coding the model. New versions arrive every few months and old ones are retired. Without an abstraction layer, every change means refactoring.
• No tests on your own data. An hour of testing on 50 real examples is worth more than a week of reading comparisons.

The model lineup in October 2026

Prices come from official price lists in October 2026 and apply to the standard tier. Three caveats: Gemini 3.8 Flash has an introductory price until the end of 2026 and doubles from January 2027; Gemini 3.1 Pro costs $4 and $18 for prompts above 200,000 tokens; and all three vendors offer a 50% discount in batch mode (Batch API) for tasks that don't need an immediate result.

How the vendors differ

OpenAI has the broadest ecosystem of tools and integrations, native structured outputs with JSON schema, and three clear GPT-6 tiers with the same large context window. A good default when you want to build a prototype fast and be sure every tool supports it.

Anthropic develops Claude with agents, code and long instructions in mind. Since version 4.6, its models have a one-million-token window at standard pricing, and caching can cut the cost of repeated context by 90-97.5%. A note for comparisons: models from version 4.7 onward use a new tokenizer that, according to Anthropic, produces about 30% more tokens for the same text.

Google offers Gemini with strong image, video and audio handling in one model, very cheap Flash and Flash-Lite models, and natural integration with Google Cloud and Workspace.

Open-weight models give you full control over your data and the ability to fine-tune on your own domain. The most important in 2026:

• Qwen 3.5 (Alibaba, Apache 2.0 license) - a family from 0.8 to 397 billion parameters, handling text, images and video.
• DeepSeek V4 (MIT license) - a Flash version and a large Pro version, with a one-million-token window.
• Gemma 4 (Google, Apache 2.0) - small models from about 2 to 31 billion parameters, good for laptops and edge devices.
• Mistral Large 3 (Apache 2.0) - a European vendor, strong in European languages.
• Bielik 3.0 - an 11B Polish model from SpeakLeash and Cyfronet AGH, built for the Polish language and Polish context.

Which model for which task

Compare the cost of the task, not the token price

The price per million tokens is only one factor. You calculate the cost of a task like this:

task cost = input tokens × input price + output tokens × output price

Four things that are easy to forget affect the result:

• Response length. Output is usually 5 times more expensive than input, and "thinking" models generate extra reasoning tokens.
• The tokenizer. The same text is a different number of tokens at different vendors - with newer Claude models, about 30% more than with older ones.
• Caching. A repeated system prompt or document from the cache costs 10% of the price, and with Anthropic's newest models as little as 2.5-5%.
• Batch mode. Tasks that can wait cost half.

An example: a chatbot handles 30,000 conversations a month, each averaging 3,000 input tokens (2,000 of which are a fixed prompt and knowledge base fragments) and 400 response tokens. On GPT-6.1 Sol without caching that's about $300 a month (90M input tokens × $2 + 12M output tokens × $10). With caching for the fixed part of the input (cached input on GPT-6.1 Sol costs $0.10 per million tokens), the cost drops to about $186. On GPT-6 Luna the same work costs around fifteen dollars - the only question is whether the answer quality is good enough. That's decided by a test, not a price list. I cover more ways to cut costs in the post on API cost optimization.

A one-hour model selection test

Before you decide, run a simple test on your own data:

1. 1.Collect 50 real examples of the task - emails, documents, customer questions - together with the expected result.
2. 2.Pick three candidates: one each from the cheaper, mid and stronger tiers.
3. 3.Run all the examples on each model with the same prompt.
4. 4.Score the results in a spreadsheet using the criteria below.
5. 5.Choose the cheapest model that meets the quality bar - not the one with the best score.

To score a large number of answers, you can use a second model as a judge - I describe this in the post on LLM evaluation. Keep the same set of examples for later: whenever you change models, run it again and you'll immediately see whether anything got worse.

A router - several models in one application

The best applications don't use one model. A cheap model handles simple queries, and a more expensive one only the hard ones. Keep model names in configuration, not in code, so a version change is a change to one variable:

import osfrom openai import OpenAIfrom anthropic import AnthropicMODELS = {    "cheap":   ("openai",    os.environ.get("MODEL_CHEAP", "gpt-6-luna")),    "default": ("openai",    os.environ.get("MODEL_DEFAULT", "gpt-6.1-sol")),    "hard":    ("anthropic", os.environ.get("MODEL_HARD", "claude-opus-5-5")),}

def classify(message: str) -> str: """A cheap model decides which tier is needed.""" r = OpenAI().chat.completions.create( model=MODELS["cheap"][1], messages=[ {"role": "system", "content": "Rate the task complexity. Answer with one word: cheap, default or hard."}, {"role": "user", "content": message}, ], max_tokens=3, ) label = r.choices[0].message.content.strip().lower() return label if label in MODELS else "default"

def ask(message: str, system: str = "") -> tuple[str, str]: provider, model = MODELS[classify(message)] if provider == "openai": msgs = ([{"role": "system", "content": system}] if system else []) + [{"role": "user", "content": message}] r = OpenAI().chat.completions.create(model=model, messages=msgs) return r.choices[0].message.content, model r = Anthropic().messages.create( model=model, system=system, max_tokens=4096, messages=[{"role": "user", "content": message}], ) return r.content[0].text, model

In production, add a fallback vendor for outages, cost limits, and logging of which model handled which query. Ready-made libraries such as LiteLLM give you one API for many vendors.

When open-weight models pay off

A model on your own server makes sense when at least one of these is true:

• Data can't leave the company - professional secrecy, medical data, customer requirements.
• Volume is very large and steady - then the server cost spreads over millions of requests.
• You need fine-tuning on your own domain - with full control over the data and the model. Details in the guide on fine-tuning an LLM.

At low volume and with nobody to maintain a server, an API is almost always cheaper. I describe how to run a model locally in the post on Ollama and vLLM. For Polish-language text, it's worth testing Bielik alongside global models - on some tasks a smaller model built for Polish beats larger ones.

Checklist

1. 1.Describe the task specifically: classification, extraction, question answering, an agent, code?
2. 2.Decide whether data may go to an outside vendor.
3. 3.Pick three candidates from different tiers.
4. 4.Test them on 50 of your own examples using the criteria table.
5. 5.Calculate the cost of the whole task at the planned volume, with caching and batch mode.
6. 6.Choose the cheapest model that meets the quality bar.
7. 7.Keep model names in configuration and plan a fallback vendor. How to build that plan B, and how much time you get when a model is retired, is covered in the post on AI vendor lock-in.
8. 8.Keep the test set and run it whenever you change models.

---

I help companies choose and deploy LLMs - from tests on their own data and cost calculations to a router with a fallback vendor and quality monitoring. I do this as part of AI app development and AI consulting. Get in touch - I'll start with an analysis of your use case and a recommendation of models to test.

Worth reading next:

• AI API Cost Optimization - Caching, Model Matching, Batch Mode and Context Compression
• LLM Evaluation (Evals) - How to Measure AI Application Quality with LLM-as-a-Judge
• Ollama, vLLM and Self-Hosted LLM - How to Run a Local AI Model in Your Company
• Fine-tuning an LLM on Company Data - When, How and What to Avoid
• AI Vendor Lock-in - How Not to Depend on One Model Provider