Stories A promise's telling · drafted 2026-09-28

The Cheap Hands and the Dear Ones

The factory builds each card with the cheap model and pays the frontier model only to plan and to judge, with every model call counted by session and purpose.

The seven beats

World
The group `one`: a single machine where seven sessions build the factory at once, all running on one subscription's quota
Cast
The operator, who asked; the conductor sessions and the subagents they spawn; the cheap builder model; a security reviewer nobody had asked for; the governor that gives the box one gate at a time
Knock
The operator, 2026-09-28: look at all the sessions that are running and understand how they could run better, with better tracking and intelligence, and optimise the different models on price and performance
Want
The same cards built for a fraction of the quota, and sooner: the cheap model does the building, the frontier model plans once and judges once, and every call can be counted back to the session and the purpose that made it
Way
The transcripts are read as a ledger. Every cost gets marked back to its cause, what does no work fades out, and each lane gets shorter, until the frontier model's turns track the decisions and stop tracking the keystrokes
Turn
The cheap model was never the cost. A hundred and forty-two calls to it cost less than a single turn of the frontier model. The quota went on the frontier loop wrapped around each call
Lesson
Open — a Lesson is learned by someone, and this one is not written yet

At ten past eleven in the morning, seven sessions were awake on one machine, and six of them were busy.

Each one had been asked for something different. One was building a customer book. One was pricing credits. One was clearing the machine so the others could breathe. None of them had been asked what the work cost.


The factory had a rule, and the rule was a good one. The cheap model builds. The frontier model judges. A card that anyone can check with a test should never be written by the most expensive mind in the building.

The operator had said it plainly that morning, and more than once. Spawn the cheap builders. Fill the gaps in parallel. Use the flash model for the looking and the research.

So the sessions spawned builders. Each builder was a frontier agent, and each one was told to hand the typing to the cheap model.

This is the thing to look at. Not the cheap model.


The transcripts keep everything. Every call, every token read and written, every tool that ran and how long it took. Read as a ledger, a day of them says where the quota went.

It did not go where the rule said it would.

In one session, twenty-three lanes were sent out to build with the cheap model. Between them they made one thousand three hundred and twenty calls to the frontier model and fifty-five calls to the cheap one. Twenty-four frontier calls for every cheap one. The cheap model had written its part in seconds. The frontier agent around it had read the files, planned the call, made the call, read the answer, checked the answer, run the gate, waited for the gate, and read the gate's answer too.

It is not that the cheap model failed. It did what it was asked. It was asked very little.


There was a second spender, and nobody had hired it.

A reviewer ran every time any session or subagent stopped. It was a whole new session, on an older and dearer model, told to think as hard as it could. It read the change, judged its security, and wrote its findings back. On a busy hour it ran dozens of times. In one day it opened a hundred and thirty-six sessions of its own.

Nobody had asked for it. It came with a plugin, and the plugin did what it was built to do.


The third spender was time.

A subagent remembers what it has read for five minutes. After that it forgets, and the next turn reads everything again from the start, at full price. Most of its turns come seconds apart, so five minutes is plenty.

A gate is different. The machine gives one gate at a time, and a gate that waits in the queue can take longer than five minutes. So can a long call to the cheap model, or a loop that sits there asking whether something has finished yet. Fifty-three times that day, a subagent waited that long and forgot everything. Each time, it paid to read it all back in.

The waiting was not free. It was paid for twice.


Then came the number that changed the question.

Over the whole day, the cheap model answered a hundred and forty-two calls. Together they cost less than a single turn of the frontier agents that called them.

The builders were never the cost. Everything around them was.


The fix is not to find a cheaper model. There is no cheaper model that matters here. The fix is to stop wrapping the cheap one in the dear one.

A frontier agent should plan the card once and judge it once. Between those two moments the work belongs to something that does not think at all: a loop that feeds each file to the cheap model, runs the test, and keeps what passes. Keep the waits under five minutes, or hand them off and come back. And let every call carry the name of the session that made it, so that tomorrow the ledger is not a thing someone has to go and read.

