Should your smartest model be the one running grep?

June 14, 2026·8 min read·by the FrankenCoder team

Most coding agents run on one model. The same model that reasons about your architecture also reads files, runs searches, and types edits — so you pay the brilliant-model rate for a turn whose entire job was "read lines 40–80 of this file." We wanted to know what a smarter shape would actually save, so instead of guessing we replayed 100,000+ real billed turns.

1. The hunch: an arbiter, not a typist

It's brilliant, and it's expensive. We had a hunch there was a better shape: keep the powerful model as the arbiter — it plans, it decides, and crucially it verifies the result — but hand the mechanical work to cheaper, faster sub-agents. The smart model stays in charge of every decision; it just stops personally typing every grep.

The obvious question is how much would that actually save? So instead of guessing, we measured it against reality.

2. We didn't benchmark. We replayed.

Every turn an agent has ever taken in FrankenCoder is stored with its real token bill — the exact input, output, and cache tokens the provider charged — alongside which tool that turn called. That's a complete, ground-truth ledger of real work.

So we built a replay simulator. It walks the actual transcripts and, turn by turn, asks: what kind of work was this?

• Searching and reading (grep, file reads, codebase lookups) → would go to a cheap "prepper" sub-agent.
• Writing and editing files → a cheap "executor" sub-agent.
• Running builds and tests → kept on the smart model by default (verification is the arbiter's job).
• Reasoning and orchestration → stays on the smart model, always.

Then it re-prices each turn at the sub-agent's rate, adds a realistic hand-off cost for every delegation, and totals it up. No synthetic tasks. No cherry-picked demo. Just the real history, re-priced. We ran it across 104,979 real turns in our largest project (566 conversations in our own codebase), then across all 18 projects we have.

3. What we found

Our largest codebase, priced with every turn on the premium model, came to $14,370. Here is where that money actually went:

That first two-thirds — $9,311 of search and writing — is exactly the mechanical work you can hand off. The final third is the part you want your best model doing.

And it held up across the whole portfolio, not just one. Priced end to end, all 18 projects came to $20,233 on the premium model; the same history with cheap workers and the premium model still planning and verifying came to $11,590 — a 42.7% reduction, $8,643 saved, deliberately measured on the conservative side.

4. Two knobs, not one

Once we could re-price any turn at any model, an obvious follow-up appeared: the worker tier and the planner tier are independent knobs, and they stack. Run against the same full-portfolio history (everything-on-premium = $20,233, today's baseline):

The two savings stack because they touch different turns — one cheapens the ~65% of work that's mechanical, the other cheapens the ~35% that's judgment (a further 31.5% on top of delegation alone). But they are not equally safe, and that distinction is the whole point of the design:

So the headline number we stand behind is the conservative ~43% — premium planner, cheap workers, verification untouched. The deeper ~61% is real and available, but it's a deliberate quality trade you opt into for low-stakes work, not a free lunch.

5. The honest part

A few things we made a point of getting right, because cost claims are easy to inflate:

• We under-counted the savings on purpose. We priced the sub-agent turns using the full context size of the original session. A real sub-agent carries a tiny context — its one task and the one file it's touching — so in practice it would cost even less than we charged it. Our numbers are a floor.
• Delegation isn't free, and we paid for it. Every hand-off to a sub-agent costs a round-trip on the smart model. We charged that overhead on every batch, at the full expensive rate — about $763 of modeled hand-off cost on our largest project, already subtracted from the $6,691 it saved.
• Savings only show up where there's grunt work. Projects that were mostly question-and-answer barely moved — there's almost nothing mechanical to delegate. Projects full of real code-reading and editing moved the most (one hit ~64%). Delegation pays exactly where the grunt work is, and nowhere else.
• This measures cost, not quality. The savings are only worth taking if the cheaper sub-agents do the mechanical work well and the smart model catches any mistakes when it verifies. We're validating that before we turn the aggressive settings on by default.

6. Where the savings stop — and why that's the point

There's a ceiling, and it's a feature. You can't delegate the planner's own thinking, and you can't delegate its verification of the work. About a third of every session is the smart model deciding what to do and checking that it was done right. That part stays expensive on purpose — it's the part that's worth paying for.

7. What we shipped

Based on these numbers, we shipped per-agent model selection. There's no preset to choose and nothing is cheapened by default: a Delegate Agent Model Override panel lets you set the model for each delegated specialist — prepper, executor, reviewer, security, documentation, and the rest — independently. Leave an agent on "Use conversation default" and it runs on whatever the planner is using; point it at a cheaper model and every time the planner delegates that role, the work runs there. (Picking a specialist yourself from the agent picker still uses the top-of-chat model selector — the override only applies to delegated hand-offs.)

The models can come from any provider, mixed freely the workers. We validated it on a clean run with the planner on Claude Haiku, the prepper on OpenAI's GPT-5.5, and the executor on xAI's Grok: three providers in a single session, each turn billed to the right one. So "premium planner, cheap workers" isn't one vendor's tier ladder — it's whichever model is cheapest for the mechanical work, whoever makes it.

← All guides