The Ratchet at the Small Scale¶

The whole argument, compressed. If you only read one post in this series, read this one.

The thesis¶

The Ma of Multi-Agent Systems framework was developed to explain why frontier models behave the way they do when composed through structured tools. Its most interesting predictions aren’t about frontier models. They’re about what happens when you apply the same architecture to the smallest, cheapest, most constrained actors — the 3B parameter models that run on a laptop CPU, take no API budget, and leak no private data to any cloud.

At the small scale, the framework makes a specific, testable claim: the Harness’s job is bigger there than it is at the frontier. A frontier model can survive a bad prompt, a noisy example bank, or a badly-designed tool interface. A 3B model can’t. Every choice the Harness makes about what tools to grant, what language they speak, which examples accompany the request, and when to crystallize successful patterns into cached templates — all of those matter more at small scale because the model has less capacity to compensate for Harness mistakes.

The payoff: if you can get the Harness right, you get a system that runs locally, costs nothing per call, protects privacy by construction, produces decidable outputs, and — over time — needs its own model less and less. The model becomes a vestigial organ. The system teaches itself to not need the thing that created it.

This series is the argument for that payoff, and the empirical record of us figuring out how to make it work.

The five claims¶

1. The round-trip tax is what makes structured tools expensive. When an agent calls structured tools through MCP, every call is a separate turn, and every turn re-processes the full conversation. The cost scales with round-trip count, not with work done. Bash escapes part of this tax by packing more work per call. The Round-Trip Tax documents this and explains why structured tools were 27% more expensive than bash in our experiments, even for the same pass rate on the same task.

2. Restricted code generation collapses the round-trip tax inside a single tool call. If you give the agent a delegate tool that takes natural language and runs a short program inside, the whole composition happens in one turn. The Lackpy Gambit describes the concrete implementation: a decidable subset of Python (no imports, no functions, no while loops, no exceptions) generated by a 3B local model, validated against an AST whitelist, executed with traced namespaces. One MCP call in, many Python tool calls inside, one structured result out.

3. The specialization lives in the language. The 3B model wasn’t trained on lackpy — there is no lackpy corpus — but it produces lackpy programs on day one. This works because lackpy is designed to borrow pre-trained familiarity: the Jupyter-cell framing surfaces patterns the model has seen thousands of times; the restrictions eliminate the failure modes we observed. The Specialization Lives in the Language argues that dialect design is a cheaper path to specialization than fine-tuning, and that a well-designed dialect borrows familiarity rather than teaching new grammar. The model stays general; the language does the specializing.

4. At 3B scale, attention routing matters more than model capacity. Our first attempt at running pluckit’s CSS-selector DSL through a 3B coder model failed — 2/8 correct, worst in the lineup. The fix wasn’t a bigger model or better guidance text. It was reducing the example count from 20 to 6 and retrieving only the relevant ones. Same weights, same queries. The 3B-coder went from 2/8 to 7/8 and became tied for best. The Worst Model Became the Best is the empirical record. The capability was in the weights the whole time. What was missing was the ability to route attention to it through the noise of twenty competing examples.

5. The ratchet eats the model. Every successful lackpy program is a training example. Templates crystallize out of recurring patterns. Rules handle the simple cases. The dispatch hierarchy — templates first, rules second, local model third, API fourth — is the ratchet in code: observations promote downward from expensive tiers to cheap ones. The Tool That Teaches Itself to Disappear works out the dynamics. The steady state is template lookups with a vestigial model used only for the long tail of novel compositions.

Why the small scale is where the framework shines¶

The Ma framework says three axes matter for regulating agent behavior: world coupling (what the actor can reach), decision surface (how many paths through the computation an input can take), and the gap between the two.

At frontier scale, that gap is small because the model’s built-in planning capacity is large. Opus routes attention correctly without much help from the Harness. Sonnet needs a nudge here and there. The framework’s predictions are valid but the effects are modest — an Opus run with a strategy principle is slightly better than an Opus run without, but you’d need a large sample to prove it.

At 3B scale, the gap is enormous. The model’s planning capacity is small. The attention routing is aggressive and local. Everything the Harness does to shape the input has more effect than it does on a frontier model, because the model has less compensatory capacity.

This inverts the usual intuition about where framework-level thinking matters. “Harness engineering” sounds like something you do when you’re building expensive production systems with million-dollar LLM bills and enterprise uptime requirements. The framework says it’s more important for the 3B model on your laptop that costs nothing to run — because that’s where every Harness decision translates directly into observable capability differences.

Our experiments bear this out. The principle instruction that saved Sonnet 20% of its cost was the instruction that made Haiku go from 40% pass rate to 100%. The retrieval layer that sharpened Sonnet’s responses marginally made the 3B-coder go from 2/8 to 7/8. The ratchet cycle that takes days for a frontier agent takes hours for a lackpy deployment. Everything is faster, cheaper, and more observable at small scale.

What’s new in this series¶

This series isn’t a simpler version of the Ma framework. It’s an extension to territory the main framework didn’t cover.

Dialect design as a specialization technique (post 3). The framework treats the tool interface as given. This series treats it as designable, and argues the design is load-bearing.
Attention routing as Harness work (post 4). The framework talks about scope construction and tool grants. This series adds example curation — which demonstrations accompany the request — as a first-class Harness responsibility.
Multi-tier dispatch as the ratchet in code (post 5). The ratchet essay describes the mechanism in general terms. This series shows the concrete implementation: templates > rules > local model > API, with promotion rules and measurable convergence.
The framework holds at micro scale. Ma was developed for multi-agent production systems. Applying it to a 3B inferencer running locally was the stress test. The architecture survived, which is more interesting than it would have been if we’d designed the framework for this case to start with.
The outer agent consumes all of this as a principle, not as infrastructure. From the outer agent’s perspective, delegate(natural language) is one tool call that returns structured results. The retrieval, the 3B model, the validator, the template cache — all of that is inside the tool. The outer agent’s CLAUDE.md says “use delegate for composition” and that’s the whole interface. The ratchet at the inner scale becomes a tool artifact at the outer scale, which becomes a strategy artifact the outer agent’s ratchet eventually caches. Each scale’s output feeds the next.

How to read this series¶

If you’re skeptical that small models can do real work, read post 1 for the cost data, then jump to post 4 for the ranking inversion.

If you’re building a tool and trying to decide between fine-tuning and something else, read post 3 first.

If you want the concrete implementation of a restricted DSL with a small model, read post 2.

If you want to know how this converges in steady state, read post 5.

If you want the theory underneath all of it, start with The Ma of Multi-Agent Systems and come back here when you’re curious about the micro-scale applications.

Next: The Round-Trip Tax — The problem this series solves: structured tools cost more than bash because the protocol overhead dominates the actual work.