Issue 22: The Crossover Line
A locksmith with one key to copy does not build a jig. He clamps the blank, files it by eye against the original, checks it in the lock, done in minutes. Ask him for five hundred and he makes a template first, the better part of an hour, then cuts. After it exists each copy takes seconds and comes out identical. The template is pure overhead on the first key and pure profit by the fiftieth.
Nothing about the key changed between those two jobs. What changed is how many he was going to make. The decision to build the template was never a fact about keys. It was a fact about volume.
This month a piece of advice went round for people running Claude Code, the harness that can drive several models at once: give each model a fixed role and set it once. Let the expensive model plan, the mid-tier write code, the cheapest search, never think about it again. It is tidy and mostly sound, and three posts in one week sold it as solved and static. Each makes the locksmith's first mistake: it assigns work by the kind of work, as if "this is a search" settled it, when what settles it is how many times that exact shape comes back.
This studio has routed its own work by the opposite rule for months, logging every decision. This week's free tool is that calculation. The paid flagship is what happens when you give it a memory.
Three from the wave this week. Each read through one question: route by task type set once, or by how often the work actually recurs?
- A widely shared post lays the pattern out in its purest form (@cyrilXBT, 16 Oct 2026, x.com/cyrilxbt/status/2110924952736325899): one setting flips Claude Code so each model has a role, the expensive one plans, the mid-tier writes code, the cheapest searches, a critic agent checks the diff. Nothing in it reports running the setup long enough to learn when a role is wrong; a static config cannot notice.
- A second frames the same split as "Anthropic just documented one of the best setups" (@mirku21, 19 Oct 2026, x.com/mirku21/status/2112287724853989810). The attribution overstates: the two settings it leans on are real documented options, the tripartite setup is the author's own assembly. Its one good instinct, letting a cheap signal decide the easy branches, is still drawn as fixed wiring, not a threshold that moves.
- A third sells the same temperature as a business (@Argona0x, 19 Oct 2026, x.com/Argona0x/status/2112260472246612365): an overnight agent said to have left fifty thousand dollars a month on the table. Read with the discount it is owed: a pipeline value, not revenue, no outreach sent, no public repository or data. Cited for the mood of the week, not as evidence.
Both tools follow The Read. crossover_line.py, free and runnable below, routes each task shape by its break-even repetition count instead of its type. Crossover Memory, the paid flagship below the cut, catches a shape that quietly crossed its line while the policy still pays frontier rates.
The Read: the cheap path is a volume decision, not a type
Start with the oldest version of the problem. In 1776 Adam Smith watched a pin factory: ten workers each specialising in one step made tens of thousands of pins a day, where one doing every step alone would struggle to make twenty. Smith added the limit in the same breath, the part people forget: the division of labour is limited by the extent of the market. The specialist who only sharpens points is a loss until you make enough pins to keep them busy. The gain is real and exists only above a certain volume.
George Stigler made that limit a law in 1951 (Journal of Political Economy, 59(3)): a step is split into its own cheaper process only when the volume pays back the setup cost. Ronald Coase drew the same boundary from the other side in 1937 (Economica, 4(16)): a firm makes a thing in-house or buys it on the market by whichever is cheaper at its scale. Make versus buy is not a property of the thing but of how much of it you need.
Now put a task shape where the pin was. To route a recurring job to a cheap path, a free local model or a script, you first prepare that path once at a fixed cost B: the generator or fixture that lets the cheap thing do the job reliably. After that each instance costs almost nothing, call it f; without it each runs on the paid model at cost p. Preparing and running the next R instances cheaply costs B plus R times f; keeping those R on the paid model costs R times p. The cheap path wins once R pays B back, and the two cross at
N* = ceil( B / (p - f) )
Below N*, keep it paid: the template is not worth cutting yet. Above N*, build the cheap path. The deciding variable is R, how often the shape recurs, which is nowhere in "this is a search" or "this is a code edit". Two tasks of identical type sit on opposite sides of the line the moment one recurs often and the other twice. A fixed role cannot say that: it committed before it knew the count.
The twenty-minute version
List the task shapes you keep doing. For each, write four numbers: times recurred, times expected (past frequency is a fair first guess), the one-time cost to build a cheap path, and the per-instance cost on the expensive model now. The free tool below prints each shape's crossover and whether a role-by-type policy routes it right, marking MISROUTED the shapes where your config spends frontier money on work too rare to earn a template, or grinds by hand on something that crossed its line long ago.
The cheap path is a jig. You cut the jig when the count says so, not because someone told you keys go on the machine.
The Tool: crossover_line.py
The free, from-scratch tool this week. Give it task shapes, each with a recurrence count, expected remaining count, the one-time cost to prepare a cheap path, and the per-instance paid cost. It computes the break-even and, where you supply what your fixed-role policy would do, says whether that action agrees or is misrouted, and by how much. Standard library only.
#!/usr/bin/env python3
"""crossover_line.py - decide per task shape whether to offload to a cheap path
or keep it on a paid model, by the break-even repetition count, not the task type.
The popular advice is a fixed role assignment: let the frontier model plan, let a
cheap model execute, let the cheapest model search, set it once and leave it. That
treats "offload this" as a property of the KIND of work (code, search, planning).
It is not. Whether to prepare a cheap reusable path for a task shape is an
investment decision, and the thing it depends on is how many more times that exact
shape will recur, not which bucket it falls in.
Adam Smith's pin factory (The Wealth of Nations, 1776) and George Stigler's
formalisation (The Division of Labor is Limited by the Extent of the Market,
Journal of Political Economy, 1951) name the law underneath: you only specialise a
step, build the jig, stand up the dedicated cheap line, when the volume is there to
pay back the fixing cost. Ronald Coase (The Nature of the Firm, Economica, 1937)
names the same boundary from the other side: you internalise a task (build the
reusable path) or transact it each time (pay the paid model per instance) according
to which is cheaper at the volume you actually have.
So the decision is a crossover, not a category:
To route a shape to the cheap path you first PREPARE it once, at a fixed cost B
(write the generator, the fixture, the template). After that each instance costs
f on the cheap path. With no preparation each instance costs p on the paid model.
cost of preparing and offloading R more instances : B + R*f
cost of keeping R more instances on the paid model : R*p
crossover N* = ceil( B / (p - f) ) (requires p > f: the cheap path must be
cheaper per instance, or offload never wins)
OFFLOAD if the expected remaining occurrences R >= N*, else KEEP-ON-PAID.
A fixed role assignment commits to one action for a whole bucket. This tool takes,
for each shape, the action that role assignment would commit to (fixed_role:
"offload" or "keep"), computes the crossover-correct action, and reports:
AGREES the committed action matches the crossover-correct action.
MISROUTED the committed action is wrong for this shape at this volume. The tool
shows how many times more the committed action costs than the right
one over the expected remaining occurrences.
A shape with no fixed_role is reported with its crossover-correct action and does
not affect the exit code.
Input: a JSON object {shapes:[...]} (plus optional defaults free_cost). Each shape
is {name, seen, horizon?, build_cost, paid_cost, free_cost?, fixed_role?}. seen is
the recurrence count observed so far; horizon is the expected remaining occurrences
(defaults to seen, the honest naive estimate that past frequency predicts future
frequency).
Exit 0 when every shape carrying a fixed_role AGREES. Exit 1 when at least one is
MISROUTED. Exit 2 on a read, parse or register error. Standard library only.
"""
from __future__ import annotations
import argparse
import json
import math
import sys
def _non_negative_number(value, field):
"""Return value as a non-negative number, or raise ValueError naming the field.
A cost or count that is negative or non-numeric is a broken register, not a
zero: refuse it rather than silently coerce."""
if isinstance(value, bool) or not isinstance(value, (int, float)):
raise ValueError("%s must be a number, got %r" % (field, value))
if value < 0:
raise ValueError("%s must be >= 0, got %r" % (field, value))
return value
def crossover(build_cost, paid_cost, free_cost):
"""The break-even repetition count N*: the number of remaining occurrences at
which preparing the cheap path first pays back its fixing cost. Raises
ValueError if the cheap path is not actually cheaper per instance."""
if paid_cost <= free_cost:
raise ValueError(
"paid_cost (%r) must exceed free_cost (%r): if the cheap path is not "
"cheaper per instance, offloading never wins at any volume"
% (paid_cost, free_cost))
return math.ceil(build_cost / (paid_cost - free_cost))
def classify(shape, default_free_cost=0.0):
"""Classify one task shape. Returns a result dict. Raises ValueError on a
malformed shape."""
if not isinstance(shape, dict) or "name" not in shape:
raise ValueError("each shape needs a 'name'")
name = str(shape["name"])
for required in ("seen", "build_cost", "paid_cost"):
if required not in shape:
raise ValueError("shape %r has no '%s'" % (name, required))
seen = _non_negative_number(shape["seen"], "seen for %s" % name)
build_cost = _non_negative_number(shape["build_cost"], "build_cost for %s" % name)
paid_cost = _non_negative_number(shape["paid_cost"], "paid_cost for %s" % name)
free_cost = _non_negative_number(
shape.get("free_cost", default_free_cost), "free_cost for %s" % name)
# horizon defaults to seen: the honest naive estimate, past frequency as the
# predictor of future frequency. A caller with a real forecast overrides it.
horizon = _non_negative_number(
shape.get("horizon", seen), "horizon for %s" % name)
n_star = crossover(build_cost, paid_cost, free_cost)
correct = "offload" if horizon >= n_star else "keep"
cost_offload = build_cost + horizon * free_cost
cost_keep = horizon * paid_cost
fixed_role = shape.get("fixed_role")
if fixed_role is not None:
fixed_role = str(fixed_role).lower()
if fixed_role not in ("offload", "keep"):
raise ValueError(
"fixed_role for %s must be 'offload' or 'keep', got %r"
% (name, shape["fixed_role"]))
verdict = None
waste_ratio = None
if fixed_role is not None:
if fixed_role == correct:
verdict = "AGREES"
else:
verdict = "MISROUTED"
# how many times more the committed action costs than the right one
if fixed_role == "offload": # committed to offload; keeping is cheaper
waste_ratio = cost_offload / cost_keep if cost_keep else float("inf")
else: # committed to keep; offloading is cheaper
waste_ratio = cost_keep / cost_offload if cost_offload else float("inf")
return {
"name": name,
"seen": seen,
"horizon": horizon,
"crossover": n_star,
"crossover_correct": correct,
"fixed_role": fixed_role,
"verdict": verdict,
"cost_offload": cost_offload,
"cost_keep": cost_keep,
"waste_ratio": waste_ratio,
}
def audit(config):
"""Classify every shape in a register. Returns (results, misrouted_count)."""
if not isinstance(config, dict):
raise ValueError("register must be a JSON object")
shapes = config.get("shapes")
if not isinstance(shapes, list) or not shapes:
raise ValueError("register needs a non-empty 'shapes' list")
default_free = config.get("free_cost", 0.0)
_non_negative_number(default_free, "default free_cost")
results = [classify(s, default_free) for s in shapes]
misrouted = sum(1 for r in results if r["verdict"] == "MISROUTED")
return results, misrouted
def _fmt(x):
return "%d" % x if float(x).is_integer() else "%.2f" % x
def render(results, misrouted):
lines = ["CROSSOVER LINE: route by break-even, not by task type", ""]
for r in results:
lines.append(" %s" % r["name"])
lines.append(" seen %s, expect %s more; crossover N* = %s"
% (_fmt(r["seen"]), _fmt(r["horizon"]), _fmt(r["crossover"])))
lines.append(" crossover says: %s (offload costs %s, keep costs %s)"
% (r["crossover_correct"].upper(),
_fmt(r["cost_offload"]), _fmt(r["cost_keep"])))
if r["fixed_role"] is None:
lines.append(" no fixed role supplied: informational only")
elif r["verdict"] == "AGREES":
lines.append(" fixed role says %s: AGREES" % r["fixed_role"].upper())
else:
lines.append(" fixed role says %s: MISROUTED. The committed action costs"
% r["fixed_role"].upper())
lines.append(" about %.1fx what the crossover-correct action costs here."
% r["waste_ratio"])
lines.append("")
if misrouted:
lines.append("VERDICT: MISROUTED. %d of %d shapes are routed by type against what"
% (misrouted, len(results)))
lines.append(" the break-even repetition count says. A fixed role cannot")
lines.append(" express a crossover; it has to be recomputed, not configured")
lines.append(" once. Stigler 1951: specialise a step only where the volume")
lines.append(" pays back the fixing cost.")
else:
lines.append("VERDICT: SOUND. Every committed action matches its crossover.")
return "\n".join(lines)
def run(path, as_json):
try:
with open(path, encoding="utf-8") as fh:
config = json.load(fh)
except OSError as exc:
print("cannot read %s: %s" % (path, exc), file=sys.stderr)
return 2
except json.JSONDecodeError as exc:
print("cannot parse %s: %s" % (path, exc), file=sys.stderr)
return 2
try:
results, misrouted = audit(config)
except ValueError as exc:
print("bad register in %s: %s" % (path, exc), file=sys.stderr)
return 2
if as_json:
print(json.dumps({"results": results, "misrouted": misrouted}, indent=2))
else:
print(render(results, misrouted))
return 1 if misrouted else 0
# (shape, expected crossover_correct, expected verdict). Each is a fact the
# classifier must get right.
SELF_TESTS = [
# recurs far below crossover; a type-based "offload" is MISROUTED
({"name": "rare-edit", "seen": 5, "build_cost": 300, "paid_cost": 3,
"free_cost": 0, "fixed_role": "offload"}, "keep", "MISROUTED"),
# same shape, now recurs well past crossover; "offload" AGREES
({"name": "nightly-edit", "seen": 140, "build_cost": 300, "paid_cost": 3,
"free_cost": 0, "fixed_role": "offload"}, "offload", "AGREES"),
# high volume but a timid "keep" leaves money on the table: MISROUTED
({"name": "kept-too-long", "seen": 500, "build_cost": 300, "paid_cost": 3,
"free_cost": 0, "fixed_role": "keep"}, "offload", "MISROUTED"),
# exactly at the crossover offloads (R >= N*)
({"name": "at-line", "seen": 100, "build_cost": 300, "paid_cost": 3,
"free_cost": 0, "fixed_role": "offload"}, "offload", "AGREES"),
# one under the crossover keeps
({"name": "just-under", "seen": 99, "build_cost": 300, "paid_cost": 3,
"free_cost": 0, "fixed_role": "keep"}, "keep", "AGREES"),
# a cheap-to-prepare shape crosses almost immediately
({"name": "cheap-jig", "seen": 4, "build_cost": 6, "paid_cost": 3,
"free_cost": 0, "fixed_role": "offload"}, "offload", "AGREES"),
# no fixed role: reported, no verdict
({"name": "informational", "seen": 5, "build_cost": 300, "paid_cost": 3},
"keep", None),
]
def self_test():
passed = 0
for i, (shape, expected_correct, expected_verdict) in enumerate(SELF_TESTS):
try:
r = classify(shape)
ok = (r["crossover_correct"] == expected_correct
and r["verdict"] == expected_verdict)
got = "%s/%s" % (r["crossover_correct"], r["verdict"])
except ValueError as exc:
ok = False
got = "ERROR(%s)" % exc
passed += ok
print(" %-4s case %-2d expected %-14s got %s"
% ("PASS" if ok else "FAIL", i,
"%s/%s" % (expected_correct, expected_verdict), got))
# a malformed shape, and a cheap path that is not cheaper, must both raise
bad_cases = [
{"seen": 1, "build_cost": 1, "paid_cost": 1}, # no name
{"name": "x", "seen": 1, "build_cost": 1}, # no paid_cost
{"name": "x", "seen": 1, "build_cost": 1, "paid_cost": 2, "free_cost": 2}, # p == f
{"name": "x", "seen": -1, "build_cost": 1, "paid_cost": 2}, # negative
]
for bad in bad_cases:
try:
classify(bad)
print(" FAIL malformed shape did not raise: %r" % (bad,))
except ValueError:
passed += 1
print(" PASS malformed shape refused: %s"
% bad.get("name", "(no name)"))
total = len(SELF_TESTS) + len(bad_cases)
print()
print("SELF-TEST: %d/%d checks passed" % (passed, total))
return 0 if passed == total else 1
def main():
ap = argparse.ArgumentParser(
description="Route each task shape by its break-even repetition count.")
ap.add_argument("register", nargs="?", help="JSON object {shapes:[...]}")
ap.add_argument("--json", action="store_true", help="machine-readable output")
ap.add_argument("--self-test", action="store_true",
help="run built-in checks and exit")
args = ap.parse_args()
if args.self_test:
return self_test()
if not args.register:
ap.error("a register path is required unless --self-test is given")
return run(args.register, args.json)
if __name__ == "__main__":
sys.exit(main())
Feed it a three-shape policy: a rare manual edit a role-by-type rule would push to the cheap worker, a nightly stamp that genuinely recurs, and the weekly issue draft the studio keeps paid.
CROSSOVER LINE: route by break-even, not by task type
lp-frontmatter-field-insert
seen 5, expect 5 more; crossover N* = 100
crossover says: KEEP (offload costs 300, keep costs 15)
fixed role says OFFLOAD: MISROUTED. The committed action costs
about 20.0x what the crossover-correct action costs here.
nightly-store-highwater-stamp
seen 140, expect 140 more; crossover N* = 100
crossover says: OFFLOAD (offload costs 300, keep costs 420)
fixed role says OFFLOAD: AGREES
weekly-issue-draft
seen 22, expect 22 more; crossover N* = 118
crossover says: KEEP (offload costs 4132, keep costs 880)
fixed role says KEEP: AGREES
VERDICT: MISROUTED. 1 of 3 shapes are routed by type against what
the break-even repetition count says. A fixed role cannot
express a crossover; it has to be recomputed, not configured
once. Stigler 1951: specialise a step only where the volume
pays back the fixing cost.
Exit one. The first shape recurs five times against a crossover of a hundred, so a cheap path for it would cost about twenty times the paid model, and a role-by-type rule that offloads it is wrong by that factor. The nightly stamp recurs a hundred and forty times, so offloading is right; the weekly draft recurs rarely and is costly to template, so keeping it paid is correct, which is where the studio keeps this issue. A sound policy flips the verdict to SOUND at exit zero. The --self-test runs eleven planted cases across all four quadrants, four of which must raise; all eleven pass.
Founder offer
If you route work to a cheap path by its type, free local models, scripts, a cheap tier, run this register against your task list today. The free tool shows which shapes your static config misroutes now; the flagship shows which crossed their line weeks ago while each decision to keep paying looked correct.
Pro is $15 a month or $250 a year: the Brief, the paid flagship tool, the paid Feed payload, and the archive. Founder is $300 a year, capped at one hundred seats, with a founders-only MCP server built once the hundredth seat sells. Terms: nonxerosum.studio/mcp.
No pitch beyond that. The crossover is the argument.
