# Buy the labor, not the judgment

> Lab 011 · Editorial lab · Status: published  
> Published by The CTO Advisor LLC · Layer2C Labs

**Question:** The pitch is that a local bug-fix agent needs a frontier tier in the loop to escalate to. I rebuilt the chain as originally intended: one loop, one deterministic test gate, one feedback contract, run unchanged across 70 real bug-fix pull requests, swapping only the model in the worker and controller seats and metering every call. A frontier model diagnosing the local worker's failures, as the loop's controller, recovered no net task a free deterministic feedback loop did not. The same frontier model doing the labor, as the worker, cleared work the local model could not. So the intelligence belongs in the worker seat, and the test still decides done.

**Load:** Seventy real bug-fix pull requests mined by git archaeology, each shipping the fix's own test suite as an unfalsifiable pass/fail gate. A local 26B reasoning model (Gemma, on a DGX) as the free worker; hosted GPT-5 mini and GPT-5.5 swapped into the worker and controller seats. One stateful repair loop and one deterministic validator held constant across all of it. The benchmark supplies the touched files, so this measures localized repair, not repository search.

## Executive Summary

The pitch under test: a local bug-fix agent needs a frontier tier in the loop to escalate to. The re-run held one loop architecture, one deterministic test gate, and one feedback contract constant across 70 real bug-fix pull requests, and swapped only the model in the worker and controller seats.

The free local worker with stateful deterministic feedback recovered 14 of the 22 tasks it first missed. Adding a frontier model as the controller diagnosing those failures recovered no net task the free loop did not, 13 to 13 on the tasks both arms ran cleanly. The controller was the wrong place to spend intelligence.

The right place was the worker seat. In the same harness, moving from the local 26B to a frontier worker took recovery from 14 to 20 and cleared most of a hard residual tail. A weak worker cannot act on a good diagnosis. The tier has to hold the pen.

The economics split by how you buy tokens. Metered, reserve the frontier for the tail. On a flat subscription its labor is free up to the cap, so run it as the worker. The metered account hit its quota and stopped the experiment mid-run; the subscription arm did not.

## DAPM Table — Authority Verdict

| Layer | Placement |
| --- | --- |
| layer0 | Retained |
| layer2b | Retained |
| layer2c | Retained |

## Seam Map — Readiness

| Function | Readiness |
| --- | --- |

## Detailed Writeup

Four arms shared one harness: one model emits a search-and-replace edit, a deterministic gate replies with the test result, and the loop iterates up to four times. Only the model in the worker and controller seats changed. That shared harness is what makes the four comparable.

The free local worker recovered 14 of its 22 first-attempt misses on rich deterministic feedback alone. A GPT-5.5 controller reading each failure and advising the same worker recovered no additional matched task, and it held across three seeds: 13-13, 10-10, and 11-10 on the tasks both arms ran cleanly, never once ahead, for about ninety-eight thousand frontier tokens a run spent to draw even. That controller saw only the current failure. Handed the full trajectory instead, a fair variant, it nudged to 13-11 on one subset, a faint edge inside the sampling band, worth another seed but not yet a result.

Moving the frontier model out of the control seat and into the worker seat, same harness, took recovery to 20 of 22 and cleared three of the five hardest residual tasks. The lever was never the loop or the diagnosis. It was which model held the pen. A weak worker cannot execute a good diagnosis, so buying the frontier's judgment as control is buying the wrong thing.

A fifth run cleared all 22, but it swapped the harness for Claude Code, an agentic loop with tools and file exploration, so it is held out of the comparison. It changed two variables at once and proves neither. Whether the agentic harness or the model did that work is a separate lab, and the clean way to run it is to hold Claude Code fixed and drop in a less capable model. That lab has since run. Lab 012 re-ran this fifth arm on the metered API with per-task usage capture: 22 of 22 again, $13.79, 10.96 million tokens. And the separation came back against the tier: a mini model in the same harness matched all 22 for $3.14. The harness was the lever.

## Assessments at the Time of the Lab

| Vendor | Layer | Grade | As assessed |
| --- | --- | --- | --- |
| NVIDIA AI Platform | Layer 0 · Compute | NVIDIA Strength — Silicon Authority | July 23, 2026 |
| NVIDIA AI Platform | Layer 2C · Reasoning | Runtime Governance Only — Not a Reasoning Plane | July 23, 2026 |

## Method and Disclosure

Self-funded editorial. The harness is loopcontrolbench, published open under the MIT license at github.com/kltownsend/loopcontrolbench: the reproduce-or-drop gate, the sandboxed runner, and the arm definitions. The vendor assessments and the layer placements this evidence feeds stay proprietary.

---
*Layer2C Labs · The CTO Advisor LLC · labs.layer2c.com*