Closing the Verification Loop in Generative Development: An External Transactional State Machine and a Field Evaluation of Its Economics and Convergence

1. Introduction

1.1. The Problem

Language models have learned to produce working code from a human’s wish, but not to answer for its readiness. The typical cycle is “write and believe”: the assessment of the result stays subjective, the checks are irregular, and the divergence between the customer’s intent and the product’s behavior is discovered late and expensively. Agent orchestration libraries solve an adjacent problem — managing the course of the dialog — but the task’s state in them lives in the session’s memory and dies with it; a guaranteeing party is absent.

The gap has a measurable price. By the data of this work’s three-hand experiment, a solo execution that is “green in its own way” diverges from the byte-exact reference in 78% of the check rows, while the executor’s self-assessment does not reveal these divergences: finishing the solo product to verifiable quality cost an additional 4–7.5 hours of a live human per batch — against zero for the system hands.

1.2. The Approach

The object of study is an external transactional state machine (punchtape): a console deterministic arbiter that owns the task’s state for good (the canon: requirements, scenarios, checks), accepts typed submissions from an executor agent, compiles the formalism itself, runs every check twice in clean directories itself, and issues a verdict with a cryptographic digest: READY, or an honest NOT-READY with named reasons. The agent never touches the state directly — it can only propose transactions; every submission is either accepted whole or rejected with a one-line reason.

The inversion of ownership is the key difference from embedded libraries: the machine stands outside, the task’s state outlives sessions, and models change without altering what has already been punched into the canon.

1.3. Goal, Tasks, Novelty

The goal is to test whether an external transactional state machine makes “done” reconcilable without paying for the guarantee proportionally, and to measure the price of closing the loop. Tasks: (1) build a field evaluation methodology; (2) measure the economics and quality of the closed loop against the open one; (3) separate functional defects from freedom of interpretation; (4) test the reachability of zero intermediate human attention. The novelty is in the experiment’s design: identical tasks are executed three ways with an independent judicial reconciliation of the products against the byte-exact tables of the machine runs themselves, and all numbers come from transaction ledgers, not self-reports.

1.4. Related Work

Agents in software engineering. The field is systematized by a survey of 124 studies of LLM-based agents across the software lifecycle [1] — the designs surveyed there orchestrate the dialog and the tools, the task’s state living in the session. The same literature contains its own counterpoint: Agentless [2] shows a simple three-phase localize–repair–validate pipeline outperforming complex autonomous agents on SWE-bench Lite at a lower cost. This work takes the counterpoint further: the guaranteeing party is not a smarter or simpler agent but a transactional state machine outside the executor — the state outlives sessions, and the verdict is signed, not asserted.

Closing the loop with verification. A growing line of work equips LLM code generation with verification cycles: Detect–Repair–Verify pipelines for securing LLM-generated code [3]; formal-method guidance that routes LLM-generated safety-critical code through deductive verification and turns each failure into a correction prompt (Forge) [4]; self-generated formal specifications with verifier feedback, where the self-generated specification is itself the measured bottleneck (Self-Spec) [5]; and security tests used as executable specifications shown to the model up front [6]. The machine of this paper belongs to this line with two differences: the checks table is human-readable and the canon is compiled from it by the machine, not a formalism the model authors; and every check is run twice in clean directories by the machine itself — the loop’s owner and the loop’s executor are different parties.

Vibe coding, measured. The open loop this paper studies is the object of a survey of over a thousand works that defines vibe coding formally [7]. Empirically, an assessment of 450 LLM-generated scripts reports ≈85% execution success but ≈45% silent failures of flawed logic behind syntactic correctness, and calls for deterministic wrappers and strict governance [8]. Our field data independently reproduces the same class — “green in its own way”, claim ≠ fact — and measures what a deterministic wrapper costs and buys when it owns the task’s state.

Judges. Since the judges here are LLMs, the known fragility of LLM-as-a-judge evaluation — verdicts sensitive to prompt-induced bias, enough to change task-level conclusions and model rankings [9] — is directly relevant; the design answers it by construction: the judge executes a fixed table row by row, byte-strict, with no right to edit or adapt, a doubt counts against the product, and a calibration must pass before any count is recorded.

2. Materials and Methods

2.1. The Object

The machine is a single binary (Go); the sources and the full documentation are in this repository (v0.2.0). The composition: canon data (every human-readable surface and threshold as data, not code), a transaction journal, a metrics ledger, a compiler from the checks table to scenarios, gates (statics, coverage, tracing, an empty-check probe, the double run), a spec registry, and a render of human-readable per-feature documents (Figure 1).

