Multi-Agent Model Routing: Planner + Executor Pairs That Cut Costs 4x

The Single-Model Cost Problem

A coding agent running Opus 4.8 on every turn processes roughly 14M input tokens per end-to-end app build. At $5/M input tokens, that is $0.07 in input costs alone — before output, before caching, before the multiple builds needed to get a task right. A 20-developer team running 10 builds per day per developer spends $28K/month on input tokens.

Most of that spend goes to turns that do not need a frontier model. File reads, tool call parsing, mechanical edits, test command invocations — these are execution tasks. They require the model to follow instructions and produce valid structured output, not to reason about novel problems. A mid-tier model handles them identically at 3-5x lower cost.

The planning turns are different. Reading the task, understanding the codebase, decomposing the problem, deciding the approach — these require the full reasoning capacity of a frontier model. The mistake is applying frontier-model pricing to execution turns that a cheaper model handles equally well.

How Planner + Executor Routing Works

The planner-executor split assigns a different model to each role in the agent loop:

The architecture is a thin routing layer, not a full orchestration framework. Your agent loop checks which phase it is in (planning vs execution) and sets the model accordingly. The actual LLM calls go directly to the provider API. No proxy, no middleware overhead.

Benchmark: 40 Real App Builds

Morph tested 44 planner-executor pairs on 40 end-to-end app builds across four task types: scaffold a new app, add a feature, refactor a module, ship to production. A build counts as successful only when the app runs and passes its acceptance checks — no partial credit.

The full leaderboard — ranked by the combined 2:1:1 score and filterable by accuracy-only, price-only, and speed-only — is at morphllm.com/benchmarks/multiagent.

Token Profile: Where the Spend Goes

Across 40 builds, the median token breakdown per build:

Switching executor from Opus 4.8 to Sonnet 4.6 saves $26.25 per build (28%). Switching to Haiku 4.5 ($1/$5 per M) saves $52.75 per build (57%). The planner cost is fixed at $26.25 regardless of executor choice — it always runs on the frontier model.

Cache pricing compounds these savings. Anthropic charges 10% for cache reads. With a stable system prompt and long file context, execution turns often hit 60-80% cache hit rates. A 70% cache hit rate on Sonnet 4.6 executor input drops the executor input cost from $30M to $30M x (0.3 + 0.7 x 0.1) = $30M x 0.37 = $11.10 per 10M tokens, reducing total cost to roughly $37.35 per build — a 60% reduction from the all-Opus baseline.

Model Tier Selection

Not all model pairs perform equally. The executor must handle the agent's full tool call schema (file read, file write, bash, search) and produce valid JSON on every turn. Models that drop tool call arguments or produce malformed JSON on complex schemas fail builds regardless of their benchmark scores on clean chat tasks.

See the full ranked leaderboard — filtered by accuracy, price, or speed — at benchmarks/multiagent.

Implementation

The planner-executor split is a routing decision at session start, not a framework change. Your agent loop tracks phase state and switches models at compaction boundaries.

import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic();

// Model assignments
const PLANNER_MODEL = "claude-opus-4-8-20260528";   // Frontier: planning only
const EXECUTOR_MODEL = "claude-sonnet-4-6-20260601"; // Mid-tier: execution turns

type Phase = "planning" | "executing";

interface AgentState {
  phase: Phase;
  turnsSinceCompaction: number;
  compactionThreshold: number; // e.g. 80 turns
}

async function agentTurn(
  messages: Anthropic.MessageParam[],
  state: AgentState,
  tools: Anthropic.Tool[],
): Promise<{ response: Anthropic.Message; state: AgentState }> {
  // Determine model based on phase
  const model =
    state.phase === "planning" ? PLANNER_MODEL : EXECUTOR_MODEL;

  const response = await anthropic.messages.create({
    model,
    max_tokens: 8192,
    tools,
    messages,
  });

  // After planning turn: switch to execution
  let nextState = { ...state };
  if (state.phase === "planning") {
    nextState.phase = "executing";
    nextState.turnsSinceCompaction = 0;
  } else {
    nextState.turnsSinceCompaction += 1;
    // Trigger compaction + re-plan at threshold
    if (nextState.turnsSinceCompaction >= state.compactionThreshold) {
      nextState.phase = "planning"; // Next turn fires planner
    }
  }

  return { response, state: nextState };
}

