Claude model selection for AI agents: which 5.5 model runs which step

Most AI agent bills we look at have the same cause. One model, usually the most capable one available, handles every step. It reads the email, sorts it, pulls out the fields, checks them, writes the reply and drafts the summary. Each of those steps is billed at the top rate, and when the monthly invoice comes in, people decide that AI is too expensive.

The model usually isn't the problem. The architecture is. Anthropic released the whole Claude 5.5 family in three weeks, and it makes a better default easy to see: give each step of the workflow the cheapest model that can do it reliably, and save the expensive one for steps that need real judgment. This post covers Claude model selection for AI agents in practice. It includes a routing worksheet and a worked example priced at published list rates.

An agent is rarely one call to a model. A typical workflow chains together intake, classification, extraction, validation, tool calls, exception handling and a final write-back. Most of those steps are narrow and repetitive. Very few need open-ended reasoning.

Run all of them on a top-tier model and you pay premium output rates for work like labelling an email as an invoice. Agents also re-send the same large context on every turn: system prompts, schemas, tool definitions and conversation history. Unless that context is cached, you pay full input price for it every time.

So the cost problem has two parts. The wrong tier is doing most of the work, and repeated context is being billed as new input.

Between 22 September and 7 October 2026, Anthropic shipped three models and one price cut:

• 22 Sep: Claude Opus 5.5 (opens in a new tab) at $4 input and $20 output per million tokens, with cache reads at $0.20 per million. Anthropic says it costs about 40% less than Opus 5 to run on typical workloads and generates output more than 30% faster.
• 28 Sep: Claude Sonnet 5.5 (opens in a new tab) at $2 input and $10 output per million. That is the same list price as Sonnet 5, but Anthropic says it typically needs far fewer tokens and costs up to 30% less for most work.
• 7 Oct: Claude Haiku 5.5 (opens in a new tab) from $0.10 input and $0.50 output per million (for prompts up to 100k tokens). Anthropic puts it at about 75% cheaper to run than Haiku 4.5 on average.
• 7 Oct: Sonnet 5.5 cache reads were halved to $0.10 per million (opens in a new tab). Anthropic says this cuts Sonnet 5.5's cost on most agentic tasks by around 20%.

All three models are available on AWS, Google Cloud and Microsoft Azure, according to Anthropic's Opus (opens in a new tab) and Haiku (opens in a new tab) announcements. That means you can usually tier models without moving cloud providers.

Anthropic is unusually direct about where each model fits.

Opus 5.5: judgment. Anthropic positions Opus for complex work that needs careful judgment. It says Opus 5.5 remains clearly stronger at complex, open-ended work requiring sustained judgment (opens in a new tab). It also leads Anthropic's benchmarks in agentic coding, computer use and knowledge work. Anthropic itself cautions that benchmark margins are a less reliable guide (opens in a new tab) to real-world differences, so test on your own tasks.

Sonnet 5.5: well-scoped everyday work. Anthropic describes Sonnet as a faster, lower-cost complement to Opus. It says Sonnet is strongest at well-scoped everyday tasks (opens in a new tab), bug fixing, and polished documents, slides and spreadsheets. On Anthropic's figures it scores 70.6% on Terminal-Bench 4.0, against 10.3% for Sonnet 5, and lands two points below Opus 5.5 on GDPval-AA.

Haiku 5.5: volume and subagents. Haiku is designed for high-volume, cost-sensitive tasks (opens in a new tab) such as summaries, compactions, database queries and classification. It is meant to work as a subagent alongside Opus and Sonnet, and suits live customer support and browser use. Anthropic says Sonnet and Opus remain the better choices for complex agentic coding.

In short: Haiku handles volume, Sonnet handles the defined work, and Opus is reserved for the hard calls.

When Anthropic announced Opus 5.5, it noted that cache reads make up the majority of agentic and coding work costs (opens in a new tab). That matches how agents behave. The same instructions, schemas and tool definitions go back to the model on every turn.

Cached input costs a small fraction of fresh input:

So design prompts with caching in mind. Put stable material at the front: the system prompt, output schema, chart of accounts and tool definitions. Put the variable material (this invoice, this ticket) at the end.

Before choosing a model, write the workflow down as separate steps. For each step, answer five questions:

