Part 1 was about a machine that refutes its own ideas with executable code. This is a shorter, sharper story from one stage of it: the moment the machine had to put a number on what to think about next. A value function is a measurement, and the fastest way to ship a broken measurement is to trust an average — so this one is built not to.

The system doing the thinking

A word first on what is now running the loop, because the shape of the hardware is the shape of the argument.

Somnus is three model families in a funnel, feeding a cloud oracle:

  • Generation — Gemma 3 12B on an AMD Radeon RX 7900 XT proposes candidate questions from the gaps between existing findings.
  • Screening — Mistral Small 24B on an AMD Radeon AI PRO R9700 rejects only certain noise and ranks the rest.
  • Adjudication — Claude (Sonnet 5 researchers, an Opus 4.8 assembler) runs the expensive, decisive step in the cloud.

The second card is new, and it is worth being exact about why it earns its slot, because it is not the obvious reason. A second GPU buys throughput, and throughput was never the constraint — the generator’s queue was already saturated. What the 7900 XT bought is prior diversity, and the end of time-sharing. Three lineages — Gemma, Mistral, Claude — hold three different sets of blind spots, so their agreements and disagreements carry signal a single family cannot manufacture; the funnel’s value is that divergence, not raw compute. And with two cards, generation and screening run concurrently instead of one card swapping models in and out of VRAM between roles. Three families, three stages, one cloud — that is the whole instrument, and everything below is one stage of it, examined closely.

A value function is a measurement

For most of its life Somnus was a grab bag: generate every plausible cross-domain question, screen it, keep the good ones. It never ran dry and it never arrived anywhere — a pile with no gradient. The deliberate fix was to focus: take one goal question, break it into a handful of falsifiable sub-questions, and grind that topic until it is compressed into something validated.

Focus is precisely what turns generate more into a pricing problem. At any moment thousands of candidate questions touch the topic, against a fixed budget: the local models are effectively free, the cloud oracle is not. So the machine must put a price on each candidate — resolve this locally, or spend real money on it at the frontier? — and that price is a measurement of one thing: how much the candidate would reduce the topic’s remaining uncertainty. Get the measurement wrong and every downstream euro is misspent with confidence. That is the whole reason this stage gets the scrutiny it does.

The price has to respect the structure of the topic. Seven sub-questions are seven distinct directions to be uncertain in. A value function that flattens them into one has not found a cheaper measurement — it has found a wrong one, and thrown away the only thing focusing was for.

A U-shaped curve: the cost of stating a law rises with precision, the cost of its exceptions falls, and their sum bottoms out at the best explanation.
The floor under all of it: the best hypothesis is the one that compresses the data to its shortest total description — the bottom of the U, neither too generic to predict nor so precise it memorises the noise.

The trap the algebra guarantees

The obvious value function almost writes itself: score a candidate c by its relevance to each sub-question, weight by how uncertain that sub-question still is, and add them up. It is also, provably, a trap — and a trap you can see coming with one line of algebra, which means it is a trap you check for rather than discover.

A weighted sum of cosine similarities is identically a single cosine to one resultant vector. The seven directions collapse into their weighted average before the candidate is ever compared to them; the sum can express exactly one direction, no matter how many sub-questions you feed it. So the prediction is not subtle: this value function will rank candidates purely by centrality to the topic’s mean, and the sub-question structure will be inert.

Measured on the live container — 1793 candidates, seven sub-questions — that is exactly what it does, at r = 1.000 against plain cosine-to-the-centroid. Six of the seven sub-questions were doing no work at all. The point of the measurement was never surprise; it was confirmation that a known failure mode was, or was not, present. It was.

Two scatter plots of candidate value against centrality. Left, the linear sum: a perfect diagonal, r equals 1.00. Right, per-candidate centering: a formless cloud, r about 0.03.
Same candidates, two aggregations. The linear sum (left) is a perfect proxy for one direction — centrality — exactly as the algebra says it must be. Centring each candidate first (right) breaks the tie and hands the structure back.

Reading the shape, not the sum

The fix is two moves, and the order matters, because the obvious repair does nothing alone.

First, read a peak, not a total. Replace the linear sum with a log-mean-exp, which interpolates smoothly between the average (cold) and the maximum (hot) and can therefore reward a candidate that hits one sub-question hard rather than everything weakly. But on this corpus the relevance profiles are nearly flat, and a soft maximum of a flat profile is still its mean — so log-mean-exp alone left the collapse standing.

The move that actually mattered was per-candidate centring: subtract each candidate’s own mean relevance before aggregating. That removes the level of the profile — which is the centrality that went to r = 1.000 — and leaves only its shape. The correlation fell from 1.000 to 0.03; three of the seven sub-questions took the lead across different candidates. Absolute relevance is real signal, so it returns — but as a multiplier on the shape, never an additive term, because adding the mean back is, by the algebra above, re-introducing the exact quantity that caused the collapse.

A curve peaking sharply at a low-to-mid temperature: the number of distinguishable sub-questions is maximal at a critical beta and decays toward one at both hot and cold extremes.
β as temperature. Too hot and every candidate melts back into the average; too cold and only the single sharpest sub-question ever registers. The structure is richest in a narrow critical band — and that is where the aggregator is set to sit.

The value function is one stage of the funnel, and the fix only matters because of where it sits.

A three-stage funnel: Gemma on the 7900 XT generates candidates, Mistral on the R9700 screens with a loose reject gate, the container value function ranks and flags the frontier, and Claude adjudicates only at the frontier.
Where the value function lives. Generation and screening are free and run on the two local cards; the value function orders what to grind locally and flags the frontier; only the frontier — relevant, uncertain, and locally unresolvable — reaches the paid oracle.

The discipline that catches it

None of this was found by staring at outputs and getting a bad feeling. A value function is not trusted here until it is shown to preserve the structure it claims to use, and the showing is one measurement: aggregate the value, correlate it against the single-direction projection, and if r → 1.0, the structure is gone. One number, run before a euro is spent on the ranking it produces — the same look before you build that runs through the whole instrument, pointed at a formula instead of a database.

The honest result — r = 1.000 — is the entire value of the check. A value function that looks decisive while secretly ranking on one axis is worse than an obviously broken one, because it spends real money with false confidence. And the same test was then run across the rest of the pipeline — the generator’s prior, the screener’s score, the essence relevances — to see whether the averaging trap had leaked anywhere else. It had not; the container’s core was the only genuine collapse. That is the cheapest insurance there is: one correlation that stops a structural error from living in production for months.

What it buys

With the structure restored, the container does the job it was built for — rank the topic’s queue locally for nothing, and spend only at the frontier. The first paid cloud ignite landed the way Part 1’s thesis says it should: handed a candidate, the three cloud researchers refused it, catching a category error in the question itself and verifying the refutation with a null model in code rather than argument. The loop fed itself two validated facts and five testable hypotheses, and the machine’s honesty held under its own money.

The numbers that make this quantitative — the critical β, the resolvability calibration, the escalation threshold, the cost of a frontier decision in bits per euro — are the subject of their own paper. What belongs here is the shape of the lesson: linear aggregation destroys structure whenever the structure lives in the peaks and not the average, and the discipline is to know that in advance, forbid the average on purpose, and prove the replacement before trusting it. A machine that can hold that line inside its own value function is, in one small and specific way, doing the thing it was built to do.

— SF3D