Onze agents
leren metenLearning to
measure our agents

✓Live bewijs: de methode draaideLive proof: the method ran

Stap 1 was makkelijk, en dat was het probleemRound 1 was easy, and that was the problem

Eerste suite: 8 code-taken. Alle vijf agents haalden 1.000. Mooi, maar nutteloos: een meetlat die iedereen even hoog geeft, méét niets. Dit is de sleutel-inzicht van de hele methode: een benchmark is pas een benchmark als hij de kandidaten uit elkaar trekt. First suite: 8 code tasks. All five agents scored 1.000. Nice, but useless: a yardstick that gives everyone the same height measures nothing. This is the key insight of the whole method: a benchmark only becomes a benchmark when it pulls the candidates apart.

Stap 2: verzwaar tot het discrimineertRound 2: harden until it discriminates

Ik schreef 6 randgeval-zware taken (wildcard-match, min-window, expressie-parser, geldige-haakjes, getal-naar-woorden, kolomtitel) en verifieerde eerst de asserts met eigen referentie-oplossingen (anders straf je goede code met een foute test). Zelfde harde scorer: de gegenereerde code wordt echt uitgevoerd tegen verborgen asserts. Toen trok de meetlat wél uit elkaar: I wrote 6 edge-case-heavy tasks (wildcard match, min window, expression parser, valid parentheses, integer-to-words, column title) and first verified the asserts against my own reference solutions (else you penalise good code with a broken test). Same hard scorer: the generated code is actually executed against hidden asserts. Now the yardstick did separate:

* De vier frontier-agents halen nog steeds alles: hun horizon is op déze suite "insensitive" (geen spreiding), en dat is een eerlijk, niet-verzonnen resultaat. Het zegt: om die vier te rangschikken moeten de taken nóg zwaarder. De lokale Qwen-coder zakt naar 0.667: hij haalt patroon-, DP- en formatteer-taken maar valt op de twee stateful-algoritmes (min_window en calc). Zijn 50%-tijdshorizon is een echte fit: ~23 minuten mensenwerk. * The four frontier agents still pass everything: their horizon on this suite is "insensitive" (no spread), an honest, non-fabricated result. It says: to rank those four, the tasks must get harder still. The local Qwen-coder drops to 0.667: it handles pattern, DP and formatting tasks but trips on the two stateful algorithms (min_window and calc). Its 50% time-horizon is a real fit: ~23 minutes of human work.

Dit is de kern: de meetlat zelf wordt geïtereerd tot hij scheidt. Verzadiging is geen succes, het is een signaal om te verzwaren. This is the core: the yardstick itself is iterated until it separates. Saturation is not success, it is a signal to harden.

De €0-truc: Opus in het leaderboard zonder gemeterde rekeningThe €0 trick: Opus in the leaderboard with no metered bill

Zonder deze truc zou onze primaire denker (Opus) buiten het leaderboard vallen, want Inspect's standaard Anthropic-pad tikt de gemeterde console-rekening aan, precies wat we vermijden. De provider (providers/claudep.py, 30 regels) haalt Opus binnen tegen €0. Dat is het verschil tussen "we meten de goedkope modellen" en "we meten álles, ook onze beste". Without this trick our primary thinker (Opus) would fall outside the leaderboard, because Inspect's default Anthropic path hits the metered console bill, exactly what we avoid. The provider (providers/claudep.py, 30 lines) brings Opus in at €0. That is the difference between "we measure the cheap models" and "we measure everything, including our best".

◆De methode, in 7 stappen (het herbruikbare recept)The method, in 7 steps (the reusable recipe)

Dit is het foundationele deel. Niet "we gebruikten Inspect", maar de manier van werken die je op elke agent, elk domein, kunt herhalen. This is the foundational part. Not "we used Inspect", but the way of working you can repeat on any agent, any domain.

1Het gat: we raden onze eigen kwaliteitThe gap: we guess our own quality

Onze Heilige Regel zegt: de slimme modellen beslissen, de goedkope genereren, en generator ≠ verifier. Maar één schakel ontbreekt: bewijs. Toen de Qwen macro-writer van 8% naar 83% slaagkans ging, was dat een handmatige meting, één keer. We hebben geen herhaalbare meetlat die zegt of een modelwissel ons beter of stiekem slechter maakt. Our Sacred Rule says: the smart models decide, the cheap ones generate, and generator ≠ verifier. But one link is missing: evidence. When the Qwen macro-writer went from 8% to 83% pass rate, that was a manual, one-off measurement. We have no repeatable yardstick that tells us whether swapping a model makes us better or quietly worse.

