TL;DR:
- Classic model routing (Haiku → Sonnet → Opus) is being replaced by effort routing on a single capable model
- Claude 4.6’s adaptive thinking lets you allocate reasoning budget dynamically per subtask — eliminating context-switching overhead
- Early adopters report 40–60% cost reductions compared to multi-model pipeline architectures
For the past two years, the standard playbook for managing agent costs has been model routing: classify the incoming task, send trivial work to a cheap small model, escalate complex reasoning to a larger one. It works, but it carries a hidden tax — the complexity of maintaining routing logic, the latency variance between models, and the constant calibration work as models and pricing change.
Claude 4.6’s adaptive thinking parameter represents a meaningful departure from that pattern. The same model can allocate near-zero reasoning on a retrieval lookup and maximum-depth reasoning on a security code review, within the same agent session, with a single configuration surface. Teams that have adopted this approach are seeing 40–60% cost reductions without routing layers.
What Effort Routing Actually Means
Claude 4.6 exposes a four-tier effort parameter that controls how much extended thinking the model applies to a given request:
- None — direct generation with no intermediate reasoning, appropriate for classification, formatting, simple lookups
- Low — minimal thinking for straightforward reasoning tasks
- Medium — balanced reasoning for moderate complexity
- High — deep extended thinking for complex code generation, architecture decisions, multi-step analysis
The paradigm shift is subtle but significant. Instead of asking “which model should handle this task?”, you ask “how much reasoning does this subtask require?” The answer maps to an effort level rather than a model endpoint.
Why This Beats Classic Routing for Most Agent Use Cases
No context switching overhead. Multi-model pipelines require serialising and deserialising context across model boundaries. A routing architecture that hands off from Haiku to Opus also hands off all the accumulated conversation state, tool results, and intermediate outputs. With effort routing on a single model, there’s no boundary.
Latency is more predictable. One of the complaints about model routers in production is P95 latency variance — the occasional misclassification that routes a simple query to a large model creates unexpected spikes. A single model with a calibrated effort parameter has a narrower variance profile.
Simpler operational footprint. Routing classifiers need to be maintained, evaluated, and updated as task distributions shift. Effort routing pushes that decision closer to the code that knows the task — your orchestrator tags each subtask with an effort hint based on business logic rather than a separate ML classifier.
Practical Architecture for Effort Routing
The most productive implementation pattern treats effort as a property of subtask type, not a per-request inference. Define your subtask taxonomy once:
EFFORT_MAP = {
"retrieval": "none",
"summarisation": "low",
"code_generation": "medium",
"security_review": "high",
"architecture_design": "high",
}
def run_subtask(task_type: str, prompt: str) -> str:
effort = EFFORT_MAP.get(task_type, "medium")
return claude_client.messages.create(
model="claude-sonnet-4-6",
thinking={"type": "enabled", "budget_tokens": effort_to_budget(effort)},
messages=[{"role": "user", "content": prompt}]
)This also makes cost management auditable — you can log effort level alongside token counts and understand exactly where your compute budget is going.
Where Model Routing Still Makes Sense
Effort routing on a single model isn’t the answer in every scenario. There are three cases where classic model routing remains valid:
Strict latency budgets. If you have subtasks that must complete in under 200ms, a small fast model still wins. High-effort adaptive thinking trades speed for quality.
Specialist domain models. Some tasks benefit from fine-tuned or domain-specific models rather than a general foundation model with extra reasoning time.
Cost floor requirements. For very high volume, very simple tasks (classification at millions-per-day scale), the cheapest small model will still be cheaper than a large model at zero effort.
Integration with Subagent Architectures
Claude 4.6’s subagent model configuration accepts three formats: a model alias (sonnet), a full model ID (claude-sonnet-4-6), or an inherit flag that mirrors the parent session’s model. This means an orchestrator running on Opus 4.7 can spawn subagents that inherit its model, each running at an appropriate effort level, without any routing infrastructure.
The orchestrator+isolated-subagents pattern that has become the production standard across Anthropic, AutoGen, LangChain, and Cognition integrations maps naturally onto this: the orchestrator classifies subtask complexity and emits effort-tagged work items, subagents execute them, results accumulate in the parent context.
Pairing With Memory Efficiency
Effort routing compounds well with memory optimisation. Claude 4.6’s hierarchical memory extraction — single-pass extraction with multi-signal retrieval — reduces the token overhead that context management adds to long-running agents. Pairing adaptive thinking (spend compute where tasks need it) with efficient memory (don’t spend tokens on irrelevant context) gives you both cost levers operating in the same direction.
The teams seeing the 40–60% reductions are typically combining both. Effort routing alone accounts for roughly 25–35% of the saving; memory efficiency makes up the rest.
Getting Started
If you’re currently running a Haiku/Sonnet/Opus routing pipeline, the migration path is straightforward:
- Audit your routing classifier to understand which task types it sends where
- Map that taxonomy to effort levels
- Migrate the highest-volume routes first, using a shadow mode where both pipelines run in parallel for a week
- Compare cost and quality metrics before cutting over
The most common finding from teams doing this migration: the routing classifier was miscalibrated in ways they hadn’t noticed, and effort routing surfaces this immediately because the decision logic lives in the application layer where it’s visible.
Effort routing won’t eliminate every use case for model routing, but for the majority of agentic pipelines, it’s a simpler, cheaper, and more maintainable path forward.