# Planner Over Cheap Models: one strong planner, cheap workers, and a check that keeps both honest

> A tested setup for splitting coding work between one strong model that plans and reviews and cheap or local models that write the code. Every task card carries its own check, a logger runs that check instead of trusting the worker, the owner says yes to the plan, any escalation and every merge, and a read-only check with fourteen tests audits the finished run. Includes a worker bake-off so you pick the cheap model on your own tasks.

- URL: https://paperchasewebb.ai/bots/marketplace/items/planner-over-cheap-models-strong-planner-cheap-workers/
- Type: Bot template
- Category: Vibe coding
- By: PaperChaseWebb
- Works with: Claude Code, Codex, Grok Bot, Hermes (named in the listing); Plain .md and four Python 3 scripts; any cheap hosted or local worker model
- Price: $24 USD
- Difficulty: Intermediate
- Setup time: 45 min
- Time to result: Set up and tested in 45 minutes; the first watched run takes about 90 more
- Format: Markdown (.md) file, planner-over-cheap-models-strong-planner-cheap-workers.md
- Version: 1.0, updated 2026-10-28
- License: Use on your own projects and on installs you do for clients. Do not resell or republish the pack itself.

## What you end up with

The expensive model stops doing the cheap work, a worker's done means its check passed, and you can see cost per passed task for each worker model you try.

## What you get

- 23 sections in one .md file
- The run folder: route.json, plan.json, approvals.csv, ledger.csv, merged.csv and report.md
- A routing table by uncertainty, blast radius and how easy the work is to verify
- The task contract: files, check, risk, tier, review and dependencies on every card
- Three owner approvals: plan before any worker starts, escalation to the strong tier, and each merge
- plan_check.py: five preflight checks before any worker starts
- log_attempt.py: runs each task's check itself and records the real exit code
- route_check.py: fourteen read-only checks on the finished run, plus cost per passed task by worker model
- A seeded fixture with 14 planted faults, what the right run did instead, and the expected output
- A worker bake-off: pick the cheap model by cost per passed task on your own tasks
- Planner and worker rules blocks, ten prompts and setup notes for Grok Bot, Claude Code, Codex and Hermes
- A one-afternoon install plan, go-live checklist, weekly review and failure table
- A look at six routing tools and packs, with sources

## Who it is for

Builders who use a coding agent every day and watch the bill or the usage window, and want cheap or local models doing real work without trusting what those models say about it.

## Tools needed

- Grok Bot, Claude Code, Codex or Hermes: runs the planner, reviewer and worker sessions on the models you pick; the planner never edits and no session merges, pushes or deploys
- A cheap hosted model or a local model server: does the worker turns, for example through llama.cpp, Ollama or LM Studio
- Python 3: runs the preflight, the attempt logger and the read-only run check; standard library only
- Your project's own tests: the check command on every task card
- You need: A coding agent harness (Grok Bot, Claude Code, Codex or Hermes)
- You need: Access to one strong model and at least one cheap or local model
- You need: Python 3.8 or newer
- You need: Tests, or the willingness to write a check for each task

Cost to run: The pack is the only purchase. Hosted model usage is billed by those vendors; local models cost only your hardware and time.

## How it works

1. **Test the checks.** Save the four scripts from the file, build the fixture and run route_check.py and plan_check.py on both folders. Expected: route_check.py: 14 findings on seeded, 0 on fixed. plan_check.py: 5, then 0.
2. **Write route.json.** Make a runs/ folder outside your repo, copy route.json from section 5, and put in your real model ids, budgets and your name as owner. Expected: plan_check.py runs on the folder.
3. **Limit the sessions.** Map each role's tools to your harness, paste the planner and worker rules blocks, and remove push, deploy, publish and network from every session. Expected: The planner session cannot edit files and no session can push or reach the network.
4. **Run three tasks, watched.** Pick three small tasks that have tests, run the ten prompts in order and give each yes yourself. Log every worker turn with log_attempt.py. Expected: route_check.py prints 0 findings and the report matches the ledger.
5. **Run the bake-off.** Run the same five tasks once per candidate worker model in separate run folders and compare the route_check.py summaries. Expected: One worker model picked by cost per passed task, with no done claims on failing checks.