// Session start: always plan first
const initialState: AgentState = {
  phase: "planning",
  turnsSinceCompaction: 0,
  compactionThreshold: 80,
};

The compaction threshold determines how often the planner re-fires. Lower thresholds (every 30-50 turns) give the planner more opportunity to re-evaluate and correct drift at higher cost. Higher thresholds (80-120 turns) are cheaper but risk the executor drifting from the original plan.

import { morph } from "morph";

// Before firing the planner, compact accumulated executor context
async function compactAndReplan(
  executorHistory: Anthropic.MessageParam[],
  originalTask: string,
): Promise<Anthropic.MessageParam[]> {
  // Compact executor turns: ~33,000 tok/s, 50-70% reduction
  const { compacted } = await morph.compact({
    messages: executorHistory,
    targetRatio: 0.4, // Reduce to 40% of original token count
  });

  // Planner receives the compacted summary + original task
  return [
    { role: "user", content: originalTask },
    {
      role: "assistant",
      content: `Progress so far: ${compacted.summary}. Continue.`,
    },
  ];
}

Single-Request vs Multi-Agent Routing

Two complementary approaches, not competing ones:

They stack: apply single-request routing within the executor to further reduce cost on the easiest executor turns. An executor turn that is routing a trivial file read can use Haiku even if the executor default is Sonnet. This delivers planner-executor savings plus per-turn routing savings on top.

For single-request routing details and the classification API, see LLM Router. For total cost reduction across all levers (routing, compaction, caching, batching), see LLM Cost Optimization.

Frequently Asked Questions

What is multi-agent model routing?

Multi-agent model routing assigns different LLM models to different roles in an agent loop. The planner uses a frontier model for reasoning. The executor uses a cheaper, faster model for mechanical turns. On a typical 14M-token build, this cuts cost 4x compared to running the frontier model everywhere.

What is the planner-executor split?

The planner fires at session start and after each context compaction: it reads the task, understands codebase state, and produces a plan. The executor handles every turn in between: tool calls, file reads, edits, test runs. Token profile per build: 4M input / 250K output on the planner, 10M input / 650K output on the executor.

How much does planner-executor routing reduce costs?

Switching executor from Opus 4.8 to Sonnet 4.6 saves 28% per build. Switching to Haiku 4.5 saves 57%. With prompt caching at 70% hit rate on executor turns, total savings reach 60%+ versus the all-Opus baseline. The PEAR benchmark reported a 4.4x cost reduction for Plan-Execute versus Reflexion on the same task set ($1.24 vs $5.12 per task).

What models work best as planner vs executor?

Planner: Claude Opus 4.8, Claude Fable 5, GPT-5.5. Executor: Claude Sonnet 4.6, Claude Haiku 4.5, Gemini 3.1 Flash. The executor constraint is reliable tool call JSON: models that drop arguments or produce malformed structured output on complex schemas fail builds regardless of chat benchmark scores. See the full leaderboard for tested pairs.

How is this different from Morph Router?

Morph Router classifies each individual prompt and routes per-turn. Planner-executor routing assigns a fixed model to each architectural role, with no per-turn classification overhead. They stack: use Morph Router within the executor to further reduce cost on trivially easy executor turns.

Where can I see the full benchmark results?

Full leaderboard with 44 model pairs ranked by accuracy, price, speed, and combined score: morphllm.com/benchmarks/multiagent.

Related Resources

• Multi-Agent Benchmarks: Full Leaderboard (44 pairs, 40 builds)
• LLM Router: Single-Request Model Routing
• LLM Cost Optimization: 5 Levers, 70-85% Savings
• AI Coding Costs: Token Math at June 2026 API Rates
• Context Compaction at 33,000 tok/s
• Context Rot: Why Agents Degrade Over Long Sessions
• AI Agent Orchestration Patterns