Aventure Cloud Blog — 6 November 2026
Every AI product today starts with the same question: which language model should we use? The answer is rarely “the biggest one”. A frontier model can reason through a hard problem, a lite model can answer ten thousand routine questions for the price of one frontier answer, and an open-source model can run inside your own cloud where your data never leaves.
This post explains how large language models (LLMs) work, what the latest models are as of 6 November 2026, and how to choose between them — by the work, not by the hype. Prices below are as of 6 November 2026, from the providers’ published pricing and pricing trackers checked that day. Prices change often, and several are introductory or promotional — check the provider’s pricing page before you budget.
1. What an LLM Is: The Transformer, in Plain Language
A large language model is a program trained to predict the next word — more precisely, the next token — in a piece of text. A token is a chunk of text, roughly three-quarters of a word in English. “Hello, how are you?” is about six tokens. By predicting the next token, over and over, a model can write an email, summarise a document, write code, or plan the steps of a task.
Almost every modern LLM is built on one architecture: the transformer, introduced in the 2017 paper “Attention Is All You Need”. Three ideas in it matter for everyone who uses LLMs, not just engineers.
Attention — the model reads the whole sentence at once
Older models read text one word at a time, left to right, and forgot the beginning by the time they reached the end. A transformer uses self-attention: for each word, it looks at every other word in the passage and asks, “which of these matter most for understanding this word?” In “the bank approved the loan”, attention links “bank” to “loan”, not to a river bank. That is why LLMs are good at context — pronouns, references, and long documents.
Encoder and decoder — understanding, and writing
A transformer has two halves, and different models use them differently:
- The encoder reads input and builds an understanding of it. It is used for classification, search, and understanding tasks — “is this ticket urgent?”, “find the clause about payment terms?”
- The decoder generates output, one token at a time. It is the part that writes the answer, the email, or the code.
- Encoder-decoder models do both: read a document, then write a summary. Most chat models you use every day are decoder-only: they read your prompt as context and then generate the reply.
In practice, you do not choose encoder vs decoder when you pick a model — the provider has already made that choice. What matters is knowing that understanding and generation are different jobs, and a model can be strong at one and weaker at the other.
Parallel processing — why transformers scaled
Because attention looks at the whole passage at once, a transformer can process many words in parallel, on many GPU cores at the same time, instead of one word after another. That parallelism is the reason models could be trained on trillions of words — and the reason they answer in seconds rather than minutes. It is also why cost is measured in tokens: more tokens in, more parallel work, more compute, more cost.
Positional encoding — remembering the order
If a model reads everything at once, how does it know the order of the words? “The dog bit the man” is not the same as “the man bit the dog”. Positional encoding adds a signal to each token that says where it sits in the sequence — first, second, third — so the model keeps the order even while processing in parallel. Modern models use a variant called rotary position embedding (RoPE), which also helps them handle very long inputs. That is part of why today’s models can take a 1-million-token context window: a whole codebase, or hundreds of pages, in one prompt.
The short version
Attention lets the model understand context. The encoder understands, the decoder writes. Parallel processing lets it scale. Positional encoding keeps the order. Everything else in this post — frontier, lite, open-source, routing, fine-tuning — is a decision about how much of that capability you need, and what you are willing to pay for it.
2. Frontier Models: The Biggest, Most Capable Models
A frontier model is the most capable model a lab offers at a given time. It is the one built for the hardest work: multi-step reasoning, long agentic tasks, hard coding, complex analysis, and professional work where a mistake is expensive.
Frontier models are the most expensive per token, the slowest to answer, and the best at work that smaller models get wrong. Use them where quality matters more than price — and route everything else away from them, as Section 7 explains.
As of 6 November 2026, the frontier line-up is:
| Provider | Frontier model | Best for |
|---|---|---|
| OpenAI | GPT-6 Astra | Hardest reasoning, long-horizon agents, computer use, professional coding |
| OpenAI | GPT-6.1 Sol | Near-frontier quality at a fifth of Astra’s price |
| Anthropic | Claude Opus 5.5 | Long-running agentic coding, large codebases, financial analysis |
| Anthropic | Claude Fable 5.1 | The hardest long-running work, above Opus |
| Gemini 4 Argon | Complex engineering, maths and science, multi-step agents | |
| Gemini 4 Carbon | Google’s strongest model — but limited access (see Section 5) | |
| Gemini 3.1 Pro | Complex reasoning and multimodal work |
A frontier model is not a permanent title. Every few months a new model takes the top spot, and yesterday’s frontier becomes today’s mid-tier — at a lower price. Budget for the tier, not the model name.
3. Lite Models: Small, Fast, Cheap — and Good Enough for Most Work
A lite model is a small, fast, low-cost model from the same family as a frontier model. It is built for high-volume, routine work: classification, extraction, summarisation, first-line replies, translation, and the sub-steps of an agent.
Lite models have improved faster than any other tier. In 2026, a lite model can do work that needed a frontier model two years ago — and at roughly one-tenth to one-hundredth of the price. Most production traffic is routine work. That is the whole case for lite models: do not pay frontier prices for work a lite model does well.
| Provider | Lite model | Price per 1M tokens, input / output (as of 6 Nov 2026) |
|---|---|---|
| OpenAI | GPT-6 Luna | $0.10 / $0.50 |
| OpenAI | GPT-5 nano | $0.05 / $0.40 |
| Anthropic | Claude Haiku 5.5 | $0.10 / $0.50 (prompts up to 100K tokens) |
| Gemini 3.5 Flash-Lite | $0.30 / $2.50 | |
| Gemini 3.1 Flash-Lite | $0.25 / $1.50 |
A lite model is the right default for: ticket and email classification, invoice and form field extraction, meeting and call summaries, FAQ-style replies, translation of routine notices, and agent sub-tasks such as pulling one figure from a filing. Keep the frontier model for the work in Section 12’s right-hand column.
4. Open-Source Models: Own the Weights, Run Them Yourself
Open-source — more precisely, open-weight — models publish their weights, so you can download them, run them on your own hardware or cloud, fine-tune them, and inspect how they behave. Most ship as open weights under a licence, not as fully open-source projects, so read the licence before you build a business on one. MIT and Apache 2.0 are the cleanest for commercial use. Meta’s Llama Community Licence, for example, permits commercial use only up to 700 million monthly active users, above which an explicit Meta agreement is required.
Why choose open weights? Three reasons: data control (your data never leaves your cloud), cost at scale (no per-token API bill — you pay for the GPUs instead), and customisation (fine-tune freely, without a provider’s restrictions). The trade-off is that you run the infrastructure: GPUs, serving, monitoring, and safety are your job.
The open-weight shortlist, November 2026
| Model | Size / type | Licence | Best for |
|---|---|---|---|
| DeepSeek V4.1 Flash | ~552B backbone, 8B active per token (MoE) | MIT | Best all-round open model; 1M-token context |
| DeepSeek V4 Pro | ~1.6T total (MoE) | MIT | Heavier open reasoning and coding |
| Kimi K3 / K3.1 Pro (Moonshot) | 2.8T total, 104B active (MoE) | MIT-based | Largest open-weight model; long-horizon agents |
| Qwen3.8-27B (Alibaba) | 27.8B dense | Apache 2.0 | Strongest small open model; fits on one GPU |
| Qwen3.8-Flash-Next | ~125–180B (MoE) | Qwen community | Fast open model with long context |
| Mistral Large 4 | ~1T total, 52B active (MoE) | Mistral custom | Strongest open model from outside China; 1M context |
| Mistral Small 4 | 119B (MoE) | Apache 2.0 | Mid-size open model, wide tooling |
| Gemma 4 (Google) | 2B–31B dense / MoE | Apache 2.0 | Best model that runs on a single laptop; edge |
| Llama 4 Scout / Maverick (Meta) | 109B / ~400B (MoE) | Llama 4 Community | Widely mirrored; long context (Scout: 10M tokens) |
| Muse Spark Open (Meta) | 816B total, 42B active (MoE) | Open weights, Oct 15, 2026 | Coding and agentic work; 1M context |
| GLM-5.3 Flash (Z.ai) | 320B total (MoE) | MIT | Near-frontier quality; long-horizon agents |
Two notes on this list. First, it changes every month — check the model card on Hugging Face for the current version, parameter count, and licence before you choose. Second, “open” does not mean “free”: a 400B–1T-parameter model needs serious GPU hardware to run well, while a 27B model like Qwen3.8-27B or a 12B Gemma 4 runs on a single good GPU. Pick the size that fits your hardware, not the biggest name on the list.
Hosted open models are also available by API — for example, DeepSeek V4.1 Flash is listed at around $0.15 input / $0.60 output per million tokens off-peak through some hosted providers — so you can start with an API and move to self-hosting later, on the same weights.
5. Latest Models as of November 2026
This is the part that goes out of date fastest. The versions below are what was current on 6 November 2026, verified from live web checks that day.
OpenAI — the GPT-6 family
OpenAI’s current flagship line is the GPT-6 family. All are reasoning models with a 1.05M-token context window and up to 128K output tokens.
| Model | Released | Price per 1M tokens, input / output (as of 6 Nov 2026) | What it is for |
|---|---|---|---|
| GPT-6 Astra | Sep 3, 2026 | $10 / $50 | Top flagship. Deepest reasoning, long-horizon agentic work, computer use, professional coding. |
| GPT-6.1 Sol | Sep 29, 2026 | $2 / $10 | Mid-tier, near-Astra performance at a fifth of the price. OpenAI’s best value frontier. |
| GPT-6.1 Terra | Oct 26, 2026 | $1 / $5 | Newcomer in the flagship list; balanced cost and capability. |
| GPT-6 Luna | Sep 22, 2026 | $0.10 / $0.50 | Small, high-volume. Routing, classification, extraction. |
| GPT-5.6 Sol | Jul 2026 | $4 / $20 (promotional, at least through Nov 21, 2026) | Previous flagship reasoning; being replaced by GPT-6. |
| GPT-5 | Aug 2025 | $1.25 / $10 | Older flagship; API retirement planned Dec 11, 2026. |
| GPT-5 mini / nano | 2025 | $0.25 / $2.00; $0.05 / $0.40 | Older lite models; also retiring Dec 11, 2026. |
Astra — read this carefully, because the name is confusing. There are two different “Astras”:
- OpenAI GPT-6 Astra is a model — the one in the table above. That is the Astra this post means when it says “Astra”.
- Google Project Astra is a different thing entirely: a Google DeepMind research prototype for a universal AI assistant that sees through a camera, listens, remembers context, and answers by voice. It runs on Google’s Gemini models, has no API of its own, and as of November 2026 is still a limited trusted-tester prototype, with its capabilities being folded into Gemini Live. It is not a model you can call, and it has no standalone price.
What is NOT released: GPT-6.1 Astra was scheduled for October 2026 and was cancelled in late September 2026 over alignment and scope-authorisation issues. GPT-6.2 Astra is not officially released as of 6 November 2026 — only an unannounced canary identifier (gpt-6.2-astra) has been seen in Codex telemetry, with rumoured pricing around $4 / $20 that is unverified. Do not plan a project around GPT-6.2 Astra until OpenAI announces it. Reports in early November said OpenAI may release Astra, Sol, and Cyber models as early as 6 November 2026 — unconfirmed, with no official announcement, benchmarks, or pricing yet.
Above 272K input tokens, OpenAI’s rates rise — Astra, for example, goes to $20 input / $75 output in long context. Cached input is much cheaper (Astra $1.00, Sol $0.10 per million).
Anthropic — the Claude 5.5 family
Anthropic’s current line-up is the Claude 5.5 family, completed between September and October 2026, plus Fable at the top.
| Model | Released | Price per 1M tokens, input / output (as of 6 Nov 2026) | What it is for |
|---|---|---|---|
| Claude Fable 5.1 | 2026 | $10 / $50 | Hardest long-running work, above Opus. |
| Claude Opus 5.5 | Sep 22, 2026 | $4 / $20 | Enterprise daily driver: long-running coding in large codebases, agents that coordinate sub-agents, financial analysis. 1M-token context, up to 128K output. |
| Claude Sonnet 5.5 | Sep 28, 2026 | $2 / $10 | Balanced speed and intelligence; Anthropic’s first recommendation for most API users. 1M-token context. |
| Claude Haiku 5.5 | Oct 7, 2026 | $0.10 / $0.50 (up to 100K tokens) | Fastest and cheapest; classification, summarisation, real-time chat, sub-agents. Above 100K tokens: $0.50 / $2.50. |
There is also Claude Mythos 5.1, a specialised highest-difficulty reasoning line in the same family, with limited access. Sonnet 4.5 API support ends 30 November 2026 — if you still call it, move to Sonnet 5.5.
Google — the Gemini 4 family
Google’s current flagship line is Gemini 4, which replaced Gemini 3 as the newest generation.
| Model | Released | Price per 1M tokens, input / output (as of 6 Nov 2026) | What it is for |
|---|---|---|---|
| Gemini 4 Carbon | Oct 28, 2026 | $2 / $10 introductory, then $4 / $20 | Google’s strongest model; ranked #1 on the Artificial Analysis Intelligence Index. Limited access only — cyber defenders first, then trusted partners via the Fairwind Program. No public model ID or developer API date as of 6 Nov 2026. |
| Gemini 4 Argon | Oct 13, 2026 (GA) | $2 / $10 introductory through Nov 30, 2026, then $4 / $20 | The flagship you can actually call: complex engineering, maths and science, autonomous multi-step agents. Model ID gemini-4-argon. |
| Gemini 3.1 Pro | Feb 19, 2026 | $2 / $12 (up to 200K tokens); $4 / $18 above | Complex reasoning and multimodal work. |
| Gemini 3.8 Flash | 2026 | $0.75 / $3.75 through Dec 31, 2026, then $1.50 / $7.50 | Fast multimodal work. |
| Gemini 3.5 Flash-Lite | 2026 | $0.30 / $2.50 | Lite work with a free API tier on some models. |
Gemini 3 itself launched in November 2025; the original Gemini 3 Pro preview was shut down in March 2026 and its API name now points to Gemini 3.1 Pro Preview. If you build on Gemini today, build on Gemini 4 Argon — it is the current flagship with a public API — and treat Carbon as “coming”, not “available”.
6. Model Cards: Read Before You Choose
A model card is the model’s identity document. Before you pick a model for production, read its card. A good model card contains:
- What the model is — architecture, size, training data in general terms, and what it was designed for.
- What it can and cannot do — intended uses, and uses it is not suited for.
- Benchmarks — scores on standard tests, with the conditions they were run under. Benchmarks are a guide, not a guarantee: run your own evaluation on your own data (see Section 9).
- Limitations and risks — known failure modes, bias, hallucination, and safety behaviour.
- Licence and data terms — whether you can use it commercially, fine-tune it, and what happens to your prompts. This matters most for open-weight models.
- Version and date — model cards change with each release; a card from six months ago may describe a model that no longer exists.
If a model has no model card, treat that as information: you are being asked to trust it without evidence. For enterprise work, that is a reason to choose a different model, not to skip the check.
Microsoft Foundry makes all of these models available — check all model cards there for pricing.
7. Model Routing: The Cheapest Model That Can Actually Do the Job
Model routing is the practice of sending each request to the cheapest model that can handle it, instead of paying frontier prices for every call. It is the single largest lever on an AI bill in 2026 — published research (RouteLLM, FrugalGPT) reports cost reductions of 35% to 85% while keeping about 95% of frontier-model quality, because most production traffic never needed a frontier model in the first place.
How a router decides
There are five common strategies, and you can combine them:
- Rule-based routing. Fixed rules map task types to models: classification goes to a lite model, drafting goes to a mid-tier model, multi-step analysis goes to a frontier model. Zero added latency, zero added cost. Start here.
- Cost-aware routing. Route on token count or budget: long prompts go to a cheaper model, or to a model with a cheaper long-context rate.
- Semantic routing. Match the request’s meaning (via embeddings) against predefined routes, without calling an LLM to classify. About 50–150 ms of added latency.
- LLM-classifier routing. A cheap model scores each prompt’s difficulty, then sends it on. Adds 300–800 ms and the classifier’s token cost — worth it only for mixed-difficulty traffic where quality comes first.
- Cascade (model tiering). Try the cheap model first; escalate only if the answer looks weak or confidence is low. A support bot answers from a $0.10-per-million model; if confidence dips below a threshold, the same request retries on a frontier model.
A well-tuned router that sends 60–70% of traffic to small models and 30–40% to frontier models is reported to cut cost per query by roughly 37–46%. Push the cheap share to 80% and the reported saving climbs toward 72%. The failure mode to guard against is silent quality regression: a router that sends too much to a weak model, and nobody notices because no one is measuring quality. Route on measured quality per task, not on hope — run an evaluation set (see Section 9) and check the router against it every time you change it.
Routing also removes a single point of failure: when one provider is down, traffic shifts to another. In a multi-cloud setup, that is a resilience decision as well as a cost decision.
8. Fine-Tuning: Teaching a Model Your Work
Fine-tuning takes a pre-trained model and trains it further on your own examples, so it learns your format, tone, domain vocabulary, and task. Pre-training decides what the model knows; fine-tuning decides how it answers your users.
Fine-tuning is the right tool when:
- The task is stable, with strict output rules (a fixed JSON schema, a report format, a classification label set).
- You have good examples — typically thousands to tens of thousands, clean and consistent.
- Prompting alone does not get you there: the model keeps drifting in format, tone, or terminology.
It is the wrong tool when the problem is missing knowledge. Fine-tuning does not reliably teach a model new facts — that is what RAG (retrieval-augmented generation) is for: give the model the document at run time instead of baking it into the weights. The rule of thumb: RAG for knowledge, fine-tuning for behaviour.
Practical notes:
- LoRA / QLoRA are the common efficient methods: they freeze the base model and train small added weight matrices instead of the whole model, so fine-tuning is cheap and fast — and the adapter can be swapped without retraining the base.
- Supervised fine-tuning (SFT) is the first stage: train on instruction-and-response pairs so the model follows instructions in your format.
- Evaluate before and after. A fine-tuned model can get better at your task and worse at everything else. Keep a held-out test set, and do not ship a fine-tune that has not beaten the base model with a good prompt on that set.
- Fine-tuning does not fix a bad task design. If the instructions are unclear to a human, they will be unclear to a fine-tuned model too.
9. Model Optimization: Making a Model Cheaper and Faster Without Making It Dumber
Optimization is everything you do to cut cost or latency after you have chosen a model. The main levers, in the order most teams should try them:
- Prompt optimization. Shorter, clearer prompts cost less and work better. Remove repeated instructions, put stable instructions in a system prompt, and stop asking the model to repeat back what you already know. This is free, and it is usually the biggest quick win.
- Prompt caching. If many requests share the same long context (a document, a codebase, a set of instructions), the provider caches it and charges a fraction for re-reading it. Cached input is typically 90–95% cheaper than fresh input — for example, GPT-6 Astra cached input is $1.00 vs $10.00 fresh, and Gemini 4 Argon cached input is 95% off.
- Batch API. Non-urgent work (overnight processing, bulk classification) can go through a batch API at roughly half the standard price — GPT-5, for example, is $0.625 input / $5 output in batch vs $1.25 / $10 standard.
- Quantization. Shrink the model’s weights from 16-bit to 8-bit or 4-bit numbers. The model gets smaller and faster, uses less GPU memory, and loses a little accuracy. This is how a 27B model runs on one GPU. Use it for self-hosted open models.
- Distillation. Train a small model to imitate a large model’s answers on your specific task. The small model then does that one task almost as well, at a fraction of the cost. This is the best way to turn a frontier model’s quality into a lite model’s bill — but only for a narrow, stable task.
- Semantic caching. If a new question is very similar to one already answered, return the cached answer instead of calling the model again. Works well for FAQ and support traffic.
- Evaluation first. None of the above is safe without a test set: a set of real examples with known-good answers, run before and after every change. If quality drops, the saving is not a saving.
10. Reinforcement Learning for Models: How Models Learn from Rewards
After pre-training and fine-tuning, the best models are shaped by reinforcement learning (RL) — learning from rewards, not just from examples. In plain terms: the model tries many answers, gets a score for each one, and adjusts so that high-scoring answers become more likely.
- RLHF — Reinforcement Learning from Human Feedback. People rate or rank model answers; those ratings train a reward model; the reward model then scores the LLM during training. This is how models learn tone, helpfulness, and safety — things that cannot be checked by a rule. It is the original alignment method, used for InstructGPT and every major chat model since.
- RLAIF — Reinforcement Learning from AI Feedback. The same idea, but an AI judge rates the answers instead of a human. Cheaper and faster, and used widely for large-scale preference data.
- RLVR — Reinforcement Learning with Verifiable Rewards. Replace human ratings with automatic checks: is the maths answer correct? Does the code pass the tests? Does the output match the schema? RLVR is the right method where correctness can be verified by a program — maths, code, structured output, and agent tasks where the environment can be checked. It is the method behind much of the recent progress in reasoning models.
- GRPO — Group Relative Policy Optimization. An RL method from the DeepSeekMath work, used to train DeepSeek’s reasoning models. Instead of needing a separate value model to judge answers (as the older PPO method does), GRPO compares the rewards of a group of answers to the same prompt and learns from the comparison. It uses less memory than PPO and works well for reasoning tasks.
- DPO — Direct Preference Optimization. Learns directly from pairs of chosen and rejected answers, with no reward model and no sampling loop. Simpler and more stable than full RLHF, and often enough when the goal is tone and preference rather than deep reasoning.
- PPO — Proximal Policy Optimization. The older, standard RL algorithm behind early RLHF. It works, but needs a value model and more compute than GRPO.
The practical takeaway: you do not need to run RL yourself to benefit from it — the frontier labs already do. What you need to know is which kind of feedback a task needs. If quality depends on human judgement (tone, helpfulness), the model needs preference data. If success can be checked by a rule (a test passes, an answer matches), RLVR and GRPO are the methods that make reasoning models good — and they are the reason today’s models can work through multi-step problems instead of just guessing the next word.
11. Token Costs: What a Million Tokens Actually Costs
A token is roughly three-quarters of a word. A million tokens is roughly 750,000 words — about ten novels, or a large codebase. API pricing is quoted per million tokens, separately for input (what you send) and output (what the model writes). Output almost always costs more than input, because generating text is the expensive part.
Prices as of 6 November 2026. Check the provider’s pricing page before you budget — several prices below are introductory or promotional, with end dates.
| Model | Input / 1M | Output / 1M | Notes |
|---|---|---|---|
| GPT-6 Astra | $10.00 | $50.00 | Long context (>272K): $20 / $75 |
| GPT-6.1 Sol | $2.00 | $10.00 | |
| GPT-6.1 Terra | $1.00 | $5.00 | |
| GPT-6 Luna | $0.10 | $0.50 | |
| GPT-5 | $1.25 | $10.00 | Retiring Dec 11, 2026 |
| GPT-5 mini / nano | $0.25 / $0.05 | $2.00 / $0.40 | Retiring Dec 11, 2026 |
| Claude Fable 5.1 | $10.00 | $50.00 | |
| Claude Opus 5.5 | $4.00 | $20.00 | |
| Claude Sonnet 5.5 | $2.00 | $10.00 | |
| Claude Haiku 5.5 | $0.10 | $0.50 | Up to 100K tokens; $0.50 / $2.50 above |
| Gemini 4 Argon | $2.00 | $10.00 | Intro through Nov 30, 2026; then $4 / $20 |
| Gemini 4 Carbon | $2.00 | $10.00 | Intro; limited access only |
| Gemini 3.1 Pro | $2.00 | $12.00 | Up to 200K tokens; $4 / $18 above |
| Gemini 3.8 Flash | $0.75 | $3.75 | Through Dec 31, 2026; then $1.50 / $7.50 |
| Gemini 3.5 Flash-Lite | $0.30 | $2.50 | |
| DeepSeek V4.1 Flash (hosted) | ~$0.15 | ~$0.60 | Off-peak hosted rate; self-hosting has no per-token bill |
The spread is the story: from $0.05 per million input tokens (GPT-5 nano) to $10 (GPT-6 Astra, Claude Fable 5.1) — a 200× gap on input, and a 125× gap on output ($0.40 to $50). That gap is why routing and cost optimization matter more than picking the “best” model. The cheapest model that can do the job is the right model.
A worked example: 1,000 requests a day, each with 2,000 input tokens and 500 output tokens. That is 2M input and 0.5M output tokens a day, or 60M input and 15M output a month. On GPT-6 Astra that is about $600 + $750 = $1,350 a month. On GPT-6 Luna it is about $6 + $7.50 = $13.50 a month. On Claude Haiku 5.5, about the same as Luna. The work decides which of those numbers is right — a frontier model for 1,000 hard reasoning tasks, a lite model for 1,000 routine classifications — and the difference is a hundredfold.
12. Cost Optimization: Which Model for Which Work
The decision table
| Work | Choose | Why |
|---|---|---|
| Complex reasoning, multi-step analysis, hard maths, architecture decisions | Frontier: GPT-6 Astra, Claude Opus 5.5 / Fable 5.1, Gemini 4 Argon | Only frontier models reliably get this right; a wrong answer costs more than the tokens |
| Long-running agentic coding, large codebases, agents coordinating sub-agents | Frontier: Claude Opus 5.5, GPT-6 Astra, Gemini 4 Argon | Needs long context, planning, and tool use over many steps |
| Well-scoped coding, drafting, analysis at scale | Mid-tier: GPT-6.1 Sol, Claude Sonnet 5.5, Gemini 3.1 Pro | Near-frontier quality at a fifth of the price |
| Classification, extraction, routing, first-line replies | Lite: GPT-6 Luna, Claude Haiku 5.5, Gemini Flash-Lite | High volume, low ambiguity; lite models are built for this |
| Summarisation of internal documents, meeting notes | Lite or mid-tier, with caching | Repeated context is cheap when cached; frontier adds little |
| RAG answers over your own documents | Mid-tier or lite, with good retrieval | Quality comes from the retrieved documents, not the biggest model |
| Data must stay in your cloud, or no per-token bill | Open-weight, self-hosted: Qwen3.8-27B, Gemma 4, DeepSeek V4.1 Flash | Data control and cost at scale; you run the GPUs |
| Strict format, tone, or domain vocabulary, stable task | Fine-tuned lite model (LoRA) | A small fine-tuned model beats a big prompted one on a narrow task |
| Verifiable work — code that must pass tests, maths that must be right | Frontier + RLVR-trained model, with an evaluation set | Reasoning models trained with verifiable rewards; verify the output, do not trust it |
| Real-time voice or chat, low latency | Lite: Haiku 5.5, GPT-6 Luna, Gemini Flash | Speed matters more than depth; a slow perfect answer loses to a fast good one |
Five rules that save real money
- Route by difficulty, not by habit. Measure your traffic: most teams find 60–80% of requests are routine. Send those to a lite model first.
- Cache everything stable. System prompts, documents, and few-shot examples should be cached, not re-sent fresh every call. Cached input is 90–95% cheaper.
- Batch the non-urgent. Overnight jobs, bulk classification, and backfills go through the batch API at about half price.
- Distil the stable task. If one task runs a million times a month, distil the frontier model’s answers into a small fine-tuned model and run that instead.
- Measure cost per task, not per token. A frontier model that answers in one call can be cheaper than a lite model that needs three retries and a human fix. Track the full cost: tokens, retries, latency, and human time.
13. Takeaway
There is no single best LLM. There is a best LLM for each piece of work.
Frontier models — GPT-6 Astra, Claude Opus 5.5 and Fable 5.1, Gemini 4 Argon — are for the hardest reasoning, the longest agents, and the work where a mistake is expensive. Lite models — GPT-6 Luna, Claude Haiku 5.5, Gemini Flash-Lite — are for the high-volume routine work that makes up most of production traffic, at a hundredth of the price. Open-weight models — DeepSeek V4.1, Qwen3.8, Gemma 4, Mistral Large 4 — are for when your data must stay in your cloud, or when you want to own the model and fine-tune it freely.
The transformer underneath them all is the same idea: attention for context, an encoder to understand and a decoder to write, parallel processing to scale, and positional encoding to keep the order. What changes between models is how much of that capability you buy, and how you shape it afterwards — with a model card to check, a router to choose, fine-tuning to teach behaviour, optimization to cut cost, and reinforcement learning to teach reasoning.
Start with the work. Pick the cheapest model that can do it well. Measure quality on your own data. And when the work gets harder, escalate — that is what the frontier is for.
Want help choosing the right model for your work, or building an agent on it? Email info@aventurecloud.net. For training enquiries, email info@aventurecloud.net. For careers, email hr@aventurecloud.net.
No responses yet