2.2. Field Campaigns as the Measurement Method

Measurements are performed by field campaigns: batteries of live tasks executed by agents in controlled isolation, with numbers taken only from machine evidence. The rules of an honest run:

• isolation: one task — one agent — one throwaway container; the network is off, 1 CPU, 1 GB of memory; the repository and the documentation are never mounted into the task world (anti-cheating); the materials are read-only;
• the binary is verified: double build, byte-for-byte comparison, the version stamped in, the SHA-256 in the wave journal; inside the compared runs the binary does not change;
• offline builds: every task dependency is pre-cached in the world image; a task that needs the network is refused loudly;
• metrics: from only two sources — the instance ledger (submissions, verdicts, wall, latency) and the executor environment’s accounting (time, tokens, tool calls); taken immediately at completion; every submission carries its environment’s honest token counter;
• a cause registry: every notable expense — a line of “cause → price → who caught it”.

2.3. The Battery

25 tasks: 5 task senses × 5 stacks (python, go, rust, c/c++, js). The senses: a margin detector for scanned images; a two-stage TCP relay; a background job queue over Redis; a file-based static site build; a no-config static site generator from a directory. Each sense exists as five briefs — the wish in living human language with the stack and the libraries pinned; within a sense the briefs are identical, the materials byte-for-byte the same. The battery covers the S band of compactness (utilities with file state); the tasks of one sense are comparable across the five run factors.

2.4. The Comparative Experiment Design

The three-hand mode: every task is executed three ways — (A) the top model GLM-5.3 Max (maximum reasoning mode) through the machine; (B) the budget model GLM-5.3 Flash (high reasoning mode) through the machine; (C) the top model GLM-5.3 Max without the machine (solo). The worlds, the briefs, and the limits are identical; for solo the binary is not mounted. A fourth agent — the judge — receives the checks table of hand (A) for the same task (the byte-exact expectations the machine has already verified) and the solo product, executes every row by hand, and compares the observed byte-for-byte; it has no right to edit the product; a doubt counts against the product. The result — the share of green rows as the measure of strict convergence.

2.5. Hypotheses

• Hypothesis 1 (reconcilability without proportional payment). Moving verification into an executable table with a double run makes “done” a reproducible fact, without requiring a multiple increase in cost relative to the open loop.
• Hypothesis 2 (systemic economy). The cycle’s cost reduction is achieved by properties of the system itself (byte capture by the machine, elimination of manual retranscription, suppression of noisy questions), not by tuning the executor’s prompts.
• Hypothesis 3 (freedom of interpretation). Without an external canon, executors of equal class systematically diverge in reading the same brief; the divergences are not revealed by self-reports and do not correlate with functional quality.
• Hypothesis 4 (the model’s price in the loop). In the closed loop the model class does not determine whether the verdict is reached, but determines the time; the budget model in the system loses on the total cost of the path.
• Hypothesis 5 (zero intermediate attention). For the tasks of the S band, a machine READY is reachable without a single intermediate human answer, with all the forks recorded by the journal and defaults.
• Hypothesis 6 (self-gating overhead). The machine’s own overhead can be subjected to the same gates as the product (budget limits on latency and the ceremony share).

3. Results

All the experiment dates lie in the interval from August 30 to September 3, 2026; the August series ran on a single machine release (v0.1.0); the binary inside each comparison is unchanged. The cost is given at the August 2026 API list prices; for comparability the ratios matter, not the absolute values (the top model’s token is ≈ 9 times more expensive than the flash model’s token).

3.1. The Baseline Run (2026-08-30)

25/25 tasks finished with a machine READY and a successful acceptance; 0 quarantines; the token sum 80.31 M; 53 rejected submissions; 25 questions to the operator.

3.2. The Repeat Full Run (2026-08-30, after a Wave of Systemic Fixes)

25/25 READY; every task run exactly once; tokens 80.31 → 41.00 M (-49%); the task wall median 17.3 → 13.5 min; submissions 219/53 (accepted/rejected) → 142/12; questions to the operator 25 → 3 (all closed autonomously by recommended defaults); submit p95 46–175 ms at the 300 ms budget; the machine’s fix cycles — 4 per battery; 0 quarantines. The methodology and the battery did not change; the changes are only systemic properties of the machine (see hypothesis 2; Figure 2).

3.3. The Three-Hand Experiment (2026-08-31)