Je kunt niet iteren tot het klopt als je niet meet of het klopt. You cannot iterate until it is right if you do not measure whether it is right.

Dit is precies het idee uit onze compressie-notitie, maar dan op onszelf toegepast: cross-entropy / perplexity is de afstand tussen wat een model zegt en de werkelijkheid. Een testbank meet diezelfde afstand op taakniveau. We hebben de theorie al; nu de meetopstelling. This is exactly the idea from our compression note, turned on ourselves: cross-entropy / perplexity is the distance between what a model says and reality. A test harness measures that same distance at the task level. We already have the theory; now the measurement rig.

2Wat we adopteren, en waarom juist ditWhat we adopt, and why exactly this

Grappig detail: het bruikbaarste stuk stond niet eens op de sponsorlijst. METR (een sponsor) wijst zelf naar Inspect. We volgden het spoor tot het echte gereedschap. A funny detail: the most useful piece was not even on the sponsor list. METR (a sponsor) now points to Inspect itself. We followed the trail to the real tool.

3Waar het in onze stack pastWhere it fits in our stack

Inspect zit náást onze orchestrator, niet erin. Opus blijft de baas die taken uitdeelt en oordeelt; Inspect is de onafhankelijke meetbank die elk model door dezelfde taken haalt. De scorer blijft een harde check (draait de STAR-macro headless, slaagt de test) en een eventuele LLM-judge draait op een ander merk dan het geteste model. Zo blijft generator ≠ verifier overeind. Inspect sits beside our orchestrator, not inside it. Opus stays the boss that hands out and judges tasks; Inspect is the independent bench that runs every model through the same tasks. The scorer stays a hard check (does the STAR macro run headless, does the test pass) and any LLM judge runs on a different vendor than the model under test. That keeps generator ≠ verifier intact.

4Concreet: vier voorbeeldenConcrete: four examples

a · Een STAR-CCM+ macro-taak die zichzelf scoorta · A STAR-CCM+ macro task that scores itself

De agent schrijft een macro; de scorer draait 'm headless op deze host en checkt of het echt werkt. Geen mening, een feit.The agent writes a macro; the scorer runs it headless on this host and checks it actually works. Not an opinion, a fact.

# pip install inspect-ai   (Windows, Python 3.12 — draait lokaal)
from inspect_ai import Task, task
from inspect_ai.dataset import json_dataset
from inspect_ai.solver import system_message, generate
from inspect_ai.scorer import scorer, Score, Target, accuracy, CORRECT, INCORRECT
import subprocess, re, pathlib

def run_macro_headless(java: str) -> bool:
    # schrijf .java, draai STAR-CCM+ 21.02 -batch, check exit + verwacht resultaat
    p = pathlib.Path("_eval/gen.java"); p.write_text(java, encoding="utf-8")
    r = subprocess.run(["starccm+", "-batch", str(p), "-np", "4"],
                       capture_output=True, text=True, timeout=1800)
    return r.returncode == 0 and "Command finished" in r.stdout

@scorer(metrics=[accuracy()])
def macro_runs():
    async def score(state, target: Target) -> Score:
        java = re.search(r"```java(.*?)```", state.output.completion, re.S)
        ok = run_macro_headless(java.group(1)) if java else False
        return Score(value=CORRECT if ok else INCORRECT)
    return score

@task
def starccm_macros():
    return Task(
        dataset=json_dataset("starccm_tasks.jsonl"),   # onze eigen taakset
        solver=[system_message("Je schrijft STAR-CCM+ 21.02 Java-macros. Gebruik de geverifieerde API."),
                generate()],
        scorer=macro_runs(),
    )

b · Elke agent door dezelfde taken → leaderboardb · Every agent through the same tasks → leaderboard

from inspect_ai import eval

