Planner Over Cheap Models: one strong planner, cheap workers, and a check that keeps both honest
by PaperChaseWebb
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.
- Price
- $24
- Difficulty
- Intermediate
- Setup
- 45 min
- Format
- .md file
planner-over-cheap-models-strong-planner-cheap-workers.md · 57 KB · instant download after checkout
Want this built for you instead? We can build it for you.
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.
Works with
Solid chips: the agent is named in this listing's own tools list. Dashed chip: Plain Markdown, so it also pastes into other agents such as Grok Bot, Hermes, OpenClaw or Muse. We list those as compatible by format only, not as tested.
Tools needed
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.
Time to result: Set up and tested in 45 minutes; the first watched run takes about 90 more
How it works
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.
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.
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.
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.
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 from the pack
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.
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 the file
# 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.
Details
Version 1.0 · Updated Oct 28, 2026 · Markdown version of this page
License: Use on your own projects and on installs you do for clients. Do not resell or republish the pack itself. Download terms
Related
The planner and worker contract and a plan preflight check (free sample)
From Planner Over Cheap Models: the six rules that let a strong model plan while cheap or local models write the code (planner never edits, a check on every task, the check runs instead of the worker, parallel tasks own different files, high risk goes up a tier, owner yes before any worker starts), plus a read-only Python check on your plan, with a worked example and its expected output.
Agent Cost Levers: cut cost per solved task without cutting quality
A Markdown pack that measures what your coding agent spends per finished task, then works five levers one at a time: thinking depth, context curation, direct tool routing, cache and reuse, and a verified stop. Includes a baseline sheet, a rules block and 10 prompts.
Cross-Harness Relay: Grok Bot, Claude Code, Codex and Hermes on one job
A bot template and teaching guide for running more than one agent harness on the same work. Six seat cards (front desk, planner, builder, reviewer, tester, night shift), a RELAY.md seat map, a relay packet for every handoff, four loop shapes, routine-or-judgment routing with a fallback when limits run tight, a preflight check, the front desk and night shift split with a proof footer, shared memory rules, eight relay drills, a rules block and 14 prompts.
Token saver: keep long command output out of your coding agent's context
Two shell scripts and one rule line that make Claude Code, Codex, Cursor and other agents read a one-page summary of builds, tests and searches instead of thousands of lines.
Spec-First Build Docs: PRD, design system, architecture note, agents guide and readiness check
A Markdown pack of the four documents to write before an agent builds anything, sized to the stakes: a PRD an agent can build from without inventing scope, the smallest design system that holds, a one-page architecture note with reversal costs, an agents guide with a project tree for Claude Code, Codex and Cursor, a weekly staleness pass and a nine-area readiness check.
Ask-first rules for AI agents: hard nos, approval cards and a test set
Paste-in rules that make an agent ask before it sends, spends, posts or deletes, define what a real yes is, and stop retries after a no, plus 12 test scenarios to check it.
Vibe Coding with AI Agents: method, prompts, skills and checklists
A Markdown playbook for building real software with Claude Code, Codex or Claude: a seven-step method, project file templates, 18 prompts, five agent skills, release and hardware checklists, cost notes and 24 project ideas.
Governed Agent Teams: subagent personas, authority maps and handoffs
A Markdown pack for running a team of coding and research agents with clear limits: 7 subagent personas for Claude Code with Codex AGENTS.md and Hermes skill versions, a Desk Authority Map, three role risk classes, a handoff packet the receiver verifies, an evidence standard, a decision ledger and a reach inventory.
Two-Agent Build and Test Loop for paid apps: one agent builds, another tests, and nothing passes on its own say-so
A tested setup for apps that take money: one agent writes the code, a separate tester session writes the stories and tests and gives the verdicts, a small runner records every red, green and revert exit code itself, and the owner says yes to the plan, any payment or pricing work, each merge and each release. Test keys and sandboxes only. A read-only check with fifteen tests audits the finished run.
Agent Control Room: voice control for a dozen agents
Talk to twelve agents by name from one place. Say "tell juniper to fix the login test" and it goes to juniper and only juniper, read back in a sentence. Ask "who is waiting" and the board answers with waiting on top. Say "stop all" and every session gets it. What voice never does is approve: every yes, "approve it", "go ahead" and "1" is refused, and gated actions wait for a typed yes from the owner tied to the sha256 of the request, which the agent checks before it acts.