Understand · Step 4 of 14

Which AI for what

Models come in capability tiers. Picking the right one is mostly matching the tier to the job — not always reaching for the biggest.

The tiers

Every provider ships a lineup along the same axis: raw capability traded against speed and cost. OpenAI and Google have the same ladder under their own names. Think in tiers, not product names — the names change, the tiers don't.

Top tier

e.g. Claude Fable 5.2 · $8 / $40 per million tokens in / out

The hardest reasoning and long, autonomous runs that go for hours.

The most capable, and priced above everything else. For when the flagship is not enough.

Flagship tier

e.g. Claude Opus 5.5 · $4 / $20 per million tokens in / out

Large refactors, subtle bugs, agent loops, novel problems.

Worth it when being wrong is expensive or the work has many steps.

Balanced tier

e.g. Claude Sonnet 5.5 · $2 / $10 per million tokens in / out

Everyday coding, writing, analysis, most chat and app traffic.

The default. Strong quality at half the flagship's price, and faster.

Fast tier

e.g. Claude Haiku 5.5 · $0.10 / $0.50 per million tokens in / out

Classification, extraction, routing, high-volume simple calls.

Cheapest and fastest by a wide margin. Use it anywhere the task is well-defined.

Look at the spread: the top tier costs 80 times what the fast tier does. The gap between tiers has grown, not shrunk — which makes the choice matter more than it used to.

Default to Balanced. Start there, drop to Fast when the task is narrow and repetitive, climb to Flagship when a wrong answer is costly or the reasoning is genuinely hard.

The second dial: effort

Current models think before they answer, and you choose how much. That setting — usually called effort — trades thoroughness against time and tokens within one model. It has largely replaced the old habit of telling a model to "think step by step."

  • Low for chat, lookups, and simple transformations.
  • Medium to high for everyday coding and analysis.
  • The top settings only where you have seen them make a difference — they cost real time and money.

Before building a pipeline that hands easy work to a cheap model and hard work to an expensive one, try the simpler thing: one capable model at lower effort. It is often as good, and it is one less moving part.

By job

JobPickWhy
Work for hours on a hard, open-ended problemTopLong autonomous runs are where the extra capability shows — and where a weaker model drifts.
Refactor a large codebase / debug something subtleFlagshipDeep multi-file reasoning is exactly where this tier earns its cost.
Power an autonomous agent loopFlagshipTool selection and recovery from mistakes compound — quality pays off.
Build a feature in an existing appBalancedStrong coding without flagship latency; escalate only if it stalls.
Draft and edit long-form writingBalancedGood voice and structure; flagship only for high-stakes pieces.
Summarize, classify, or tag at volumeFastThe task is narrow and repeated — pay for speed, not genius.
Extract fields from documents into JSONFastSchema-bound work. Use structured output and validate in code.
Route a request to the right handlerFastA tiny classification call in front of a bigger pipeline.
Do the reading for a bigger agent (sub-agents)FastSearching and skimming are cheap work; the lead agent keeps the judgment.

What will it cost? Work it out

Cost is tokens in × the input price, plus tokens out × the output price. Say a support tool summarizes 2,000 tickets a day; each ticket is about 1,500 tokens and each summary about 200.

Per day:  2,000 × 1,500 = 3.0M tokens in
          2,000 ×   200 = 0.4M tokens out

Fast      3.0 × $0.10 + 0.4 × $0.50 = $0.50 a day   (~$15 a month)
Balanced  3.0 × $2    + 0.4 × $10   = $10 a day     (~$300 a month)
Flagship  3.0 × $4    + 0.4 × $20   = $20 a day     (~$600 a month)

Same job, a forty-fold difference. Whether the cheap one is good enough is not something to guess — it is something to measure, with a small test set. That is what Evals is for. (Thinking counts as output tokens, so higher effort raises the output side.)

Beyond the tier

  • Context window — a million tokens is now common, enough for a whole codebase or a stack of long documents. That it fits does not mean you should send it: you pay for every token on every call.
  • Tool use & agents — if it will run an agent loop, prefer a model explicitly strong at tool use.
  • Latency — user-facing and interactive? A faster tier that feels instant often beats a smarter one that lags.
  • Cost at scale — a price gap is irrelevant at 100 calls and decisive at 10 million. Estimate real volume, and judge cost per finished task: a cheap call that needs three retries is not cheap.
  • Discounts hiding in the API — caching a prompt prefix you send repeatedly cuts its cost by about 90%, and batch jobs that can wait run at half price. Use both before you downgrade the model.
Model lineups change every few months. Names and prices here were checked in November 2026; re-check them before committing — but the tier logic above keeps holding.