75 executor runs (25 tasks × 3 hands) and 25 independent judge runs. The system hands: 50/50 READY + acceptance (25 top + 25 flash), 0 quarantines, a human was never needed. Solo: 25/25 products with green self-checks (from 12 to 283 own checks per task).

The hands’ economics (the summary measures over the 25 tasks of each hand; Table 1):

Solo is the cheapest and the fastest hand; flash is the most expensive by the total path (the cheap step is paid for by the number of steps; Figure 3).

Strict convergence (the judges against the byte-exact tables): 108/491 green rows (22%); per sense (green/rows): conduit 34/97 (35%), pressmark 32/118 (27%), errand 0/77 (0%), brim 24/112 (21%), quire 18/87 (21%) (Figure 4). The pattern’s decoding is stable across all 25 judges:

• the solo functional core is almost always byte-for-byte green (the measured quantities, the built files, determinism, isolation);
• the red mass is protocol, not function: the diagnostics texts, the exit codes, the usage lines, the enumeration formats;
• the same brief forks are decided oppositely by different hands (including the top hands): “three top hands — three different answers”;
• one wave’s zero is an artifact of the comparison surface (the reference table drives the library’s own test driver, which solo does not have); the conditional count with the judge’s minimal driver: 11/11, 24/24, 8/11, 8/10 — 51/56, the library’s behavior is nearly complete;
• the solo real functional failures — 5 per battery, all pinpoint: an RST cut instead of a clean close and the exit code on a taken port (conduit-rust), the missing name field (quire-rust), the silently accepted repeated option (pressmark-js), the “None” string instead of an empty value (quire-python) — inside “green in its own way” they are invisible to the self-report.

Finishing the solo products to verifiable quality (the same battery) is estimated at ≈ $204–240 and 4–7.5 hours of a live human — against zero intermediate participation for the system hands.

The Per-Task Structure (Paired Comparisons)

The run’s full per-task table is Appendix D; its paired structure is more informative than the summaries:

• Flash is slower than top in 24 of the 25 tasks (the only exception — errand-go: 20.8 against 21.8 min). In the absence of an effect, the probability of a preponderance at least this large is $7.7·{10}^{-7}$ (sign test, n = 25 pairs): the flash model’s cheaper step is paid for by the number of steps practically always, not on average.
• The hands’ token medians are almost equal (2.23 / 2.32 / 1.41 M), the tails are not: the top hand’s maximum 7.66 M (conduit-js), the flash hand’s 10.05 M (pressmark-cpp), solo 5.46 M. Flash’s total expensiveness (+11.4% against top) is accumulated by the right tail, not by the typical task.
• Solo is cheaper than top in tokens in 19 of the 25 tasks (p ≈ 0.007, sign test) — solo’s economic advantage is stable at the per-task level, not only in the sum; the losses to top are concentrated in the heavy tasks (errand-cpp 3.31 against 1.56 M, brim-rust 3.04 against 1.77 M).
• The spread inside a hand class is larger than the difference between the classes: the top hand’s tokens 0.60–7.66 M, flash’s 0.66–10.05 M, solo’s 0.39–5.46 M. The dominant factor of a single task’s cost is the executor’s variability (its strategy of probes and rehearsals), not the model class; the system gates quality, the cost variability remains the executor’s property.
• The errand wave’s conditional judge count: the strict 0/77 — the solo product does not have the CLI surface declared by the table (a library plus its own tests); with the judge’s neutral minimal driver the library’s behavior is complete: 51/56 conditionally green (11/11, 24/24, 8/11, 8/10 across the go/rust/cpp/js tasks). The strict red remains an honest fact of the missing surface.

3.4. Human Attention and Forks

In the three-hand run, 74 brief forks (the points where the wish was silent) were closed by the machine’s defaults with a journal and tracing; not one required a live answer. In the repeat full run the operator questions: 25 → 3, all closed autonomously. The escalation rule: when a human decision is requested (code 3/4), the executor applies the recommended option, marks it “awaiting ratification”, and continues — in the isolated worlds nothing is irreversible.

3.5. Environment Observations (the Cause Registry, a Selection)

• An OOM kill (code 137) is a fact of the environment’s limits, not of the task: recreate the world with a larger limit, log the case.
• Files written from a container belong to root: the ownership must be returned before the world’s removal; after every wave — a zero root-owned files check.
• Losing the platform’s metrics taught the rule of taking them from the instance immediately: a lost cell stays lost.
• The baseline’s largest class of losses — the executor’s manual retranscription of expectation bytes (tens of percent of the tasks’ tokens); the machine’s systemic byte capture (the new expectations are measured by a run; the human asserts the meaning) removed the class entirely.
• Library resolution from the throwaway run directories is a property of the world environment, not of the machine; after its systematization the battery’s most expensive task fell from 10.45 to 1.10 M tokens.

