Model tiering is the single most impactful cost lever an architect has in 2026. Route triage and tool-call agents to cheap fast models — GPT-4o-mini, Claude Haiku 4, Llama 4 8B served on Groq or Cerebras. Route reasoning agents to capable models — Claude Sonnet 4.5, GPT-4o, Gemini 2.5 Pro, with extended thinking enabled when the task demands it. Done correctly, this gets you 60-85% cost reduction per resolution against the naive "use Sonnet 4.5 for everything" baseline, with the same or better reliability. Done badly, you route too aggressively to the cheap tier and reliability collapses; or you route nothing to the cheap tier and you wonder why the CFO is asking about your AI spend. This lesson is the architect's tiering playbook: the three tiers, the routing rules, the named numbers, the cost-per-resolution math, and the five failure modes. The cost-per-resolution lift is real. The discipline to measure it is what separates production-ready architects from prompt-pusher consultants.

Why Tiering Is the 2026 Cost Lever

In 2024, agent cost optimization was prompt-shortening and caching. In 2025, it was retrieval optimization. In 2026, the dominant cost lever has shifted to model tiering across agents. Three reasons for the shift.

First, the model price-performance curve has steepened. Claude Haiku 4 (released October 2025) matches Claude 3.5 Sonnet on most benchmarks at one-twentieth the cost. GPT-4o-mini does similar work to GPT-4 Turbo at one-fifteenth the cost. The cheap tier is no longer "the dumb fallback" — it is genuinely capable for triage, classification, and tool-call decisions. The capability gap that justified always-using-the-expensive-model has narrowed dramatically.

Second, multi-agent architectures (orchestrator-worker, hierarchical, even single agents with sub-tasks) create natural seams between work types. Routing a triage decision is structurally different from synthesizing a multi-source answer. Each seam is a tiering opportunity that did not exist when everything ran through one prompt.

Third, the spend has grown. The companies running agents at scale in 2026 are spending six and seven figures monthly on LLM API costs. A 60% cost reduction on a $400K monthly bill is $240K saved — enough to fund the architect's salary and then some. The CFO conversation has moved from "what is this spend?" to "show me the unit economics," and tiering is the dominant lever in the unit-economics conversation.

Model tiering is the cost lever that pays for the architect role. If you cannot show 60%+ cost reduction from your tiering design vs the naive single-model baseline, you have not yet earned the title.

The Three Tiers

The 2026 tiering model has three named tiers. The names are not standardized across the industry but the concept is.

Tier 1: Cheap-Fast (Triage and Tool-Call)

What it does: Classifies intent. Routes between specialists. Decides which tool to call. Extracts structured data from input. Generates short summaries. Checks if a step is needed.

Models: Claude Haiku 4, GPT-4o-mini, Gemini 2.5 Flash, Llama 4 8B (served on Groq or Cerebras for ultra-low latency).

Profile: Latency under 500ms median, often under 200ms with Groq/Cerebras. Cost $0.0001-$0.0006 per call at typical token counts. Reliability acceptable for classification and routing tasks. Not acceptable for novel reasoning or long-context synthesis.

What 60-75% of your agent traffic should run on.

Tier 2: Capable (Reasoning and Synthesis)

What it does: Synthesizes multi-source information. Reasons over retrieved documents. Drafts substantive responses. Handles novel cases. Performs the actual customer-facing work.

Models: Claude Sonnet 4.5, GPT-4o (or GPT-5 default mode), Gemini 2.5 Pro.

Profile: Latency 1.2-2.5s median for a typical agent turn. Cost $0.02-$0.08 per call at typical token counts (4K input, 1K output). Reliability strong for the work you ship to users.

What 20-35% of your agent traffic should run on.

Tier 3: Frontier (Hard Reasoning and Long Context)

What it does: Multi-step reasoning that requires extended thinking. Long-document analysis (50K+ tokens). High-stakes decisions where extra reliability is worth the cost. Eval generation and judge tasks.

Models: Claude Opus 4.5 with extended thinking, GPT-5 Pro with reasoning, Gemini 2.5 Ultra.

Profile: Latency 4-15s median (extended thinking adds time). Cost $0.10-$0.80 per call. Reliability the strongest available, with the trade-off of cost and latency.

What 1-5% of your agent traffic should run on.

The Routing Rules That Actually Work

