Agents
The Best AI Model Should Not Do All The Work
Use the strongest model for judgment. Do not burn it on chores.
What this answers
Pillar
Learn how to split planning, execution, and review between stronger and cheaper AI models.
Key takeaways
- The strongest model should own intent, architecture, tradeoffs, review, and escalation.
- Cheap model work is safe only when the task is bounded and the output is easy to inspect.
- Delegation fails when the plan is vague, the quality bar is missing, or the reviewer shares the same blind spots as the worker.
Use the strongest model for judgment
The expensive mistake is using your strongest model like an intern with a bigger brain. It writes the plan, edits the files, runs the checks, fixes the errors, summarizes the result, and then grades itself.
That feels convenient until the project gets long, the context gets noisy, and every minute of premium attention is spent on mechanical work.
The better split is simple. Use the strongest model for intent, architecture, tradeoffs, review, and escalation. Use cheaper workers for bounded execution.
Cheap work must be checkable
Delegation is not magic. A cheap worker is useful when the task is narrow, the expected output is clear, and the result can be checked without redoing the whole job.
Good worker tasks look like this: inspect these files, write this test, update this component, summarize these logs, compare this diff against this spec.
Bad worker tasks look like this: make the architecture better, figure out the product, fix whatever is wrong, improve quality. That is not delegation. That is a vague wish with a lower invoice.
A useful split for real projects
In WarpOS, my agentic operating-system project, the pattern I trust is closer to an operating system than a prompt trick: one lane protects intent, worker lanes execute bounded tasks, and review lanes check evidence against the spec.
The premium model does not need to touch every file. It needs to decide what matters, break the work into safe units, route the right workers, and inspect the proof.
The decision rule is boring and useful: delegate work when the output can be inspected cheaper than it can be produced. Keep work with the strongest model when the cost of a wrong judgment is high.
FAQ
When should I use a cheaper model for agentic coding?
Use a cheaper model when the task is bounded, the instructions are clear, the output is easy to inspect, and failure will not silently damage the project.
What should the strongest model keep?
Keep planning, architecture, tradeoffs, ambiguous debugging, final review, and escalation with the strongest model.
Why does model delegation fail?
It fails when the plan is vague, the worker has too much freedom, the quality bar is missing, or review is done by the same kind of model with the same blind spots.
Conclusion
The goal is not to use the cheapest model possible. The goal is to spend expensive judgment where it compounds.
If the task is bounded and checkable, delegate it. If the task requires taste, architecture, risk judgment, or final accountability, keep the premium model in the loop.
Next move
Keep going through the system.
Read the next piece in this cluster so the idea turns into a usable operating model, not a loose take.
Read agent systemsAbout the author
Related articles
Keep going
AI Coding Feels Magical Until The Project Gets Serious
AI coding breaks when the work needs memory, handoffs, evidence, review, and recovery. That is an operating-system problem.
Your CLAUDE.md Is Not An Operating System
CLAUDE.md can give context, but serious agentic work needs hooks, validators, ledgers, and review gates that do not depend on model memory.