Opus vs Sonnet vs Haiku for Agents: Which Model for Which Job in 2026?
Opus vs Sonnet vs Haiku is the first choice every agent builder faces in 2026, and most get it wrong by defaulting to one model for everything. I've run all three in production for six months. Here's the exact pricing math, plus the role-based split that cut my bill by 48%.
📋 Table of Contents
- Why Most Model Choices for Agents Go Wrong - Specs and Pricing at a Glance - Opus 4.8: When the Orchestrator Earns Its Price - Sonnet 4.6: The Production Workhorse - Haiku 4.5: Cheap, Fast, and Underrated - The Mixed-Fleet Pattern I Actually Run - FAQ and Pre-Publish Checklist
🧭 Why Most Model Choices for Agents Go Wrong
Most agent builders I talk to pick a model the way they pick a database: once, at the start, for everything. Then one of two things happens. Either they run Opus on every step and watch the bill triple, or they run Haiku on every step and watch the agent forget its plan halfway through a 40-step loop.
Agents punish both mistakes harder than chat apps do. A chat app makes one call per user message. An agent makes ten, twenty, sometimes a hundred calls per task: planning, tool calls, retries, verification, summarization. Every inefficiency gets multiplied by your loop count. And since output tokens cost 5x the input price on every Claude tier, an agent that narrates every step burns money even when it's doing routine work.
The framing that fixed this for me: stop asking which model my agent should use and start asking which model each role should use. A production agent system has three distinct jobs. Something plans and supervises. Something executes bounded tasks with tools. Something does high-volume grunt work like routing, extraction, and search. Those jobs have wildly different intelligence requirements, and in 2026 Anthropic ships a model priced for each one.
I learned this the expensive way. My first research pipeline ran claude-opus-4-8 end to end, including the step that just decided which folder a document belonged in. That classification step alone was about 30% of my token volume. It needed Haiku. It got Opus. My bill noticed.
💵 Specs and Pricing at a Glance
Here's the 2026 lineup as it actually matters for agent workloads. Prices are per million tokens on the standard API.
Three footnotes change the math more than the sticker prices do. First, the Batch API cuts all of these prices by 50% when you can wait up to an hour for results, which most background agent jobs can. Second, prompt caching serves repeated context at roughly 0.1x the input price, so a well-cached agent loop pays full price mostly on new tokens. Third, the effort parameter (low through max) works on Opus 4.8 and Sonnet 4.6 but not on Haiku 4.5. That matters because effort is how you tune cost inside a tier before you switch tiers.
| Model | API ID | Input $/1M | Output $/1M | Context | Max Output | Best Agent Role |
|---|---|---|---|---|---|---|
| Opus 4.8 | claude-opus-4-8 | $5.00 | $25.00 | 1M tokens | 128K | Orchestrator, long-horizon work |
| Sonnet 4.6 | claude-sonnet-4-6 | $3.00 | $15.00 | 1M tokens | 64K | Production workhorse |
| Haiku 4.5 | claude-haiku-4-5 | $1.00 | $5.00 | 200K tokens | 64K | Subagents, routing, extraction |
🏗️ Opus 4.8: When the Orchestrator Earns Its Price
Opus 4.8 is the model you give a goal, not a script. Its headline strength is long-horizon autonomy: it holds a plan across hours of tool calls, verifies its own work, and finishes overnight runs without a human nudging it back on track. Anthropic's guidance matches what I've seen in practice. Give it the full task specification in one well-specified first turn, set effort to high or xhigh, and let it run.
In my fleet, Opus owns two jobs. It's the orchestrator that decomposes tasks and delegates to cheaper models, and it's the closer for work where a wrong answer costs more than the tokens do: a multi-file refactor, a migration plan, a contract-shaped document review. Over the past six months it has finished runs that Sonnet abandoned midway, and one overnight refactor came back with its own test failures already investigated and explained. That's the behavior you're paying for. The 1M context window and 128K max output also make it the tier that most comfortably holds a large repo plus its own working notes in one session.
Two cost warnings. Output tokens run $25 per million, and Opus narrates more than its siblings by default, so an uncapped Opus agent can spend real money on progress commentary. Add a silence-by-default instruction for routine steps. And don't reflexively run it at max effort. I default to high and reserve xhigh for runs where correctness beats cost, because higher effort means more thinking tokens on every single step of the loop.
When Opus is the wrong choice
Bounded, well-specified tasks. If you can describe the step in a paragraph and verify the output with a script, Sonnet does it for 40% less on both input and output, and you won't notice the difference. My rule: if the step never surprises me, it doesn't get Opus.
⚡ Sonnet 4.6: The Production Workhorse
Sonnet 4.6 is where most production agent tokens should land, and in my fleet it's where roughly 60% of them do. At $3 input and $15 output it costs 40% less than Opus on both sides, it has the same 1M context window and the same effort parameter, and on bounded tasks the quality gap is hard to detect without an eval suite.
The role it owns is the executor. My code-review agent, my summarization workers, and the writer that drafts structured reports all run Sonnet at effort medium or high. These are tasks with clear inputs, clear success criteria, and tool access: exactly the shape where Sonnet's speed advantage compounds. Faster turns mean more loop iterations per hour, which for agents translates directly into throughput.
One tuning note that saved me money: Sonnet 4.6 defaults to high effort. If you swap it in for lighter tasks and keep the default, you'll see more thinking and slower turns than you expected. For classification-adjacent work I set effort low, and for standard tool loops medium is usually the sweet spot.
The start-in-the-middle test
My working heuristic: prototype every new agent on Sonnet first. If it succeeds reliably, test whether Haiku can hold the easy steps. If it fails on planning or long-horizon coherence, promote just the failing role to Opus. Starting in the middle makes every move deliberate, and you only pay for intelligence where an eval says you need it.
🐇 Haiku 4.5: Cheap, Fast, and Underrated
Haiku 4.5 is the model people underestimate because they benchmark it on the wrong jobs. Ask it to plan a refactor and it will disappoint you. Ask it to do one small thing ten thousand times and it becomes the highest-ROI line in your stack.
At $1 input and $5 output it's 80% cheaper than Opus, and it's the fastest of the three by a wide margin. Speed matters more in agent systems than in chat because latency compounds across a loop: a router that answers in under a second keeps the whole pipeline moving.
The roles I give Haiku: intent routing, document classification, entity extraction, first-pass search across files, and read-only explore subagents that go find things and report back. This is the same pattern Claude Code uses internally, where cheap fast subagents sweep a codebase so the expensive main loop only reads conclusions. My triage bot processes every inbound item on Haiku and escalates maybe 15% of them to Sonnet. The other 85% never touch a more expensive model.
Two real constraints. The context window is 200K tokens instead of 1M, so it can't hold a big repo or a very long transcript. And it doesn't support the effort parameter, so there's no dial to turn when a task sits just past its ceiling. When that happens, don't prompt-engineer harder. Move the step to Sonnet.
🧩 The Mixed-Fleet Pattern I Actually Run
Here's the math that convinced me, using my own pipeline's shape. It runs about 2,000 agent tasks a month, and a typical task consumes around 100K input tokens and 10K output tokens across its loop. That's 200M input and 20M output tokens per month.
Run everything on Opus and you pay $1,000 for input plus $500 for output: $1,500 a month. Run everything on Sonnet and it's $600 plus $300: $900 a month, a 40% drop, but with real risk on the hardest planning steps.
The mixed fleet beats both. I route about 10% of tokens to Opus for orchestration and hard closes, 60% to Sonnet for execution, and 30% to Haiku for routing, extraction, and subagent sweeps. Input comes to $100 for Opus, $360 for Sonnet, and $60 for Haiku: $520. Output comes to $50, $180, and $30: $260. Total: $780 a month, a 48% drop from all-Opus. Quality went up on the hard steps at the same time, because Opus now concentrates where it matters instead of being spread everywhere.
Two multipliers stack on top of that. The Batch API halves any job that can wait an hour, and prompt caching means your agent's system prompt and tool definitions bill at roughly a tenth of the input price after the first call. My real bill sits below the naive math for both reasons.
MODEL ASSIGNMENT RULES (copy into your agent config docs) 1. Planning, delegation, or unsupervised runs over 30 minutes: use claude-opus-4-8, effort high 2. Bounded execution with tools and clear success criteria: use claude-sonnet-4-6, effort medium 3. Routing, classification, extraction, read-only search: use claude-haiku-4-5 4. Context above 200K tokens required: Opus or Sonnet only 5. Job tolerates a 1-hour delay: same model, Batch API, 50% off 6. Repeated system prompt and tools across calls: add prompt caching before downgrading models 7. Escalation path: if Haiku fails twice, retry once on Sonnet; if Sonnet fails on planning, promote that step to Opus
❓ Frequently Asked Questions
Can I switch models mid-conversation to save money?
Not cheaply. Prompt caches are model-scoped, so switching models mid-session invalidates the cache and reprocesses the whole history at full input price. The better pattern is spawning a subagent on the cheaper model for the sub-task while the main loop stays on one model. That gets you Haiku prices without breaking the cache.
Is Haiku 4.5 smart enough to run a whole agent on its own?
For narrow agents, yes. A support triage bot or a data-extraction pipeline with tight prompts runs fine on Haiku alone. It struggles with multi-step planning and recovery from unexpected tool failures, and its 200K context window rules out long sessions. Prototype on Sonnet, then downgrade and let your evals make the call.
Where does Claude Fable 5 fit into this comparison?
Fable 5 sits above Opus at $10 input and $50 output per million tokens. It's built for the hardest long-horizon work, the runs you'd otherwise have to babysit. Most agent fleets don't need it as a default. I treat it as a fourth tier reserved for the single hardest role, the same way Opus concentrates above Sonnet.
Do effort levels replace model switching?
They complement it. Effort (low through max on Opus 4.8 and Sonnet 4.6) tunes cost inside a tier, and it's the first dial to try when a model slightly overshoots or undershoots a task. Switching tiers is the bigger lever. My order of operations: tune effort first, add caching, then change models.
🏁 Final Thoughts
Six months of running mixed fleets taught me one thing: model choice for agents is a routing problem, and teams that treat it that way ship cheaper and better systems at the same time. Opus 4.8 plans and closes. Sonnet 4.6 executes. Haiku 4.5 handles volume. Priced at $5/$25, $3/$15, and $1/$5 per million tokens, the tiers are spaced almost perfectly for that division of labor, and in my pipeline the split cut costs by 48% while improving results on the hardest steps. Start on Sonnet, measure, then promote and demote roles based on evals rather than vibes. If this breakdown helped, subscribe to Agents at Work for more operator-level posts on running AI agents in production, and drop a comment with your own fleet split. I read every one, and reader numbers keep making these comparisons sharper.
Last updated: September 04, 2026 · Keyword: Opus vs Sonnet vs Haiku · Agents at Work
Comments
Post a Comment