SShogo Learn
← Library

Guide · 2026-10-30

Stop paying the big model to do the cheap work

What you'll have: a team split by role across two models — the expensive one plans and reviews, the cheap one executes — and the one sentence you put in the plan so the cheap model doesn't start second-guessing it.

What's real here: the split is a setting, not a theory. Every agent in my workspace has a model, and the ones that run under a lead can be given a tier — cheap, default, or best — per task. I set it by role: the thing that decides what to build gets the slow expensive model, the thing that types gets the fast cheap one. The prices below are mine from 2026-10-20 ($0.10 per million tokens for the small model, about 50× cheaper than the big one) and they move — check yours before you budget on them.

The problem this fixes

The obvious setup is one frontier model for every agent. It works. Then you add a fourth agent and the bill scales with the team, so you start rationing your own agents — which is the opposite of the point of having them.

The thing to notice: almost none of that spend is on ambiguity. It's on carrying out a plan that's already been written.

The split

Role Model Why
Planner the strong one This is where ambiguity lives: what to build, in what order, what "done" means. A cheap model here misreads the task and every agent downstream pays for it.
Reviewer / checker the strong one Reading a diff for what's wrong is a judgement call on incomplete information. This is the second-hardest job in the team and the cheapest place to spend.
Workers the cheap one Once the plan removed the ambiguity, the job is mostly following it: read the files, write the change, run the tests, report.
Reflection / summarising the cheap one Tidying the week, writing lessons, summarising a thread. No decisions, lots of tokens.

The rule underneath: the model goes where the ambiguity is. Not "the important stuff" — importance isn't the axis. A cheap change to a dangerous file is still cheap; an ambiguous instruction is expensive no matter who does it.

What it costs, measured by someone else

  • Cursor's agent swarm, July 2026: an Opus 4.8 planner with cheaper workers cost $1,339 on their SQLite task. GPT-5.5 doing everything cost $10,565 — and they report "every mix produced similar quality." Caveat: one task, their harness, their pricing — not a benchmark of your workload.
  • Anthropic, June 2025: an Opus lead with Sonnet subagents beat a solo Opus by 90.2% on their internal research eval. Caveat: their eval, their models, and a research task — the direction is what transfers, not the number.

Two different findings, same shape: mixing models did not cost quality. In the Cursor case it was the same output for about an eighth of the price.

The one sentence that makes it work

This is the part people skip, and it's why their cheap workers produce mush.

When you hand the plan to a worker, say what's already decided:

"The plan is decided. Your job is to carry out step 3 exactly as written: the change goes in src/api/handlers.ts, the test goes next to it. If the plan looks wrong, stop and say why — don't redesign it."

Without that line, a small model sees a goal and starts re-deciding things it isn't equipped to decide. With it, "stop and say why" gives you the escape hatch that keeps a cheap model from silently doing something clever.

Where it goes wrong

  • Cheap model on the plan. The failure is silent: everything downstream is well executed and wrong.
  • Cheap model on review. It passes things it can't verify. A reviewer that can't be bothered to be suspicious is worse than no reviewer, because it makes you stop looking.
  • A cheap model with no brief. "Build the thing" to a small model gets you a different thing every time.
  • Splitting before you've written the plan down. The split assumes a plan exists as text. Two models sharing a vague intention is just two chances to be wrong.
  • Tiering everything at once. Change one role. If output drops, you know which change did it.

How to set it up

  1. Write down your roles. Four lines: planner, worker, checker, and whoever tidies up. If you can't name them, you don't have a team yet, you have one agent doing everything.
  2. Point the plan and the review at the strong model. Nothing else, yet.
  3. Move the workers to the cheap one. Add the "the plan is decided" sentence to the hand-off, with "stop and say why" in it.
  4. Run three real tasks. Read what came back. The failure to watch for isn't worse code, it's confidently different code.
  5. Then the tidy-up work — summaries, lessons, changelogs — onto the cheap model too.

shogo-guide.md next to this file sets the whole thing up in a Shogo workspace in one message.

Next step

The split only holds if something catches what the worker got wrong, and the worker can't be the one to catch it. That's the REVIEW guide: the checker's brief, and the three things it has to produce before anything ships.

Set it up in Shogo

Open a Shogo workspace and paste this into the chat. Answer its questions; the agent builds the rest.

Prompt
Set up a role split across two models for this project, and show me the hand-off.

Do not change anything yet. First, write `ROLES.md` at the root of this project with a table like this, filled in for what actually exists here:

| Role | What it decides | Model tier |
|---|---|---|
| Planner | what to build, in what order, what "done" means | best |
| Checker | whether the change is right, from the diff and its own runs | best |
| Worker | carrying out one step of a written plan | fast |
| Tidy-up | summaries, changelogs, writing lessons | fast |

Set the tier to `best` only where the role makes a judgement call on incomplete information — a plan, or a review. Everything else is `fast`. Add one line under the table explaining the rule: "The model goes where the ambiguity is, not where the importance is."

Then, for every worker hand-off in this project, add a brief template to `AGENTS.md` under `## Handing work to a worker`:

```
The plan is decided. Your job is to carry out step N exactly as written:
- change: <file>
- test: <file>
- prove it: <command that must pass>
If the plan looks wrong, stop and say why. Do not redesign it.
```

Then show me it works on the smallest real task you can find in this repo: pick one small, safe change (a typo, a doc line, a missing return type), hand it to the worker using that template verbatim, and paste back both the hand-off and the result.

Do not claim a cost saving — you have no billing data. If you can read a model name per role from the config, print the table with the real model names next to each tier; if you can't, say so plainly and leave the tier column as the tier only.
Want it as a guided course with a coach?Agent Team Playbook