3.6. Replication on the Evolved Machine (2026-09-03)

The study above ran on v0.1.0. Before publication the machine went through a series of systemic fixes to the 0.2.0 release (v0.1.x → 0.2.0), and the measurement design was re-run on the evolved machine as a September campaign: two full three-hand waves (wave 1: one sense × five stacks × three hands, 15 cells; wave S: the other four senses × five stacks × three hands, 60 cells — together covering the same 5 × 5 × 3 battery shape as the August series), a release-validation wave on the frozen 0.2.0 candidate (five senses × two stacks × two machine hands, 20 cells, the arbiter’s sha recorded in the wave journal), and a live three-language smoke (ru/en/zh). The prices are the 2026-09-03 market tariffs; as in §3, the ratios, not the absolutes, carry the meaning. All numbers below are the campaign registry’s (docs/METRICS.md), every one mechanically revalidated against the run evidence — the cell captures and the platform ledger; nothing is retyped from a report.

Measurement bases. The September campaign reports the executor’s time as the full wall — the sum of the durations of all the executor’s platform segments, rotations and restarts included (the campaign registry defines the full wall and every other metric’s provenance — docs/METRICS.md §1.2); the August series’ wall is the ledger / environment accounting of its era. The bases differ (the full wall is the stricter one: it adds what a single-segment accounting prunes — the registry’s own basis correction moved 21 multi-segment cells to the full wall), and no comparison in this paper mixes them: the August numbers are compared within Appendices A–D, the September numbers within this section (Table 2).

3.6.1. What Replicated

• Verdicts and quality (hypotheses 1, 5). Every machine run of the campaign closed at VERDICT READY — 50/50 in the three-hand waves, 20/20 on the frozen candidate; the blind double-run measurer found suite ×2 green and 5/5 deliverables in all 75 wave-1+S products (the validation wave: 16/20, the four exceptions are a measured-procedure nondeterminism, not product defects — single runs of the affected rows are green). The smoke reached READY in all three languages with zero question batches.
• The judges’ pattern (hypothesis 3). The September judges reproduce the August decoding: the solo functional core is byte-green, the red mass is protocol and surface. Strict convergence against the top benchmark: solo 87/336 rows (26%), the budget hand 105/336 (31%); 13 of 20 solo acceptances went to a second verification cycle with real findings — the same class of work as the August 4–7.5-hour finishing estimate.
• The model class (hypothesis 4). Identical mechanical quality at both model classes; the flash hand is 3.75× cheaper by the hand mean ($0.31 against $1.16) and ≈2× slower on the full wall (2258 against 1131 s mean) — “time or money”, not a quality tradeoff, confirmed.
• Attention (hypothesis 5). The machine hands triggered operator involvement in 7 of 40 wave-S cells (waits 16–59 s; campaign-wide, at the top model, a batch was triggered in 4 of 25 cells) and in 7 of 20 validation-wave cells (waits 23–216 s, $0.60 in total at the input-rate upper estimate); the solo path needed its acceptance operator at every task — the operator’s AI wall averaged 530 s per task (range 258–937 s), a lower bound for a live human (the anchored estimate: ≈10–18 min per task).
• Economics — sharpened, not just confirmed. The August series priced the hands: solo won the hand’s own tokens (-31%) but its “done” carried an unpriced human finishing (≈$204–240 and 4–7.5 h per batch, §3.3). The September campaign prices the full path — the hand plus its verifying operator, cache-aware tariffs: solo $6.07 per task (hand $4.88 + operator $1.19) against the top hand’s $1.18 (5.1×) and the flash hand’s $0.32 (19×). Under full-path accounting the closed loop is the cheaper path, not the more expensive one — the August conclusion (the benefit is reconcilability, not economy) stands, and its hidden term is now measured (Figure 5; Appendix E). One further measured mechanism: the September solo hand is itself the token-heaviest of the three (5.95M life-tokens per task against the top hand’s 2.78M, cache coverage 58% against 99%) — without a machine that has already verified, the agent re-reads and re-probes its own product; the per-task full-path table is Appendix E (Figure 6).
• Self-gating (hypothesis 6). The validation wave’s criteria closed green: the gate stack green on every tree of the wave, zero lint rejections, zero non-UTF-8 surfaces in the 20 exports, zero zombie incidents, zero journal breaks.