That morning there were seven sessions and one question.

What did the work cost?


By the afternoon there was a second question, and it was the harder one.

What did the work buy?

A day of transcripts says where the quota went. It does not say how many cards landed, how long each one took from claim to dev, or how many times the cheap model's work passed on the first judge. Until those numbers sit beside the cost, the factory could get cheaper and worse on the same day, and nobody would see it.

So every number gets a name, a baseline and a target. Every card says which number it moves. The pages show the numbers, and the chairman's meeting starts from them. A card that moved nothing is not done, however green its tests.


Connected to

Every link here was checked against the repo when the page was built. 10 names the story uses could not be found and are shown without a link.

People

  • tony

Agents

Each opens a chat with that agent.

Skills

Each opens the skill's page.

  • models
  • planning
  • meeting
  • deploy

Paths

The flows this story walks — trigger → step → step.

  1. trigger: card claimed → agent: plan the card once (frontier; the promise's accept lines are the plan) → tool: a second model family writes the tests, and they run red → tool: flash-lane.sh feeds each file to deepseek-flash (a script, not an agent) → tool: verify:fast through gate-run → condition: green → agent: the cheapest judge rung that can say no (jev, then kimi-k3; never the builder's family) → condition: judges disagree, or red twice → agent: frontier judges once → tool: land.sh
  2. trigger: session stops → tool: ledger over the day's transcripts, deduplicated by message id → tool: factory-kpis.json (the one copy) → tool: tasks:bulk writes the day's cost per session onto its rows
  3. trigger: chairman convenes in /u/one/in → tool: the dashboard as the measurement pack → agent: each head claims the rows that move its KPI → delay: the next day's ledger → condition: did the KPI move → tool: mark the rows whose KPI moved, warn the ones that did not

Tools

Receivers and scripts it signals.

  • .claude/scripts/m.sh
  • .claude/scripts/gate-run.sh
  • agent:run
  • tasks:bulk
  • AI Gateway `channels` log (tokens, reasoning tokens, cost per call)
  • .claude/scripts/session-ledger.mjs — to build (deliverable 1); ledger2.py is the scratch prototype
  • .claude/scripts/flash-lane.sh — to build (deliverable 6)
  • .claude/scripts/roster-check.sh
  • .claude/scripts/work-order.mjs
  • .claude/scripts/bake.sh --mark-row
  • world:pick-model
  • thread:append
  • POST /api/billing/transfer

Promises

What it holds; a told promise opens its own story.

Events

Every event is a signal; each names the path it marks or warns.

  • agent:run · from m.sh mark: the model on the card's tag when the judge passes; warn: when the judge refuses its diff tags: factory, cost
  • tasks:bulk · from the ledger none — a write of measured cost onto the rows, not a routing act tags: factory, cost
  • mark · from bake.sh --mark-row, once per judged card mark: the card's shape → the model that built it, when the judge passes; warn: when it refuses tags: factory-optimise
  • thread:append · from chairman, and '<head> · assistant (<model>)' none — the meeting's record, read back from D1 tags: factory-optimise

Transactions

  • none move for the frontier calls — they draw on the subscription's quota; the cheap calls are paid from production's OpenRouter key
  • credits handed to each head by POST /api/billing/transfer (recipient_type agent); each gateway call for the run leaves a credit_burns row (deliverable 21)

Analytics

  • list-equivalent burn per session and per kind (main · subagent · hook), read from ~/.claude/projects/**/*.jsonl, one row per message id
  • AI Gateway `channels` log per call, joined by cf-aig-metadata tags once the tags survive to production (they read null on 2026-09-28)
  • one.ie/web/src/data/factory-kpis.json — every KPI once, read by /factory, /speed, /deploy, the meeting pack and the --assert lines