1. Is the task narrow and repeatable? Examples are classifying, summarising, extracting a known field or running a lookup. If yes, start with Haiku.
2. Does it produce structured, well-defined output that a person would check quickly? Examples are mapping to a schema, drafting a standard reply or fixing a known bug. If yes, start with Sonnet.
3. Does it need judgment on ambiguous or novel inputs, or could a mistake be hard to reverse? If yes, use Opus, or escalate to it.
4. How much of the prompt is stable across calls? If most of it is, structure it for caching.
5. What is the volume? Steps that run thousands of times a day deserve the most attention to cost. Steps that run rarely can afford a stronger model.

Then fill in a simple table for each step: name, tier, average input tokens, share cached, output tokens, and how often it runs. That table becomes your cost model, and you should rerun it every time a price changes.

Take an agent that reads supplier invoices and prepares entries for an accounting system, similar to our invoice-to-Tally automation. The token counts below are illustrative assumptions, not measurements. Prices are the list rates above. We have left out cache-write charges, taxes and retries because the sources here don't cover them.

Here is the step 2 arithmetic: 2,000 fresh tokens × $2/M = $0.004, plus 4,000 cached × $0.10/M = $0.0004, plus 800 output × $10/M = $0.008, for a total of $0.0124.

With the Opus step spread across all invoices ($0.052 × 5% = $0.0026), the tiered agent costs about $0.025 per invoice, or roughly $253 per 10,000 invoices.

Now run the same steps and token counts entirely on Opus 5.5:

• No caching: about $0.1125 per invoice, or $1,125 per 10,000.
• With the same caching: about $0.065 per invoice, or $650 per 10,000.

Caching alone cuts the all-Opus bill by over 40%. Tiering and caching together bring it to under a quarter of the starting figure. Your own numbers will differ, so measure real token counts in a pilot before you commit. The pattern holds, though: most of the saving comes from moving high-volume steps off the top tier.

The same approach works for RFQ-to-PO automation, where parsing and matching are high-volume and supplier exceptions need judgment. It also works for a retail shopping concierge, where Haiku's fit for live customer support makes it a natural first responder.

Cheap routing only works if the agent knows when to hand a case up. Set explicit escalation triggers:

• Low confidence or failed validation. Totals don't reconcile, a required field is missing, or the schema check fails twice.
• Novel inputs. An unknown supplier, an unfamiliar document layout or a language you haven't seen before.
• High-consequence actions. Anything that posts, pays, deletes or emails a customer should get stronger review and, in most SMEs, a human approval step.
• Value thresholds. Above a set amount, always escalate.

On safety, Anthropic says Opus 5.5 is much less likely than recent models to take hard-to-reverse actions (opens in a new tab) or act outside the boundaries it was given. It also says Opus 5.5 is more resistant than Opus 5 to prompt injection. That is useful, but it doesn't replace good design. Invoices, emails and web pages come from outside parties and can contain instructions aimed at your agent. So:

• Treat all document and web content as data, never as instructions.
• Give each step only the tools it needs. An extraction step doesn't need write access to your ledger.
• Validate model output against a schema before any tool runs on it.
• Log every escalation and every action so you can audit and tune the routing.

At Softpiper we design agents step by step, not model-first. Our AI agents and automation work starts with the routing worksheet above. We map the workflow, assign tiers, structure prompts for caching, and set escalation and approval rules before going live. We're part of the Claude Partner Network as a Select Services Partner, and we build with Claude and Gemini, choosing whichever fits each step.

When an agent is part of a larger product, our AI product engineering team handles evaluation and cost monitoring. Our Cloud and DevOps on Google Cloud practice handles deployment, which matters because all three 5.5 models are available there. For an example of a product we build and run ourselves, see LuxeLens AI Studio.

• Workflow broken into named steps, each with a tier
• Stable prompt content placed first for caching
• Token counts measured in a pilot, not guessed
• Escalation triggers and value thresholds defined
• Human approval on irreversible actions
• Tools scoped per step, with outputs schema-validated
• Cost model rerun at every price change

If your agent bill is growing faster than its usefulness, talk to Softpiper. We'll go through your workflow with you and show where each step should run.

• Claude Opus 5.5 (Anthropic announcement) (opens in a new tab)
• Claude Sonnet 5.5 (Anthropic announcement) (opens in a new tab)
• Claude Haiku 5.5 (Anthropic announcement) (opens in a new tab)