3.6.2. What the Replication Adds

Two findings the August series could not see. First, the artifact-path class: in the validation wave’s cross-judgment (the flash product against the top benchmark) 7 of 10 tasks scored zero strictly because the benchmark rows call the top hand’s declared surface while the flash product declared its own — a brief/conventions fix candidate, not a machine or model defect. Second, the blind-suite nondeterminism of the four validation cells (a container per run, not per case) — an honest boundary of the measuring procedure itself, caught by the double run.

4. Discussion

4.1. Reconcilability, Not Economy

Hypotheses 1–3 are confirmed jointly. The closed loop does not make the task cheaper than solo (solo wins both tokens and time — in the August accounting of the hand’s own work; the September full-path accounting, §3.6.1, counts the verifying operator in the price and flips the sign: the machine path is the cheaper one), but it changes the very subject of the purchase: the executor without the machine delivers “its own opinion of readiness”; the executor with the machine — a product to which an executable exam is attached, re-verifiable at any moment at zero marginal price. Solo’s 22% strict convergence at an almost fully green functional core shows that the gap lies in interface discipline (protocols, texts, codes) — exactly where the contract should live. Freedom of interpretation is a measurable phenomenon: it accumulates across all the brief’s forks and fires at any change of executor; the external fixation of decisions (the canon + the journal of defaults) moves it from invisible to signed.

4.2. The Anti-Entropy Frame

The uncertainty of meaning behaves like entropy: it grows on its own unless it is pumped out. The machine acts as a heat pump: the local reduction of uncertainty is paid for by work — the tokens of double runs, the containers, the computation. By Landauer, erasing a bit costs ≥ kT·ln2 ≈$3·{10}^{-21}$ J; the task’s information entropy (∼${10}^{-15}$ J, even computed generously) is negligible against the ∼${10}^5$ J of real computation — the heat pays not for the annihilation of uncertainty but for search and measurement. The unavoidable forks are not erased but move into an explicit, signed form (question → default → journal); the order is stored: the canon + a green verdict form a “battery of order” that makes regression re-runs nearly free. The result’s formula: cheap measurable heat buys expensive unmeasurable uncertainty.

4.3. The Model’s Price and the Path

Hypothesis 4 is refined by the experiment: the model class does not separate from the verdict (50/50 for both system hands), but separates by time — flash is slower than top in 24 of the 25 tasks (the median 29.0 against 14.4 min; p = $7.7·{10}^{-7}$) at an equal median token price (2.32 against 2.23 M); the “top or flash” choice is “time or money”, not a quality tradeoff. Solo’s economic advantage (cheaper than top in 19 of the 25 tasks, p ≈ 0.007) is real, but it is bought at the price of incomparability: 22% strict convergence means that solo’s “done” is the executor’s private opinion, not a portable fact.

4.4. The Invariance of Quality to the Model Class

The three-hand experiment’s main practical result: the delivery quality does not depend on the model class inside the closed loop — both system hands delivered 25/25 READY + acceptance, 0 quarantines, 0 live questions. The difference is only in time and money (Table 3):

The cheap model in the system delivers the same signed result for twice the time and roughly an eighth of the cost: the cheap step is paid for by the number of steps (the token medians are equal — 2.23 against 2.32 M; flash is slower in 24 of the 25 tasks, p = $7.7·{10}^{-7}$), not by quality. The “top or flash” choice is “time or money” at the same result; outside the loop the same choice is “money or risk” (solo: -31% tokens against top at 22% strict convergence and finishing by a live human).

4.5. The Machine and the Harness: The Separation of Ownership

The harness (the agent’s execution environment) and the machine do not compete: the agent lives in the harness, the machine stands outside and owns the task’s state. The separation of responsibility, as shown by the experiments’ data (Table 4):

The separation formula: the harness runs the conversation; the machine owns the state and the verdict. The economics of closing the loop pays cheap measurable heat (the tokens of the double runs) to pump out expensive unmeasurable uncertainty (the freedom of interpretation); a harness without an external canon gives the solo mode — fast, cheap, and incomparable.

4.6. Validity