## Sample prompt: Plan the run (Grok Bot, Claude Code, Codex, Hermes)

```
Here is the request: {request}. Read only the files you need and write plan.json for run {run} under the task contract in the pack.
Keep each task small enough for a cheap worker to pass in two attempts. Then run plan_check.py and fix every finding.
```

Prompt 1 of 10. Runs after the planner rules block in section 14.

## Sample prompt: Approval card for the plan (Grok Bot, Claude Code, Codex, Hermes)

```
Show plan.json as an approval card: run id, plan hash (first 12 of sha256), each task with goal, files, check, risk, tier and review, then the planner budget.
End with: reply 'yes plan {run}' to approve. Do not write the approval row yourself.
```

Prompt 2 of 10.

## Free preview of planner-over-cheap-models-strong-planner-cheap-workers.md

````markdown
# Planner Over Cheap Models: one strong planner, cheap workers, and a check that keeps both honest

Version 1.0, 2026-10-28. By PaperChaseWebb. Works with Grok Bot, Claude Code, Codex and Hermes. Plain Markdown and four Python 3 scripts (standard library only), tested on a seeded fixture with fourteen planted faults.

This pack sets up one way of working: the expensive model plans and reviews, cheap or local models write the code, and nothing counts as done until a check you wrote before the run says so. It gives you the run folder, the routing file, the task contract the planner writes, three approval steps for the owner, a logger that runs each task's check itself, a preflight, a read-only check on the finished run, and a way to pick your worker model on your own tasks instead of on a leaderboard.

It does not repeat how to measure cost per solved task or the five general cost levers (thinking depth, context, tool routing, caching, verified stop). Those are in Agent Cost Levers (pp-agent-cost-levers), and this pack assumes you have a baseline from it or something like it. Moving work between harnesses mid-week is in Cross-Harness Relay (pp-cross-harness-relay). This pack is the part those leave open: how to split one job between a strong planner and cheap workers so the bill drops without the quality going with it.

## Contents

1. What this pack does
2. Who it is for, and when not to use it
3. The split: what the planner does, what workers do
4. The run folder
5. route.jso
````

## Worth knowing

- It needs a check command per task. Work you cannot check with a command (copy, design taste, open research) does not fit this method.
- For one-file fixes the planning and review overhead is bigger than the job. Use one model.
- It does not repeat cost-per-solved-task measurement or the general cost levers; those are in Agent Cost Levers (pp-agent-cost-levers).
- Token figures quoted from public posts are single runs by their authors. The pack makes no savings claim; route_check.py shows your own numbers.
- On 2026-10-28, route_check.py reported the fourteen expected findings on the seeded fixture, then 0 on the fixed one, with file hashes unchanged; plan_check.py gave 5 then 0; log_attempt.py recorded real exit codes for a passing and a failing check. Run the tests on your own machine first.

## Questions

**How is this different from Agent Cost Levers?** Agent Cost Levers shows you how to measure cost per solved task and which five general levers to pull. This pack is one specific setup on top of that: a strong planner, cheap or local workers, checks on every task, owner approvals and a read-only audit of each run.

**Can the workers be local models?** Yes. Run them in a harness that supports local endpoints, such as Hermes or Codex, on the same run folder. Claude Code subagents run on Anthropic models, so local workers live in another harness there.

**What stops a cheap worker from saying it finished when it did not?** The worker never reports its own check result. log_attempt.py runs the task's check and records the exit code, and route_check.py flags any done claim on a failing check.

**How many prompts does it have?** Ten, one per step of a run. The pack is built around tested files (four scripts and a seeded fixture with expected output) rather than a long prompt list.

## How to buy

$24 one time at https://paperchasewebb.ai/bots/marketplace/items/planner-over-cheap-models-strong-planner-cheap-workers/. Stripe checkout, then an instant download page; the download link is also in your emailed receipt.

Seller: PaperChaseWebb Inc., mgmt@paperchasewebb.com