Five models, five jobs: picking an API after September's price cuts

Most small teams don't need to pick one. They need to match each job to the cheapest model that does it well enough. Here's how we'd think about it.

The options

GPT-6 Luna is the new floor for high-volume, low-judgement work: extraction, tagging, routing, summaries. At these rates the model is rarely your biggest cost. Logging and retries are.

Gemini 3.8 Flash is pitched at coding and agent work at a low price, but that price doubles on 1 January. Cost it at the 2027 rate before you build on it.

GPT-6 Sol and Claude Sonnet 5 sit level at $2 and $10, which makes that pair the default comparison for everyday product features: drafting, support replies, analysis and most agent steps. Run both on your own examples. Published benchmarks rarely match your prompts.

Claude Opus 5.5 is for long work that's expensive to get wrong: multi-hour agent runs, large refactors, anything where a failed attempt costs more than the tokens. Anthropic's pitch is that it finishes more of that work per dollar than Opus 5 did.

What it costs on your worst week

Prices per million tokens are hard to feel, so here's one busy week for a small product team: 20,000 calls, each about 3,000 tokens in and 800 out. That's 60 million input tokens and 16 million output tokens (FER calculations from the list prices above):

• GPT-6 Luna: $6 plus $8, so $14 for the week.
• Gemini 3.8 Flash: $45 plus $60, so $105 now, and $210 from January.
• GPT-6 Sol or Claude Sonnet 5: $120 plus $160, so $280.
• Claude Opus 5.5: $240 plus $320, so $560.

That's a forty-fold spread for the same week of work. The expensive mistake isn't using Opus for a hard job. It's running every trivial job through it all month.

One warning about these sums: they assume every model uses the same number of tokens for the same job, and they don't. Some models write longer answers, think for longer or take more steps as agents, and a cheaper model that needs a second attempt costs you twice. Use the list prices to shortlist, then measure what a finished job actually costs on your own examples.

How to test in an afternoon

1. Pick one feature and pull 50 real inputs from your logs.
2. Write down what a good answer looks like for each, or keep the answer your current model gave if it was good.
3. Run all 50 through two or three candidate models.
4. Score each answer as good or not good. Don't overthink the scale.
5. Divide each model's total cost by its number of good answers. That's your real price.

What we'd pick

• Routing, tagging, extraction and summaries: Luna. Test it first; it's the cheapest experiment you'll run all year.
• Everyday product features and support drafts: Sol or Sonnet 5. Run 50 real examples through both and keep the better one.
• Cheap coding and agent steps: Gemini 3.8 Flash, if the numbers still work at the January price.
• Long, high-stakes work: Opus 5.5, where one good attempt beats three cheap ones.
• If you only do one thing: put the model name in config, not in code, so switching is a one-line change.

Our house rule is to route by job, not by vendor. Keep a small set of real examples for each feature, and re-run them whenever the price sheet moves, which this year means monthly.

What we'd skip: switching everything to the newest model on launch day, and signing a long commitment to one provider while prices are falling this fast.

Disclosure: this publication's research agent runs on Claude Opus 5.5.