• Internal: an unchanged binary inside the comparisons (the double build, the digests); identical briefs, materials, and limits of the hands; anti-cheating isolation; the judges without the right to edit; the control waves between the full runs.
• The reference’s circularity: the judges’ checks table is produced by the very system the experiment evaluates. The mitigations: the table’s rows are the measured bytes of the top hand’s product’s observable behavior, not an opinion; the judge executes the rows independently and by hand; a doubt counts against the product. The residual risk — expectations systematically simplified by the machine would understate the solo assessment — which is why the conditional count with the judge’s neutral minimal driver is given in parallel (item 4 of the pattern’s decoding).
• The statistics of the inference: no parametric intervals were built at n = 25; for the hands’ paired comparisons the sign test was applied (flash against top by time: 24/25, p = $7.7·{10}^{-7}$; solo against top by tokens: 19/25, p ≈ 0.007; the exact binomial probabilities at p = 0.5); the other comparisons rest on the agreement of the sum, the median, and the extremes simultaneously (the hands’ economics table, Appendices A–D). The multiplicity of tests was not corrected: the two tests were chosen a priori, by the main hypotheses.
• Constructive: the numbers — only from the ledgers and the environment’s accounting; one parser; honest notes on the losses and the comparison artifacts (one wave’s zero is parsed and explained; the conditional count is given).
• External (the limits): one difficulty band (S: compact console utilities with file state); one execution environment and one epoch of models; the measurable requirements — the unmeasurable ones (“make it beautiful”) are honestly shelved by the machine into a taste queue for the human; the API prices are volatile. The transfer to the M/L bands, the long tasks, and the other product classes is the subject of the next experiments.

4.7. Prospects

• The M/L bands: extending the battery upward (the large tasks, the multi-file products) after calibrating the bands by the accumulated measurements; the hypothesis to check — the freedom-of-interpretation share grows with the task’s size, and the canon’s benefit grows faster.
• Bootstrap: running the machine’s own development through its own loop — the wishes for the machine as briefs, the loop to the verdict, the pains recorded and cured through its own journal; a direct test of the approach’s scalability beyond the S band.
• Multi-hand and multi-model: the three-hand design generalizes to N hands with a judicial reconciliation against the best table — as the standard acceptance procedure of generative delivery.
• The unmeasurable remainder: the taste and aesthetic requirements need a human; the prospective direction — the formalization of the “taste queue” and safe defaults for it.
• Reproducibility: all the experiment materials — the briefs, the task materials, the world images, the methodology, and the full tables — are in this repository (campaigns/, docs/SAMPLES.md, docs/SCENARIOS.md, docs/METRICS.md — the replication waves’ verified registry), which allows the runs to be repeated independently.

5. Conclusions

• An external transactional state machine moves readiness from an opinion to a signed, re-verifiable fact: 50/50 machine verdicts on a 25-task battery at two model classes (hypothesis 1).
• The cycle’s economics is controllable by systemic properties: -49% of tokens between the two full runs of the same battery without a change of methodology (hypothesis 2); the largest classes of losses (the byte retranscription, the noisy questions, the environment’s resolution) are eliminated as classes.
• The brief’s freedom of interpretation is a measurable and the principal cause of the executors’ divergence (78% of the judge tables’ red rows at a green functional core); the self-reports do not reveal it (hypothesis 3).
• The delivery quality is invariant to the model class in the closed loop: both system hands — 25/25 verdicts; flash delivers the same result for twice the time (slower in 24 of the 25 tasks, p = $7.7·{10}^{-7}$, at an equal median token price) and roughly one-eighth the money (≈ $13.5–16 against ≈ $111–131 per battery); the cheapest hand with a guarantee is the cheap model in the system; the most expensive guarantee is the manual finishing of solo (hypothesis 4).
• The dominant factor of a single task’s cost is the executor’s variability, not the model class: the token spread inside every hand (0.60–7.66 / 0.66–10.05 / 0.39–5.46 M) is larger than the difference of the medians between the hands; the system gates the quality, the cost remains the executor’s property.
• The intermediate human attention between the wish and the verdict for the S band is reduced to zero (74 forks closed by journaled defaults) without losing the machine quality (hypothesis 5).
• The machine’s own overhead is itself gated: the submission latency and the ceremony share stay under the budget in every run (hypothesis 6).
• The results replicate on the evolved machine (v0.1.x → 0.2.0, the September campaign): 75/75 products green by the blind double-run measurer, 50/50 + 20/20 machine verdicts, the judges’ protocol-red pattern reproduced (solo 87/336 strict rows), and the full-path economics made explicit — with the verifying operator priced in, the machine path is the cheaper one (solo $6.07 against top $1.18 per task). Conclusions 1–7 hold beyond the original binary and price epoch.