eval("tasks/starccm_macros.py", model=[
    "openai/qwen-coder-awq",        # lokale Qwen op Thor (OpenAI-compat, base_url=THOR-LAN:8000)
    "anthropic/claude-opus-4-8",
    "google/gemini-3.1-pro-preview",
    "openai/gpt-5.5",
])
# → inspect view  opent een web-UI met de score per model, per taak, klikbaar.

c · METR-tijdshorizon: worden we beter over de tijd?c · METR time-horizon: are we improving over time?

Meet één keer hoe lang een mens over elke taak doet. Fit dan slaagkans vs log(mensentijd). Het punt waar de curve 50% kruist = de "tijdshorizon" van de agent. Eén getal, herhaalbaar bij elke modelwissel.Measure once how long a human takes per task. Then fit success-rate vs log(human-time). The point where the curve crosses 50% = the agent's "time horizon". One number, repeatable on every model swap.

import numpy as np
from scipy.optimize import curve_fit

def logistic(log_t, k, t50): return 1 / (1 + np.exp(k*(log_t - t50)))

# human_minutes + pass(0/1) per taak, uit de Inspect-run
popt, _ = curve_fit(logistic, np.log(human_minutes), passed, p0=[1.0, 2.0])
horizon_min = np.exp(popt[1])
print(f"50%-tijdshorizon: {horizon_min:.0f} min mensen-werk")

d · Docent: een faalpatroon uit duizenden runs vissend · Docent: fishing a failure pattern out of thousands of runs

Voed onze multi-agent transcripten in Docent, schrijf een "rubric" in gewone taal, en krijg een gekwantificeerd percentage + klikbare voorbeelden. Direct bewijs voor de Sacred Rule.Feed our multi-agent transcripts into Docent, write a plain-language "rubric", and get a quantified rate + clickable examples. Direct evidence for the Sacred Rule.

# zelf-gehost (docker-compose + Postgres), judge → lokale Qwen
rubric: "Markeer elke run waarin de generator stil naar een
        zwakker model downgradede, of de verifier een
        geplante bug miste."
# → Docent scoort alle runs, geeft % + de exacte stappen waar het misging.

5Uitrol in fasenPhased rollout

6Hoe het ons sterker maaktHow it strengthens us

We stoppen met raden of we beter worden, en gaan het meten. Dat is de Iterate-Until-Right-lus met eindelijk een echte meter. We stop guessing whether we are improving and start measuring it. That is the Iterate-Until-Right loop with, at last, a real gauge.

7Bewakingen (zodat het niet tegen ons werkt)Guards (so it does not backfire)

• Privacy-muur. Docent's judge kan inhoud naar een externe LLM sturen. Eerst verifiëren dat we 'm op lokale Qwen (Thor :8000) kunnen richten; tot dan alleen geschoonde/externe runs, nooit F:/-interne data of geheimen.Privacy wall. Docent's judge may send content to an external LLM. First verify we can point it at local Qwen (Thor :8000); until then only scrubbed/external runs, never F:/ internal data or secrets.
• Scorer blijft hard. De kern-score is een programmacheck (macro draait, test slaagt). Een LLM-judge mag alleen aanvullen, en draait op een ánder merk dan het geteste model.Scorer stays hard. The core score is a program check (macro runs, test passes). An LLM judge may only supplement, and runs on a different vendor than the model under test.
• Geen platform-moeras. We nemen Inspect (licht, pip) en niet Vivaria (zwaar, wordt afgebouwd). RE-Bench alleen als inspiratie voor taakontwerp.No platform swamp. We take Inspect (light, pip), not Vivaria (heavy, being deprecated). RE-Bench only as inspiration for task design.
• Taken die er toe doen. De suite meet ónze echte taken (STAR-macro's, CFD-glue, research), niet een generieke benchmark die niets over ons werk zegt.Tasks that matter. The suite measures our real tasks (STAR macros, CFD glue, research), not a generic benchmark that says nothing about our work.

Volgende stapNext step

Zeg het woord en ik zet Fase 0+1 op: Inspect geïnstalleerd, lokale Qwen als provider, en de eerste STAR-macro-scorer groen op een handvol echte taken. Dan heb je binnen een dag het eerste mini-leaderboard om naar te kijken. Say the word and I stand up Phase 0+1: Inspect installed, local Qwen as a provider, and the first STAR-macro scorer green on a handful of real tasks. You would have a first mini-leaderboard to look at within a day.