Tiering is a routing problem. The orchestrator (or the single agent's intent classification) decides which tier handles the work. Five routing rules that work in production.

Rule 1: Tool-call decisions go to Tier 1

The agent's "should I call a tool? which one?" decision is a classification task. Tier 1 models do this reliably with the right prompt and tool descriptions. The 2026 production pattern: the orchestrator passes the user input + tool list to a Haiku 4 or GPT-4o-mini agent, which produces a structured "tool: search_kb, args: {...}, confidence: 0.92" output. The expensive Tier 2 model is only called when the tool result needs synthesis.

Production data: tool-call agents fine-tuned on Llama 4 8B (covered in Level 3) hit 96-98% tool-selection accuracy at ~$0.00005 per call. The Sonnet 4.5 baseline hits 97-99% at ~$0.04 per call. 800x cost reduction for ~1 percentage point of accuracy. The trade-off favors Tier 1 in virtually all production deployments.

Rule 2: Triage and routing go to Tier 1

"Which specialist should handle this?" "Is this a billing or support question?" "Does this query need retrieval?" All classification problems. All Tier 1.

The orchestrator agent from Lesson 1 of this chapter runs on Tier 1. The 200-600ms latency overhead the lesson cited assumes a Tier 1 orchestrator. If you put the orchestrator on Tier 2, you double the orchestration latency for no quality gain.

Rule 3: Structured extraction goes to Tier 1

"Extract the customer ID, the order number, and the issue type from this support email." Structured-output tasks with clear schemas run well on Tier 1. GPT-4o-mini with JSON-mode constraints hits 99%+ schema compliance at 1/15 the cost of GPT-4o.

Rule 4: Synthesis and novel reasoning go to Tier 2

"Given the customer's history, the policy documents, and the recent ticket — what is the best response?" This is the work Tier 2 was designed for. The synthesis specialist in your multi-agent design, or the reasoning step in your single-agent design, runs on Tier 2.

Rule 5: Long context and hard reasoning escalate to Tier 3

Two specific triggers for Tier 3. First, context size: when the input exceeds 50K tokens (large document analysis, long conversation histories), the frontier models' extended-context handling outperforms Tier 2 enough to justify the cost. Second, when Tier 2 is failing — the eval shows your agent's accuracy collapsing on a specific case type — try Tier 3 on those cases before redesigning. Sometimes the right answer is "this is hard, and the hard-reasoning tier handles it."

Critically: Tier 3 is the exception, not the default. The architect who routes everything to Tier 3 for "reliability" is rebuilding the naive single-model design with a more expensive model. Use Tier 3 for the cases that need it.

The Cost-Per-Resolution Math

The honest measurement. Cost-per-resolution is the dollars your agent spends per task it successfully completes. Not per LLM call. Not per user interaction. Per resolved task. It is the architectural KPI.

The naive baseline

A typical mid-complexity B2B agent task — handle a customer support query end-to-end — looks like:

• 1 intent classification call.
• 1-2 tool calls (search KB, lookup customer).
• 1 synthesis call to generate the response.
• 1 validation/refusal-check call.
• Total: ~5 LLM calls per resolution.

If everything runs on Claude Sonnet 4.5: 5 × $0.04 = $0.20 per resolution.

At 10,000 resolutions per day: $2,000/day = $60,000/month = $720,000/year.

The tiered architecture

Same task with three-tier routing:

• Intent classification on Tier 1 (Haiku 4): $0.0006.
• Tool calls on Tier 1 (Haiku 4 or fine-tuned Llama 4 8B): 2 × $0.0006 = $0.0012.
• Synthesis on Tier 2 (Sonnet 4.5): $0.04.
• Validation/refusal check on Tier 1 (Haiku 4): $0.0006.
• Total: ~$0.043 per resolution.

That is a 78% cost reduction vs the naive baseline ($0.20 → $0.043). At 10,000 resolutions per day: $430/day = $12,900/month = $154,800/year.

Annual savings: $720,000 - $154,800 = $565,200.

The frontier-escalation case

Add a 5% Tier 3 escalation for hard cases:

• 95% of resolutions on the tiered architecture: 9,500 × $0.043 = $408.50/day.
• 5% on Tier 3 (Opus 4.5 with extended thinking, full pipeline): 500 × $0.40 = $200/day.
• Total: ~$608.50/day = $18,255/month = $219,060/year.

Still 70% cheaper than the naive baseline. The Tier 3 escalation buys you better reliability on the hard cases without sacrificing the overall savings.

78% cost reduction with the same or better reliability. This is the architect's lever. If you cannot reproduce this math for your domain, you have not yet tiered correctly.

The Five Failure Modes

Failure 1: Over-routing to Tier 1

The architect, excited about cost savings, routes synthesis work to Tier 1. The agent's responses become noticeably worse — shallower reasoning, more factual errors, less nuanced tone. The eval set catches it; the user-facing CSAT score catches it; the support tickets pile up. Fix: tier-by-task-type, not tier-by-cost. Tier 1 is for triage, tool-call, classification, extraction. Anything that synthesizes user-facing content goes to Tier 2.

Failure 2: Under-routing to Tier 1

The architect, worried about reliability, routes everything to Tier 2. Costs match the naive baseline. The tiering design technically exists on paper but is not actually saving anything. Fix: audit the orchestrator's routing decisions. Count what percentage of calls actually hit Tier 1. If it is below 50%, the routing rules are not aggressive enough.

Failure 3: Tier 1 quality regression after a model update

The cheap tier model receives an update. Haiku 4 ships a new checkpoint. The agent's tier-1 classification accuracy drops 3 points. Routing accuracy collapses. The eval set should catch this (regression detection from Level 3 chapter 3.6) but only if the eval slices Tier 1 separately. Fix: per-tier eval slices, weekly regression detection, automated rollback to the previous Tier 1 checkpoint if accuracy drops.

Failure 4: Latency budgets ignored

The tiered architecture is cheaper but slower because the orchestrator adds 200-400ms before the work begins. For voice agents (where p95 latency budget is often under 2 seconds), the tiering cost savings come at the price of breaking the conversational experience. Fix: latency-budget the architecture before designing it. For voice, often the answer is "less tiering, more capable model end-to-end."

Failure 5: Tier 3 sprawl

"This case is hard, escalate to Tier 3" becomes "anything ambiguous, escalate to Tier 3" becomes "20% of traffic on Tier 3." The cost-per-resolution doubles. Fix: cap Tier 3 routing at 5-10% of traffic. Build a hard-case eval slice. Anything Tier 2 handles with >85% accuracy stays on Tier 2.

Model-Specific Routing Recommendations

The 2026 routing recommendations by use case. These are the named numbers and named models. They will evolve, but they are accurate as of May 2026.

Customer support agent

• Orchestrator: Claude Haiku 4.
• Triage specialist: Claude Haiku 4 or fine-tuned Llama 4 8B on Groq.
• Knowledge-base specialist: Claude Sonnet 4.5 with retrieval.
• Refund specialist (high-stakes): Claude Sonnet 4.5; Claude Opus 4.5 for refunds >$500.
• Validation/refusal check: Claude Haiku 4.
• Expected per-resolution cost: $0.03-$0.08.

Internal IT support agent

• Orchestrator: GPT-4o-mini.
• Password-reset / how-to specialist: GPT-4o-mini.
• Troubleshooting specialist: GPT-4o (or Claude Sonnet 4.5).
• Escalation-to-human classifier: GPT-4o-mini.
• Expected per-resolution cost: $0.02-$0.05.

Sales triage agent

• Lead qualification (BANT or similar framework): Claude Haiku 4.
• Email drafting: Claude Sonnet 4.5 (synthesis matters; tone matters).
• Calendar-call tool: deterministic, no LLM.
• Enrichment + scoring: Llama 4 8B on Groq for the classification, Sonnet 4.5 for the narrative.
• Expected per-resolution cost: $0.05-$0.15.

Research and synthesis agent (analyst replacement)

• Query routing: Claude Haiku 4.
• Retrieval and chunking: deterministic + small embeddings model.
• Synthesis: Claude Sonnet 4.5 for routine, Claude Opus 4.5 with extended thinking for long documents or novel synthesis.
• Citation verification: Claude Haiku 4.
• Expected per-resolution cost: $0.15-$0.60 (synthesis is the cost concentration).

Coding agent

• Intent classification: Claude Haiku 4 or GPT-4o-mini.
• Code generation: Claude Sonnet 4.5 (or Sonnet 4.5 with extended thinking for complex tasks).
• Code review: GPT-5 default mode or Claude Sonnet 4.5.
• Multi-file refactoring: Claude Opus 4.5 with extended thinking.
• Expected per-resolution cost: $0.10-$2.00 (high variance based on task complexity).

Implementing Tiering in LangGraph, CrewAI, and Platform-Native Stacks

LangGraph

Each agent node is configured with a specific model in its ChatModel definition. The state schema includes a routing_decision field. Conditional edges dispatch to nodes wired with the appropriate tier. Adding a new tier escalation is a new node + a new edge — typically a 30-minute change.

CrewAI

Each agent's llm parameter takes a specific model. CrewAI agents declare their model directly. The manager agent can also be on a different tier than the crew members — typical pattern is manager on Tier 1, specialists on Tier 2.

Microsoft Agent Framework

Per-agent ChatCompletionService configuration. Azure OpenAI deployments can mix model SKUs in the same Agent Framework deployment. Easy to wire different agents to different Azure model endpoints.

Platform-native (Lindy + Relevance + Vellum)

Lindy's per-agent model selection. Relevance AI lets each agent specify a model. Vellum lets prompt versions specify the target model. The tiering is a UI configuration rather than code — accessible to non-engineers.

The model-routing proxy approach

A pattern gaining traction in 2026: route all agent LLM calls through a model-routing proxy (Helicone, Portkey, LangChain's own Router, or a custom one) that classifies the request and dispatches to the appropriate provider. The orchestration code doesn't need to know about tiers; the proxy handles it. This decouples the tiering decision from the agent code and lets the FinOps team adjust tiering rules without engineering involvement.

Measurement and the FinOps Conversation

The architect's tiering design is real if and only if it produces measurable cost-per-resolution numbers. Three measurements that matter.

1. Cost-per-resolution by tier

Sum of LLM API costs for every resolution, attributed to the tiers used. The reporting view: "70% of resolutions used Tier 1 for everything except synthesis. Average cost: $0.041. Compared to all-Tier-2 baseline: $0.20. Savings: 79.5%."

2. Tier mix over time

Daily breakdown of what percentage of LLM calls hit each tier. If Tier 3 creeps up, you see it before the monthly bill arrives. If Tier 1 drops because the orchestrator's routing prompt got worse, you see it.

3. Quality by tier slice

Per-tier accuracy on the eval set. The Tier 1 slice should have its own eval and its own regression detection. Same for Tier 2 and Tier 3.

These three measurements turn the architect's tiering design into an ongoing FinOps function. The conversation with the CFO becomes: "We are running at $0.043 per resolution, 78% below the un-tiered baseline. Tier 1 covers 72% of calls. Tier 2 covers 26%. Tier 3 covers 2%. Tier 1 eval accuracy is 97.4%, Tier 2 is 94.1%, Tier 3 is 96.8%."

That conversation is the architect role. The CFO renews the budget. The CEO mentions you by name on the earnings call.

Key Takeaways

• Model tiering is the dominant 2026 cost lever for agent architectures. 60-85% cost reduction per resolution is achievable with the same or better reliability vs the naive "use the expensive model for everything" baseline.
• Three tiers: Cheap-fast (Claude Haiku 4, GPT-4o-mini, Llama 4 8B on Groq) for triage and tool-call, capable (Claude Sonnet 4.5, GPT-4o, Gemini 2.5 Pro) for synthesis and reasoning, frontier (Claude Opus 4.5 with thinking, GPT-5 Pro, Gemini 2.5 Ultra) for hard reasoning and long context.
• Target tier mix: 60-75% Tier 1, 20-35% Tier 2, 1-5% Tier 3. Audit your actual mix monthly.
• Five routing rules: tool-call decisions go to Tier 1, triage and routing go to Tier 1, structured extraction goes to Tier 1, synthesis and novel reasoning go to Tier 2, long context and hard reasoning escalate to Tier 3 (only when needed).
• Cost math: a typical 5-LLM-call B2B support resolution costs $0.20 un-tiered (all Sonnet 4.5) and $0.043 tiered — 78% cost reduction. At 10K resolutions/day, the annual savings are $565,000+.
• Five failure modes: over-routing to Tier 1 (quality collapse), under-routing to Tier 1 (no savings), Tier 1 quality regression after model update (per-tier eval slices catch this), latency budgets ignored (voice agents break), Tier 3 sprawl (cost doubles).
• Implementation: LangGraph wires per-node model, CrewAI wires per-agent llm parameter, Microsoft Agent Framework per-agent ChatCompletionService, platform-native UI configuration. Model-routing proxies (Helicone, Portkey) decouple tiering from agent code.
• Measurement: cost-per-resolution by tier, tier mix over time, quality by tier slice. These three metrics turn tiering from an architectural design into an ongoing FinOps function and earn the architect role.