AI engineering · Module 04 of 21 · Level 1: How AI works

Reasoning, model tiers and cost

Which model should you use, how hard should it think, and what will it cost? Three settings decide quality, speed and the bill. Learn to turn them deliberately and you'll get better results for a fraction of the price.

1. The idea

You wouldn't ask your most senior architect to rename a variable, or give an intern a week to design your payment system. You match the person to the job, and you decide how long they should spend on it. AI models work the same way, and you pay for every minute.

Reasoning: thinking before answering

Modern models can think before they answer: they write out working (restating the problem, trying approaches, checking results) and only then write the final answer. That working is made of tokens too, called reasoning or thinking tokens. Two facts matter:

Thinking makes hard problems go much better: maths, tricky bugs, design and long agent tasks.
Thinking is billed as output, the expensive kind of token, even when the tool hides the thinking from you. It also adds waiting time.

Current models decide for themselves how much to think (Anthropic calls this adaptive thinking), steered by an effort setting such as low, medium or high. Gemini calls it the thinking level; OpenAI calls it reasoning effort.

Tiers: small, balanced, strongest

Each vendor sells a family of models. Smaller ones are faster and far cheaper; bigger ones are smarter and slower. As of October 2026:

Tier	Anthropic (Claude)	Google (Gemini)	OpenAI (GPT)	Typical jobs
Fast and cheap	Haiku 5.5	3.5 Flash-Lite, 3.1 Flash-Lite	GPT-6 Luna	Classifying, extracting fields, routing, simple edits, high volume
Balanced	Sonnet 5.5	3.8 Flash	GPT-6.1 Sol	Most coding and writing; the everyday default in many teams
Strongest	Opus 5.5 (Anthropic's suggested default), Fable 5.1 (hardest work)	Gemini 4 Argon	GPT-6 Astra	Hard bugs, architecture, long autonomous agent tasks, reviews

Names change every few months; the tiers don't. Check the vendors' model pages before you rely on a name.

Price: per million tokens, input and output

APIs charge per million tokens, with output typically about 5 times the input price. Two discounts matter: prompt caching (re-sending the same start of a prompt costs 2.5–10% of the normal input price) and the batch API (half price if you can wait hours for results).

2. How it works

Every request's bill: input tokens at the input price, plus thinking and answer tokens at the output price. Each of the three dials changes one part.

Step through the same tricky bug answered at low and high effort, on a balanced model priced at $2 per million input and $10 per million output tokens.

3. Try it yourself: the cost calculator

Pick a model and a workload. Prices are the vendors' list prices on 13 October 2026; the thinking amounts per effort level are illustrative, since real thinking depends on the task.

4. Why it matters at work

Start small, raise one dial at a time. Try the balanced tier at low or medium effort first. Raise the tier or the effort only when the result isn't good enough, and keep the cheaper setting where it is.
Route by job. In products, send simple high-volume work (classify, extract, route) to the fast tier and only the hard part to a stronger model. In coding agents, use a strong model for planning and review and a cheaper one for searching and simple edits.
Output dominates. Thinking and answer tokens are the expensive ones. Ask for diffs, JSON or short answers instead of essays, and cap the maximum output.
Cache and batch. Keep the stable part of prompts (instructions, tool definitions, documents) identical and first, so it's cached. Send anything that can wait through the batch API.
Compare tasks, not price lists. Different tokenizers turn the same text into different token counts, and a cheaper model that needs three attempts isn't cheaper. Measure cost per finished task.
Let evals decide, not leaderboards. Public benchmarks are good for a shortlist; your own test set (Module 17) decides which model is good enough for your job.

5. In your five tools

Each tool lets you change the model and the thinking effort, and see what you've spent. Checked October 2026.

Tool	Change the model	Change the effort	See usage
Claude Code	`/model`	`/effort` (low, medium, high, xhigh, max)	`/cost` or `/usage`
Antigravity CLI	`/model`	`/fast` skips reasoning for quick tasks	`/usage`, `/credits`
GitHub Copilot (VS Code)	Model picker in the chat input	Thinking Effort submenu next to the model name (None, Low, Medium, High)	Usage and credits in your Copilot settings
Cursor	Model picker; Auto lets Cursor choose a cost-efficient model	Choose a model variant in the picker	The usage page in your Cursor account
Codex CLI	`/model`	Picked in `/model`; `Alt`+`,` and `Alt`+`.` lower or raise it	`/status`

6. Remember it

Memory hook: "Three dials on the bill: tier, effort, tokens"Every quality, speed and cost decision is one of three dials. Start low and raise one dial at a time, only when the result isn't good enough.

How this hook works: what “Three dials on the bill: tier, effort, tokens” means

What the slogan means, phrase by phrase

“Three dials”: You don't control the model's insides; you control three settings. Each one trades money and time for quality.
“tier”: Which size of model: fast, balanced or strongest. Moving up a tier multiplies the price per token by anything from 2 (Sonnet to Opus) to 100 (Haiku to Fable).
“effort”: How long it may think. Thinking tokens are billed as output, so high effort can multiply the cost of a request several times over.
“tokens”: How much goes in and comes out: context size, answer length, and the discounts on them (caching, batch).
“on the bill”: Each dial multiplies the others. Turning all three up at once is how a feature ends up costing 500 times what it needed to.

Why this picture fits: it turns a confusing menu of model names and settings into three independent decisions, each with a clear question: how smart, how much thinking, how much text.

The story → the concept

Dial	Settings	Turn it up when…
Tier	Haiku / Sonnet / Opus, Flash-Lite / Flash / Argon, Luna / Sol / Astra	the task needs judgement or deep knowledge the smaller model lacks
Effort	none / low / medium / high (and higher on some tools)	the task needs multi-step reasoning: a tricky bug, a design, a proof
Tokens	context size, answer length, caching, batch	(turn these down) whenever the extra text isn't changing the answer

Watch it on numbers

Classify 50,000 support tickets a day: 800 prompt tokens and a 20-token label each, at October 2026 list prices.

All dials up: Claude Opus 5.5 at high effort, about 1,000 thinking tokens each. Input 40M tokens × $4 = $160; output 51M × $20 = $1,020. About $1,180 a day.
Tier down to Haiku 5.5, effort off: input 40M × $0.10 = $4; output 1M × $0.50 = $0.50. $4.50 a day.
Tokens dial: it can wait, so use the batch API at half price. About $2.25 a day.
Same job, roughly 500 times cheaper. Your eval set tells you whether the small model labels well enough; if it doesn't, raise one dial and re-test.

The trap it saves you from

Defaulting to "the best model, maximum effort" for everything. It feels safe, but it's slow, expensive, and often no better on simple work.

It still works when…

You build agents and features (Modules 14–19). Model routing, prompt caching, output limits and per-customer budgets are all ways of setting these three dials automatically.

7. Common mistakes

Maximum effort on everythingHigh effort can multiply the cost and the wait of a request several times, for no gain on simple tasks. Raise it for hard problems only.

Forgetting thinking tokens in estimatesA "200-token answer" can come with thousands of hidden thinking tokens, billed as output. Check the usage numbers the API or tool reports.

Comparing vendors' price lists directlyTokenizers differ and quality differs. Compare the cost of finishing the same task to the same standard.

Missing price changesPrices move, and some are introductory: several Gemini prices on this page are listed only until the end of 2026. Put a review date on any cost estimate.

8. Hands-on lab (25 minutes)

Effort experiment. Give a coding agent a genuinely tricky bug at low effort, then again in a fresh session at high effort (/effort in Claude Code, /model in Codex, the Thinking Effort menu in Copilot). Record time, tokens used and whether it fixed the bug.
Tier experiment. Run one simple task (rename a function across files) on the fast tier and the strongest tier. Did the strong model do anything better?
Estimate a feature. Pick an AI feature for your product and use the calculator above for three models. Write down the monthly cost of the cheapest one you'd trust.
Your defaults. Draft a short table: which tier and effort for exploring, implementing, reviewing and bulk jobs.

9. Self-check quiz

How are a model's thinking tokens usually billed?

Thinking is generated text, so it's billed at the output price, even when you don't see it.

Tagging 100,000 product reviews overnight. Best setup?

Simple, high-volume and not urgent: smallest tier, minimal thinking, half-price batch. Check quality with an eval set.

The balanced model keeps getting a hard concurrency bug wrong. What next?

Turn one dial for the task that needs it. Keep cheaper settings for everything else.

Your prompt starts with the same 20,000 tokens of instructions every time. What makes that part cheap?

Prompt caching bills a repeated prefix at 2.5–10% of the input price, so keep the stable part identical and first.

10. Go deeper

Resource	Time	Why
Choosing a model (Anthropic)	10 min	A vendor's own advice on picking a tier, with criteria.
Reasoning models (OpenAI)	15 min	How reasoning effort works and how it's billed.
Gemini thinking (Google)	10 min	Thinking levels and how thinking tokens are counted.
Pricing pages: Claude, Gemini, OpenAI	10 min	The source of every number in the calculator. Re-check them quarterly.
Artificial Analysis	10 min	Independent comparisons of quality, speed and price, for building a shortlist.