What Is Model Orchestration? Using Cheap Models for Building and Expensive Models for Review

Model Orchestration Defined

Model orchestration is the practice of routing different parts of an AI coding workflow to different models based on cost-quality tradeoffs. The core principle: use cheap, fast models for generation and first drafts, then route to expensive, capable models for review and verification.

This isn't new in software engineering — it mirrors code review culture. Junior developers write code, senior developers review it. Model orchestration applies the same hierarchy to AI models, capturing 80% of premium model quality at 30% of the cost.

The Economics of Build vs Review

Code generation is token-heavy. A typical feature implementation generates 2,000–10,000 output tokens across multiple iterations. Review, by contrast, requires substantial input tokens (reading the code) but minimal output (approve, reject, or suggest specific fixes). This asymmetry makes orchestration economically powerful.

The orchestrated approach costs 28% less than all-Opus while retaining Opus-level verification quality. The savings compound — over 100 tasks per day, that's $7/day or ~$210/month saved per developer.

Real-World Orchestration Patterns

Pattern 1: /architect mode. Tools like Claude Code's /architect command use a premium model (Opus 4.8) to plan the approach, then hand execution to a cheaper model (Sonnet 4.6). The expensive model sees the full context once and produces a plan; the cheap model executes mechanically.

Pattern 2: Sub-agent delegation. A primary agent running Opus spawns sub-agents on Sonnet for parallelizable tasks — searching codebases, writing tests, generating boilerplate. The primary agent reviews outputs before committing changes.

Pattern 3: Semantic routing. A lightweight classifier (often a small model or heuristic) categorizes incoming tasks by complexity. Simple tasks route to budget models directly. Complex tasks route to premium models. This eliminates the orchestration overhead for tasks that don't benefit from it.

Pattern 4: Generate-then-verify loops. A cheap model generates code, a premium model reviews it, and if rejected, the cheap model regenerates based on feedback. This typically converges in 1–2 cycles for well-specified tasks.

Cost Savings Math: A Worked Example

Consider a team running 500 coding tasks per week. Current approach: all tasks on Opus 4.8 at an average cost of $0.25/task = $125/week.

With orchestration: 400 routine tasks on Sonnet 4.6 at $0.15/task ($60) + 100 complex tasks on Opus 4.8 at $0.25/task ($25) + review pass on all tasks by Opus at $0.075/task ($37.50) = $122.50/week. Marginal savings here because Opus still reviews everything.

Optimized orchestration: only review the Sonnet outputs with Opus (skip review for Opus-generated code). 400 × $0.15 + 400 × $0.075 + 100 × $0.25 = $60 + $30 + $25 = $115/week. That's 8% savings with equivalent quality on complex tasks and Opus-verified quality on routine tasks.

The real savings come from using even cheaper models for generation. With GLM-5.2 (free) for initial generation and Sonnet 4.6 for review: 400 × $0 + 400 × $0.045 + 100 × $0.25 = $0 + $18 + $25 = $43/week — a 66% reduction.

When Orchestration Helps

Orchestration delivers the most value when: tasks are clearly separable into generation and verification phases; your task mix includes both routine and complex work; you have high volume (savings compound with scale); and the cheap model's output is "close enough" that review catches issues faster than regeneration.

When Orchestration Hurts

Orchestration adds cost when: tasks are uniformly complex (you still need the premium model for generation); the cheap model's output quality is so low that review becomes a full rewrite; latency matters more than cost (two model calls instead of one); or your volume is too low for the infrastructure complexity to pay off. For a solo developer running 10 tasks/day, the savings may not justify the setup overhead.

Getting Started

Start simple: use your current premium model as the reviewer and add a cheaper model for generation on routine tasks only. Measure the reject rate — if the premium model approves 80%+ of cheap model outputs without changes, orchestration is working. If it's rejecting more than 40%, the cheap model isn't suitable for that task category. Use the AI Cost Estimator to compare costs across different orchestration configurations.