Building the veteran

TL;DR

Stanford's new course on self-improving agents describes the machinery underneath LAG. A loop with four verbs, generate, verify, capture, distil. In practice that means a gateway, workflow graphs in version control, a trace store, an inventory of the client's native verifiers, a frozen golden set that turns the learning claim into a nightly chart, sampling as a quality dial, an exception desk whose corrections train the next adapter, and a migration ritual that keeps the model swappable. The machinery is public now. The strategic question is where the loop lives and who keeps what it learns.

Stanford now teaches a course on self-improving AI agents. CS329A, autumn quarter, taught by two researchers whose careers run through Google Brain and the frontier labs. The first lecture walks through how a language model becomes a system that gets better at its job by doing its job. I read the transcript twice, because the machinery it describes, sampling, verifiers, feedback loops, distillation, is the machinery this series wagered on back in its second essay. The wager now has a syllabus. That seems like the right moment to take the lid off ours and show how the loop actually gets built inside a client.

The lecture's most useful result goes by the name Large Language Monkeys, after the infinite monkey theorem. A small open model, asked once, loses to the frontier model. The same small model, asked ten thousand times with a verifier picking through the answers, beats it. Two lessons sit in that graph. Models know far more than any single answer reveals. And the scarce ingredient is not the model at all. It is the verifier, the thing that knows which of ten thousand attempts was right.

Four verbs

Everything in the course, and everything in our practice, reduces to a loop with four verbs. Generate, where the system samples the model, once for easy work, many times in parallel for hard work. Verify, where outputs meet something that knows right from wrong. Capture, where every attempt, verdict and human correction is recorded as data the client owns. Distil, where the verified work folds back into the model on a schedule, so next week's system has absorbed this week's lessons. The reasoning models everyone admires were built by exactly this loop run at lab scale. LAG is the same loop run at company scale, inside the company's walls.

In production the loop is unglamorous plumbing. One gateway that every model call passes through, so cost, logging and model choice live in one place. Workflows declared as graphs in version control, readable like pipelines, changed by reviewable diffs, never improvising in production. A trace store that records each decision with its full context. Verifiers wired into the graph. A review queue for what fails. A weekly training job. A web engineer would recognise every part, the proxy, the pipeline, the test suite, the queue. Only two things are genuinely new. The worker in the middle is non-deterministic. And the logs feed back into the worker. The first is why the checking matters so much. The second is why the system compounds while ordinary software just runs.

The verifier estate

Here is the thing the lecture circles and enterprises miss. A company is full of verifiers that nobody calls verifiers. Reconciliations that must balance. Invoices that must match purchase orders. Policies that are rules, and rules that are checkable. Service levels with numbers attached. This estate decides everything, because wherever a hard check exists the loop spins fast and unsupervised, and wherever one does not, a model judges with a written rubric and humans spot-check the judge. The first act of an engagement is not a model choice. It is an inventory of the client's verifiers.

The map of a company's verifiers is the map of where learning is cheap.

The Stanford pair name the failure mode politely, the generator-verifier gap. It is easy to make a model produce plausible content at scale, and hard to know whether the content is right. Most in-house AI programmes we meet live on the wrong side of that gap. They scaled generation in their first quarter and left verification for later, and later never came. The chatbots got fluent. Nobody can say whether they got better.

Measurement gets the same discipline. From the client's history we take a few hundred cases where the right answer is known, freeze them, and never train on them. Every night the system runs against this golden set and a chart moves, or does not. Our second essay promised that the answer in March would be better than the answer in January, measurably. The golden set is the instrument that keeps the promise honest. A claim becomes a chart, and the chart is the product.

The dial and the desk

Non-determinism, the property everyone complains about, turns out to be the asset. The system asks the model once for routine work. For the decision that moves money, it asks fifty times in parallel and lets the verifier pick the survivor. Quality stops being a fixed property of a model and becomes a dial, priced by what the decision is worth. A router does the same for cost, cheap model first, escalation on failure, so the expensive intelligence is spent only on the hard tail.

What fails everything lands on a desk, in front of a person, in a tool built for correcting. The correction is stored with the case as labelled data. The last essay argued that the new grunt work is assurance, the humans who keep the machine worth trusting. Here is the closing of that circle. The exception desk is not a cost centre beside the loop. It is the loop's teacher. A correction made on Tuesday is in the training run on Friday and absorbed by Monday. The pager holders are not guarding the veteran. They are raising it.

The distillation

The weekly job gathers what survived, outputs the verifiers passed and outputs a human repaired, and trains a small adapter on open weights running on the client's own infrastructure. One detail from the lecture matters more than it looks. Models learn better from their own reasoning traces than from a bigger model's, provided the traces are filtered by outcome. So the veteran trains on its own verified work, not on a frontier model's imported homework. Adapters, on your weights, on your metal. The file that results is small enough to email and worth more than the platform it runs on, because it encodes how this company, specifically, does things.

For the work no rule can check, taste gets captured instead. The client's best people spend a few weeks answering one question, A or B, which answer is better, a few thousand times. A small reward model trains on those choices and becomes an automated approximation of their judgment, good enough to pick winners at scale and to decide which problems deserve more attempts. This is the mechanism that made chatbots helpful, shrunk to the scale of one company's standards.

And the model underneath stays a cartridge. When a provider ships a new one, it runs in shadow against the golden set. If the chart improves, the gateway swaps it in, and the graph, the traces, the adapters and the benchmark all carry over untouched. Migration stops being an emergency and becomes a monthly ritual with a report. Swap the model, keep the veteran, stops being an aspiration and becomes a procedure.

What it asks

There is a client's side to the bargain, and honesty about it belongs in the open. The first weeks are plumbing and look like plumbing. The loop needs a few hundred historical cases with known outcomes, experts willing to click A or B, and an executive who wants a meter more than a demo. The craft, and there is real craft, lives in curating what goes into each training run, which is where our people earn their keep. And the client's own engineers sit inside the build from the first week, because the capability has to stay when we go. That is not generosity. It is the only version of this that passes the test this series keeps writing about.

The machinery is public now. Stanford teaches it to a lecture hall every autumn, the papers are on the course website, and every vendor in the market has read them too. What the course does not teach, because it is not a technical question, is where the loop should live. The same four verbs can run in a vendor's cloud, learning from your work for their benefit, or inside your walls, compounding into a veteran you own. The machinery stopped being proprietary the day it became a syllabus. The only strategic thing left is the address.