Start here · Getting going
Pick the cheapest model for the job
Written October 28, 2026 · Edited November 7, 2026
For anyone about to pay × choosing between models × the vendors' own pricing pages, ending with the cheapest model that passes a fixed check on the real job — and a written reason to step up, if stepping up is ever needed.
Before you start
You need the job written down in one sentence, and a way to tell good output from bad that does not depend on your mood that day: a checklist, an expected answer, a test. Model prices are per million tokens, split into input and output. On the Claude API pricing page, the current ladder runs from Haiku 5.5 at $0.10 per million input tokens and $0.50 per million output tokens, through Sonnet 5.5 at $2 and $10, Opus 5.5 at $4 and $20, to Fable 5.1 at $10 and $50. On the OpenAI pricing page, the ladder runs from Luna at $0.10 and $0.50, through Terra at $1 and $5 and Sol at $2 and $10, to Astra at $10 and $50, with a Codex coding model at $1.75 and $14. The gap between the bottom and the top of each ladder is a hundredfold on input. Most jobs do not need the top.
Two discounts change the answer more than the model choice does. Batch processing on the Claude API pricing page costs half the standard input and output rates, and prompt caching charges a cache read at a tenth of the input rate on most models — a twentieth on Opus 5.5 and Sonnet 5.5, and a fortieth on Fable 5.1. Writing to the cache costs extra: 1.25 times the input rate for a cache that lasts five minutes, twice the input rate for one that lasts an hour — so caching pays for itself after one repeated read on the five-minute cache, or two on the one-hour cache. A repeated job with a long fixed context is often cheaper on a mid-tier model with caching than on the cheapest model without it. The token cost calculator on this site turns these rates into a per-job figure.
Subscriptions and API use are different purchases. A Claude Pro subscription at $20 a month when billed monthly ($17 a month when billed annually) includes Claude Code and draws on a shared usage pool; the API bills per token with no pool. Steady daily chat use usually belongs on a subscription; irregular, repeated, or automated jobs usually belong on the API. The cost guide covers the subscription side.
What "done" looks like
At the end of one sitting you have run the real job on the cheapest model, checked the output against your fixed bar, and either kept the cheap model or stepped up exactly one tier with the failure written down. You also know the per-job cost at the chosen model, and whether batching or caching would cut it further. No model was picked because it is the newest or the most talked about.
Steps
- Name the job and the check. Write one sentence for the job — "summarise this inbox thread into three actions," "write a test for this function" — and write the check before you run anything: the output must name the three actions with owners, or the test must fail on the old code and pass on the new. A check written after seeing the output is a description of the output, not a test of it.
- Start at the bottom of the ladder. For short, repeated, latency-sensitive work, start with Haiku 5.5 or Luna. For a first attempt at anything else, start one rung up — Sonnet 5.5 or Sol — only if the job needs multi-step reasoning the cheapest tier has already failed at before. Starting at the top "to be safe" is the most expensive habit in this playbook, and safety is what the check in step 1 is for.
- Run the real job, not a demo of it. Use the actual input: the real thread, the real function, the real document. A model that handles a toy example and fails on the real input has told you nothing except that the toy was easy. Run it three times on the same input if the job matters: a model that passes once in three is not the cheapest model that works.
- Step up one tier, only on a named failure. If the output fails the check, write down exactly how it failed — missed a requirement, invented a fact, lost the thread halfway — and move up one tier. A vague "it felt weak" is not a failure and does not earn a step up. Repeat the same check at the new tier. Most jobs settle at the second tier; a job that needs the top tier should be able to name the failure that each lower tier produced.
- Price the job at the tier that passed. Count the input and output tokens for one run — the API response reports both — and price them at the vendor's rates with the token cost calculator. Multiply by how often the job runs. A job that costs 40 cents a run and runs twice a day costs about $24 a month; a job that costs 2 cents a run costs about $1.20. The monthly figure is the number that decides between a subscription and the API, not the per-run figure.
- Apply batching and caching before buying a bigger model. If the job repeats with the same long context, cache the context: repeated reads cost a tenth or less of first reads. If the job can wait — nightly summaries, bulk classification — batch it for half price on the Claude API. Re-run the check after each change: a discount that changes the output is not a discount, it is a different job.
- Re-check the price on the vendor's page on the day you pay. Prices move, and promotional rates end: on the OpenAI pricing page, gpt-6.1-sol costs $2 per million input tokens and $10 per million output tokens, with no promotional note on its row — while a different model, GPT-5.6 Sol, costs $4 and $20 on promotional pricing available until November 30, 2026. Enter the model ID, not just the name "Sol", when you price a job or enter it in the calculator: the two are different models at different prices, and the November 30 date belongs to GPT-5.6 Sol, not to the $2 rate. The rates in this playbook are the ones on the vendors' pages at the time of writing, linked inline above; the page you pay from is the one that counts. If the ladder has moved, re-run step 5 at the new rates before committing to a tier. The gpt-6.1-sol tiers guide covers that model in more depth.
Check the agent's work
- Check that the job and its pass bar were written before the first run, not after the first output.
- Check that each tier that was passed over has a named failure attached to it, not a feeling.
- Check the token counts in the API response, not an estimate from word counts. Word-count estimates understate code and overstate prose.
- Check that the monthly figure multiplies the per-run cost by the real run rate, including retries and re-runs.
- Check that caching and batching were considered before a bigger model was bought. A discount on the current tier beats a step up in most repeated jobs.
What can go wrong
- Starting at the top. The strongest model passes every check, including checks the cheapest model would also have passed. You learn nothing and pay a hundred times more for the lesson.
- Testing on a toy input. The model passes the demo and fails the real job, and the failure is discovered after the tier is chosen and the work is built around it.
- One run, one verdict. Model output varies run to run. A single pass proves little; three runs on the same input is the minimum for a job that matters.
- Forgetting the long-prompt tier. Haiku 5.5 charges five times more for prompts over 100,000 tokens — $0.50 and $2.50 per million instead of $0.10 and $0.50. A job with a very long prompt can be cheaper on Sonnet than on Haiku. Price the actual prompt length, not the model's headline rate.
- Comparing a subscription with an API bill as if they were the same thing. A subscription buys a usage pool; the API buys tokens. The comparison that matters is monthly cost at your real run rate, on each side, with the pool's limits stated.
Limits
- This playbook picks the cheapest model for one defined job. It does not pick a stack, and it does not say which vendor to build on; the stack picker covers that choice.
- Prices here are list prices from the vendors' pricing pages. Negotiated rates, cloud-marketplace billing, and regional uplifts change them; the OpenAI page notes a 10% uplift for some regional endpoints.
- Use model IDs, not bare names, when you price a job: "Sol" on its own can mean gpt-6.1-sol at $2 and $10 per million tokens, or GPT-5.6 Sol at $4 and $20 on promotional pricing. The OpenAI pricing page lists both.
- A model that passes the check today can still fail on next month's inputs. Re-run the check when the input changes shape, not just when the price changes.
Related playbooks
- Check Copilot cloud sandbox billing first
- Run MiniMax M3.1 Flash inside Claude Code
- What an agent costs, in plain figures
- Anthropic's model-protection rule is now in force
Sources
Sources: Anthropic API pricing docs, OpenAI pricing, Claude pricing.
Back to: Start here · Also: What an agent costs, in plain figures · Token cost calculator